스냅샷 API#

녹화 컴포넌트에서 제공하는 takeRecordingSnapshot과는 별개로 직접 카메라 이미지를 캡춰합니다.

스냅샷 API는 Non-blocking 방식과 Blocking 방식이 있습니다.

• Photographer 객체를 생성하고 PhotographerObserver 인터페이스를 사용하는 방식으로 캡쳐 파일을 계속 생성할 수 있습니다.
• takePicture 함수를 호출하여 스냅샷이 완료될 때까지 기다리는 방식으로 캡춰 파일을 하나만 생성할 수 있습니다.

헤더 파일#

OasisMedia.h

Blocking 함수#

Blocking 방식으로 스냅샷 데이터를 생성합니다. 스냅샷이 완료되거나 타임아웃이 발생할 때까지 기다립니다.

스냅샷 생성에 필요한 key-value map은 아래와 같습니다.

JPEG 이미지 생성 시 아래 EXIF 태깅 패러미터를 지정할 수 있습니다.

Non-Blocking 함수#

사용자는 createPhotographer로 Photographer 객체를 생성합니다. 이후 startPhotographer 로 시작한 후, 스냅샷이 필요할 경우 마다 photographerGeneratePicture를 호출합니다. Photographer를 사용을 마치려면, stopPhotographer를 호출합니다.

PhotographerObserver 인터페이스#

createPhotographer 호출 시에 매개변수로 PhotographerObserver을 base class로 정의한 사용자 인터페이스 객체를 전달합니다. 이후 콜백함수를 통하여 스냅샷 작업을 수행합니다.

class PhotographerObserver : public std::enable_shared_from_this<PhotographerObserver>
{
public:
  PhotographerObserver();
  virtual ~PhotographerObserver();

  virtual void onCameraSensorMetaData(int32_t camera_id, const CameraSensorMetaData &metadata);
  virtual void onIspMetaData(int32_t camera_id, const IspMetaData &metadata);

  virtual void onCaptureImageAvailable(bool subchannel_image);
  virtual void onImageDataCompleted(const key_value_map_t &parameters, bool subchannel_image, int32_t width, int32_t height, int32_t format, const std::vector<char> &data);
  virtual void onImageDataCompletedWithError(const key_value_map_t &parameters, bool subchannel_image, int32_t error);

};

Photographer API#

아래 key-value map 으로 옵션 사항입니다. 이외에 osd 관련 패러미터와 EXIF 관련 패러미터를 지정할 수 있습니다.

​

예제#

선택한 카메라 장치로 부터 영상을 캡춰하고 OSD를 적용한 다음 JPEG 파일을 생성하는 예입니다. -a 옵션을 선택할 경우, Non-Blocking 함수를 사용합니다. Non-Blocking 함수를 적용할 경우, 1초 간격으로 각기 다른 OSD 텍스트를 지정하여 2회 스냅샷을 생성합니다.

#include "OasisAPI.h"
#include "OasisLog.h"
#include "OasisMedia.h"
#include "OasisUI.h"
#include "OasisUtil.h"
#include "OasisDisplay.h"

#include <thread>
#include <mutex>
#include <memory>
#include <condition_variable>

#include <signal.h>

#define DLOG_APP    0x00010000

#undef DLOG_FLAGS
#define  DLOG_FLAGS (DLOG_FLAGS_DEFAULT|DLOG_APP/**/)

using namespace oasis;


static bool continue_capturing = true;

enum {
  kCaptureStateIdle = 0,
  kCaptureStateImageAvailable,
  kCaptureStateImageDataReady,
  kCaptureStateError,
};

static std::list<int32_t> capture_state_q;

static std::mutex capture_mutex;
static std::condition_variable capture_cond;
static std::vector<char> captured_image_data;

void cancel_handler(int signum)
{
  continue_capturing = false;
  capture_cond.notify_one();
}


class MyPhotographerObserver : public PhotographerObserver
{
public:
  MyPhotographerObserver() {}
  virtual ~MyPhotographerObserver() {}

  virtual void onCameraSensorMetaData(int32_t camera_id, const CameraSensorMetaData &metadata) {}
  virtual void onIspMetaData(int32_t camera_id, const IspMetaData &metadata) {}

  virtual void onCaptureImageAvailable(bool subchannel_image);
  virtual void onImageDataCompleted(const key_value_map_t &parameters, bool subchannel_image, int32_t width, int32_t height, int32_t format, const std::vector<char> &data);
  virtual void onImageDataCompletedWithError(const key_value_map_t &parameters, bool subchannel_image, int32_t error);

};


void MyPhotographerObserver::onCaptureImageAvailable(bool subchannel_image)
{
  fprintf(stdout, ">>> image available\n");
  {
    std::lock_guard<std::mutex> lock(capture_mutex);
    capture_state_q.push_back(kCaptureStateImageAvailable);
  }
  capture_cond.notify_one();
}

void MyPhotographerObserver::onImageDataCompleted(const key_value_map_t &parameters, bool subchannel_image, int32_t width, int32_t height, int32_t format, const std::vector<char> &data)
{
  fprintf(stdout, ">>>>> image data completed: %dx%d, format %d, data size %zd\n", width, height, format, data.size());
  {
    std::lock_guard<std::mutex> lock(capture_mutex);
    capture_state_q.push_back(kCaptureStateImageDataReady);
    captured_image_data = data;
  }
  capture_cond.notify_one();
}

void MyPhotographerObserver::onImageDataCompletedWithError(const key_value_map_t &parameters, bool subchannel_image, int32_t error) 
{
  fprintf(stdout, ">>>>> image data completed with error: %d\n", error);
  {
    std::lock_guard<std::mutex> lock(capture_mutex);
    capture_state_q.push_back(kCaptureStateError);
  }
  capture_cond.notify_one();
}

void print_usage(const char *prog_name)
{
  fprintf(stdout, "USAGE: %s [-a] [-w width] [-h height] [-q quality] [-t wait-timeout in seconds] [-s skip frame count] <camera id> <output-jpeg-file-path>\n", prog_name);
}

int main(int argc, char* argv[])
{
  int32_t err, opt;
  int32_t camera_id = 0, width = 0, height = 0, wait = 5, quality = 100, skip = 6;
  char output_path[PATH_MAX];
  bool use_async = false;

  while((opt = getopt(argc, argv, "aw:h:q:t:s:")) != -1 ) {
    switch ( opt ) {
    case 'a':
      use_async = true;
      break;
    case 'w':
      if(optarg == nullptr) {
        print_usage(argv[0]);
        return -1;
      }
      width = atoi(optarg);
      break;
    case 'h':
      if(optarg == nullptr) {
        print_usage(argv[0]);
        return -1;
      }
      height = atoi(optarg);
      break;
    case 'q':
      if(optarg == nullptr) {
        print_usage(argv[0]);
        return -1;
      }
      quality = atoi(optarg);
      if(quality > 100) quality = 100;
      else if(quality < 0) quality = 1;
      break;
    case 't':
      if(optarg == nullptr) {
        print_usage(argv[0]);
        return -1;
      }
      wait = atoi(optarg);
      break;
    case 's':
      if(optarg == nullptr) {
        print_usage(argv[0]);
        return -1;
      }
      skip = atoi(optarg);
      break;
    default:
      fprintf(stderr, "error: unknown option '%c'\n", optopt);
      print_usage(argv[0]);
      return -1;
    }
  }

  if(argc-optind < 2) {
    fprintf(stderr, "error: invalid or insufficient arguments\n");
    print_usage(argv[0]);
    return -1;
  }

  camera_id = atoi(argv[optind]);
  strncpy(output_path, argv[optind+1], sizeof(output_path)-1);

  TRACE0("camera %d, size %dx%d, quality %d, wait timeout %d, skip %d frames, save to %s\n", camera_id, width, height, quality, wait, skip, output_path);

  signal(SIGINT, cancel_handler);

   ////////////////////////////////////////////////////////////////////////////////////////////
  // init

  oasis::key_value_map_t parameters;

  parameters["offs-disable"] = "1";         
  //parameters["oasis-log-flags"] = std::to_string(OASIS_LOG_DEBUG/*|OASIS_LOG_ENCODE_BITRATE*/);

  if(oasis::initialize(parameters) < 0) {
    DLOG(DLOG_ERROR, "Oasis init failed\n");
    return -1;
  }

  ////////////////////////////////////////////////////////////////////////////////////////////
  // config cameras
  parameters.clear();


  parameters["source-count"] = "1";

  parameters["source1-camera-id"] = "0";
  parameters["source1-isp-id"] = "0";
  parameters["source1-isp-wdr-mode"] = "0";
  parameters["source1-capture-format"] = "YUV420";
  parameters["source1-capture-buffers"] = "5";
  parameters["source1-fps"] = "30";
  parameters["source1-subchannel-rotation"] = "0";
  parameters["source1-loc"] = "front";
  parameters["source1-capture-resolution"] = "1080p";
  parameters["source1-sensor-config"] = "./Resource_tp2863/VIC/0/tp2863_1920x1080_ch0.cfg";
  parameters["source1-autoscene-config"] = "./Resource_tp2863/AutoScene/autoscene_conf.cfg";
  parameters["source1-resource-dir"] = "./Resource_tp2863/";

  configCameras(parameters);


  ////////////////////////////////////////////////////////////////////////////////////////////
  // display setup
  parameters.clear();

  parameters["memory-type"] = "ion"; //cma
  parameters["screen-width"] = "480";
  parameters["screen-height"] = "320";

  display::setup(parameters);


  ////////////////////////////////////////////////////////////////////////////////////////////

  parameters["camera-id"] = std::to_string(camera_id);
  parameters["width"] = std::to_string(width);
  parameters["height"] = std::to_string(height);
  parameters["quality"] = std::to_string(quality);
  parameters["timeout"] = std::to_string(wait*1000);
  parameters["drop-frame-count"] = std::to_string(skip);

  if(use_async) {

    std::shared_ptr<MyPhotographerObserver> observer = std::make_shared<MyPhotographerObserver>();
    PhotographerRef photographer = createPhotographer(camera_id, parameters, observer);

    if(photographer) {

      parameters.clear();
      //parameters["jpeg-quality"] = std::to_string(quality);
      startPhotographer(photographer);

      bool is_capturing = false;
      int32_t image_count = 0;

      do {

        int32_t state;

        {
          std::unique_lock<std::mutex> lock(capture_mutex);
          while(continue_capturing && capture_state_q.empty()) {
            if(wait > 0) {
              std::cv_status status = capture_cond.wait_for(lock, std::chrono::seconds(wait));
              if(status == std::cv_status::timeout) {
                fprintf(stderr, "wait for image available timeout\n");
                continue_capturing = false;
                break;
              }
            } else {
              capture_cond.wait(lock);
            }
          }
          if(capture_state_q.empty()) {
            continue;
          } else {
            state = capture_state_q.front();
            capture_state_q.pop_front();
          }
        }

        auto triggerSnapshot = [&](int32_t image_index) -> int32_t {

          key_value_map_t parameters;

          time_t tm;
          struct tm tm_t;
          std::string osd_string;

          time(&tm);
          localtime_r(&tm, &tm_t);

          osd_string = oasis::format("snapshot<%d> %4d/%02d/%02d %02d:%02d:%02d", image_index, tm_t.tm_year + 1900, tm_t.tm_mon + 1, tm_t.tm_mday, tm_t.tm_hour, tm_t.tm_min, tm_t.tm_sec);

          parameters["osd"] = osd_string;
          parameters["osd-font-size"] = "26";
          parameters["osd-font-face"] = "Consolas";
          parameters["osd-text-color"] = "255,255,255";
          parameters["osd-use-text-color"] = "1";
          parameters["osd-use-bg-color"] = "0";
          parameters["osd-bg-color"] = "0,0,0";
          parameters["osd-use-outline-color"] = "1";
          parameters["osd-outline-color"] = "0,0,0";
          parameters["osd-horz-align"] = "left";
          parameters["osd-vert-align"] = "bottom";
          parameters["osd-font-path"] = "/mnt/sd/consola.ttf";
          parameters["osd-use-fixed-size"] = "0";

          return photographerGeneratePicture(photographer, parameters, false, nullptr, 0);
        };  

        if(state == kCaptureStateImageAvailable) {
          if(is_capturing == false) {
            is_capturing = 0 ==  triggerSnapshot(image_count);
            if(!is_capturing) {
              fprintf(stderr, "failed to generate picture\n");
              break;
            } else {
              image_count++;
            }
          }
        } else if(state == kCaptureStateImageDataReady) {
          if(captured_image_data.empty() == false) {

            std::string path = output_path;
            size_t dot_pos = path.find_last_of(".");
            std::string prefix = dot_pos != std::string::npos ? path.substr(0, dot_pos) : path;
            std::string suffix = dot_pos != std::string::npos ? path.substr(dot_pos) : "";
            std::string this_image_path = prefix + "_" + std::to_string(image_count) + suffix;
            FILE *fp = fopen(this_image_path.c_str(), "wb");
            if(fp) {
              size_t n, len;
              for(n=0; n<captured_image_data.size(); n += len) {
                len = fwrite( captured_image_data.data()+n, 1, captured_image_data.size()-n, fp );
                if(len == 0) break;
              }
              fclose(fp);
              DLOG0(DLOG_INFO, "%s saved\n", this_image_path.c_str());
            }
          }
          is_capturing = false;

          if(image_count == 2) {
            break;
          } else {
            //take another picture
            usleep(1000000);
            if(is_capturing == false) {
              is_capturing = 0 ==  triggerSnapshot(image_count);
              if(!is_capturing) {
                fprintf(stderr, "failed to generate picture\n");
                break;
              } else {
                image_count++;
              }
            }
          }
        } else if(state == kCaptureStateError) {
          is_capturing = false;
          break;
        }
      } while (continue_capturing);

      stopPhotographer(photographer);
      destroyPhotographer(photographer);
    }

  } else {

    time_t tm;
    struct tm tm_t;
    std::string osd_string;

    time(&tm);
    localtime_r(&tm, &tm_t);

    osd_string = oasis::format("%4d/%02d/%02d %02d:%02d:%02d 12.0V 12H/11.9V", tm_t.tm_year + 1900, tm_t.tm_mon + 1, tm_t.tm_mday, tm_t.tm_hour, tm_t.tm_min, tm_t.tm_sec);

    parameters["osd"] = osd_string;
    parameters["osd-font-size"] = "16";
    parameters["osd-font-face"] = "Consolas";
    parameters["osd-text-color"] = "255,255,255";
    parameters["osd-use-text-color"] = "1";
    parameters["osd-use-bg-color"] = "0";
    parameters["osd-bg-color"] = "0,0,0";
    parameters["osd-use-outline-color"] = "1";
    parameters["osd-outline-color"] = "0,0,0";
    parameters["osd-horz-align"] = "left";
    parameters["osd-vert-align"] = "bottom";
    parameters["osd-font-path"] = "/mnt/sd/consola.ttf";
    parameters["osd-use-fixed-size"] = "0";

    err = takePicture(camera_id, parameters, captured_image_data);

    if(err == 0) {
      DLOG0(DLOG_INFO, "snapshot jpeg data %d bytes returned\n", captured_image_data.size());
      FILE *fp = fopen(output_path, "wb");
      if(fp) {
        size_t n, len;
        for(n=0; n<captured_image_data.size(); n += len) {
          len = fwrite( captured_image_data.data()+n, 1, captured_image_data.size()-n, fp );
          if(len == 0) break;
        }
        fclose(fp);
        DLOG0(DLOG_INFO, "%s saved\n", output_path);
      }
    } else {
      DLOG0(DLOG_ERROR, "error %d\n", err);
    }

  }



  oasis::finalize();

  return 0;
}