dji_camera_module.hpp

Go to the documentation of this file.

#ifndef ONBOARDSDK_DJI_CAMERA_MODULE_HPP
#define ONBOARDSDK_DJI_CAMERA_MODULE_HPP

#include "dji_command.hpp"
#include "dji_payload_base.hpp"
#include "dji_type.hpp"
#include "dji_vehicle_callback.hpp"

namespace DJI {
namespace OSDK {
class CameraModule : public PayloadBase {
 public:
  enum WorkMode {
    SHOOT_PHOTO = 0,
    RECORD_VIDEO = 1,
    PLAYBACK = 2,
    MEDIA_DOWNLOAD = 3,
    BROADCAST = 4,
    WORK_MODE_UNKNOWN = 0xFF,
  };

  enum ShootPhotoMode {
    SINGLE = DJI_CAMERA_TAKE_PHOTO_TYPE_NORMAL,
    HDR = DJI_CAMERA_TAKE_PHOTO_TYPE_HDR,
    BURST = DJI_CAMERA_TAKE_PHOTO_TYPE_BURST,
    AEB = DJI_CAMERA_TAKE_PHOTO_TYPE_AEB,
    INTERVAL = DJI_CAMERA_TAKE_PHOTO_TYPE_TIME_LAPSE,
    RAW_BURST = DJI_CAMERA_TAKE_PHOTO_TYPE_RAW_BURST,
    EHDR = DJI_CAMERA_TAKE_PHOTO_TYPE_EHDR,
    REGIONAL_SR = 0x16,
    SHOOT_PHOTO_MODE_UNKNOWN = 0xFF,
  };

  enum ContiCapMode {
    CONTI_CAP_SINGLE = 0, 
    CONTI_CAP_MULTIPLE =
        1, 
    CONTI_CAP_TIMELAPSE = 2, 
  };

  enum ExposureMode {
    PROGRAM_AUTO = 1,       
    SHUTTER_PRIORITY = 2,   
    APERTURE_PRIORITY = 3,  
    EXPOSURE_MANUAL = 4,    
    EXPOSURE_UNKNOWN = 0xFF 
  };

  enum PhotoAEBCount {
    AEB_COUNT_3 = 3,
    AEB_COUNT_5 = 5,
    AEB_COUNT_7 = 7,
    AEB_COUNT_KNOWN = 0xFF,
  };

  enum PhotoBurstCount {
    BURST_COUNT_2 = 2,
    BURST_COUNT_3 = 3,
    BURST_COUNT_5 = 5,
    BURST_COUNT_7 = 7,
    BURST_COUNT_10 = 10,
    BURST_COUNT_14 = 14,
    BURST_COUNT_KNOWN = 0xFF,
  };
  enum FocusMode {
    MANUAL = 0,
    AUTO = 1,
    AFC = 2,
    FOCUS_MODE_UNKNOWN = 0xFFFF,
  };

  enum ShutterMode {
    SHUTTER_AUTO_MODE = 0x00,
    SHUTTER_MANUAL_MODE = 0x01,
  };

  enum ShutterSpeed {
    SHUTTER_SPEED_1_8000 = 0,     
    SHUTTER_SPEED_1_6400 = 1,     
    SHUTTER_SPEED_1_6000 = 2,     
    SHUTTER_SPEED_1_5000 = 3,     
    SHUTTER_SPEED_1_4000 = 4,     
    SHUTTER_SPEED_1_3200 = 5,     
    SHUTTER_SPEED_1_3000 = 6,     
    SHUTTER_SPEED_1_2500 = 7,     
    SHUTTER_SPEED_1_2000 = 8,     
    SHUTTER_SPEED_1_1600 = 9,     
    SHUTTER_SPEED_1_1500 = 10,    
    SHUTTER_SPEED_1_1250 = 11,    
    SHUTTER_SPEED_1_1000 = 12,    
    SHUTTER_SPEED_1_800 = 13,     
    SHUTTER_SPEED_1_725 = 14,     
    SHUTTER_SPEED_1_640 = 15,     
    SHUTTER_SPEED_1_500 = 16,     
    SHUTTER_SPEED_1_400 = 17,     
    SHUTTER_SPEED_1_350 = 18,     
    SHUTTER_SPEED_1_320 = 19,     
    SHUTTER_SPEED_1_250 = 20,     
    SHUTTER_SPEED_1_240 = 21,     
    SHUTTER_SPEED_1_200 = 22,     
    SHUTTER_SPEED_1_180 = 23,     
    SHUTTER_SPEED_1_160 = 24,     
    SHUTTER_SPEED_1_125 = 25,     
    SHUTTER_SPEED_1_120 = 26,     
    SHUTTER_SPEED_1_100 = 27,     
    SHUTTER_SPEED_1_90 = 28,      
    SHUTTER_SPEED_1_80 = 29,      
    SHUTTER_SPEED_1_60 = 30,      
    SHUTTER_SPEED_1_50 = 31,      
    SHUTTER_SPEED_1_40 = 32,      
    SHUTTER_SPEED_1_30 = 33,      
    SHUTTER_SPEED_1_25 = 34,      
    SHUTTER_SPEED_1_20 = 35,      
    SHUTTER_SPEED_1_15 = 36,      
    SHUTTER_SPEED_1_12DOT5 = 37,  
    SHUTTER_SPEED_1_10 = 38,      
    SHUTTER_SPEED_1_8 = 39,       
    SHUTTER_SPEED_1_6DOT25 = 40,  
    SHUTTER_SPEED_1_5 = 41,       
    SHUTTER_SPEED_1_4 = 42,       
    SHUTTER_SPEED_1_3 = 43,       
    SHUTTER_SPEED_1_2DOT5 = 44,   
    SHUTTER_SPEED_1_2 = 45,       
    SHUTTER_SPEED_1_1DOT67 = 46,  
    SHUTTER_SPEED_1_1DOT25 = 47,  
    SHUTTER_SPEED_1 = 48,         
    SHUTTER_SPEED_1DOT3 = 49,     
    SHUTTER_SPEED_1DOT6 = 50,     
    SHUTTER_SPEED_2 = 51,         
    SHUTTER_SPEED_2DOT5 = 52,     
    SHUTTER_SPEED_3 = 53,         
    SHUTTER_SPEED_3DOT2 = 54,     
    SHUTTER_SPEED_4 = 55,         
    SHUTTER_SPEED_5 = 56,         
    SHUTTER_SPEED_6 = 57,         
    SHUTTER_SPEED_7 = 58,         
    SHUTTER_SPEED_8 = 59,         
    SHUTTER_SPEED_9 = 60,         
    SHUTTER_SPEED_10 = 61,        
    SHUTTER_SPEED_13 = 62,        
    SHUTTER_SPEED_15 = 63,        
    SHUTTER_SPEED_20 = 64,        
    SHUTTER_SPEED_25 = 65,        
    SHUTTER_SPEED_30 = 66,        
    SHUTTER_SPEED_UNKNOWN = 0xFF, 
  };

  enum ISO {
    ISO_AUTO = DJI_CAMERA_ISO_PARAMETER_AUTO,
    ISO_100 = DJI_CAMERA_ISO_PARAMETER_100,
    ISO_200 = DJI_CAMERA_ISO_PARAMETER_200,
    ISO_400 = DJI_CAMERA_ISO_PARAMETER_400,
    ISO_800 = DJI_CAMERA_ISO_PARAMETER_800,
    ISO_1600 = DJI_CAMERA_ISO_PARAMETER_1600,
    ISO_3200 = DJI_CAMERA_ISO_PARAMETER_3200,
    ISO_6400 = DJI_CAMERA_ISO_PARAMETER_6400,
    ISO_12800 = DJI_CAMERA_ISO_PARAMETER_12800,
    ISO_25600 = DJI_CAMERA_ISO_PARAMETER_25600,
    ISO_FIXED = DJI_CAMERA_ISO_PARAMETER_FIXED,
    ISO_UNKNOWN = 0xFFFF,
  };

  enum ExposureCompensation {
    N_5_0 = 1,
    N_4_7 = 2,
    N_4_3 = 3,
    N_4_0 = 4,
    N_3_7 = 5,
    N_3_3 = 6,
    N_3_0 = 7,
    N_2_7 = 8,
    N_2_3 = 9,
    N_2_0 = 10,
    N_1_7 = 11,
    N_1_3 = 12,
    N_1_0 = 13,
    N_0_7 = 14,
    N_0_3 = 15,
    N_0_0 = 16,
    P_0_3 = 17,
    P_0_7 = 18,
    P_1_0 = 19,
    P_1_3 = 20,
    P_1_7 = 21,
    P_2_0 = 22,
    P_2_3 = 23,
    P_2_7 = 24,
    P_3_0 = 25,
    P_3_3 = 26,
    P_3_7 = 27,
    P_4_0 = 28,
    P_4_3 = 29,
    P_4_7 = 30,
    P_5_0 = 31,
    FIXED = 0xFF,
    UNKNOWN = 0xFFFF,
  };

  enum FunctionID {
    FUNCTION_SIMPLE_SHOT = 0,
    FUNCTION_RECORD_VIDEO = 1,
    FUNCTION_SET_WORKING_MODE = 3,
    FUNCTION_GET_WORKING_MODE = 4,
    FUNCTION_SET_FOCUS_PARAMETER = 7,
    FUNCTION_SET_EXPOSURE_MODE = 8,
    FUNCTION_GET_EXPOSURE_MODE = 9,
    FUNCTION_SET_FOCUS_MODE = 10,
    FUNCTION_GET_FOCUS_MODE = 11,
    FUNCTION_SET_EV_PARAMETER = 12,
    FUNCTION_GET_EV_PARAMETER = 13,
    FUNCTION_GET_FOCUS_PARAMETER = 14,
    FUNCTION_SET_POINT_ZOOM_MODE = 15,
    FUNCTION_GET_POINT_ZOOM_MODE = 16,
    FUNCTION_POINT_ZOOM_CTRL = 17,
    FUNCTION_SET_ZOOM_PARAMETER = 19,
    FUNCTION_GET_ZOOM_PARAMETER = 20,
    FUNCTION_SET_ISO_PARAMETER = 22,
    FUNCTION_GET_ISO_PARAMETER = 23,
    FUNCTION_SET_SHUTTER_SPEED = 24,
    FUNCTION_GET_SHUTTER_SPEED = 25,
    FUNCTION_SET_APERTURE_SIZE = 26,
    FUNCTION_GET_APERTURE_SIZE = 27,
    FUNCTION_SET_METERING_MODE = 28,
    FUNCTION_GET_METERING_MODE = 29,
    FUNCTION_SET_SPOT_FOCUS_AERA = 30,
    FUNCTION_GET_SPOT_FOCUS_AERA = 31,
    FUNCTION_SET_SHOT_MODE = 32,
    FUNCTION_GET_SHOT_MODE = 33,
    FUNCTION_CONTROL_OPTIZOOM = 34,
  };

  enum Aperture {
    F_1_DOT_6 = 160,
    F_1_DOT_7 = 170,
    F_1_DOT_8 = 180,
    F_2 = 200,
    F_2_DOT_2 = 220,
    F_2_DOT_4 = 240,
    F_2_DOT_5 = 250,
    F_2_DOT_6 = 260,
    F_2_DOT_8 = 280,
    F_3_DOT_2 = 320,
    F_3_DOT_4 = 340,
    F_3_DOT_5 = 350,
    F_4 = 400,
    F_4_DOT_5 = 450,
    F_4_DOT_8 = 480,
    F_5 = 500,
    F_5_DOT_6 = 560,
    F_6_DOT_3 = 630,
    F_6_DOT_8 = 680,
    F_7_DOT_1 = 710,
    F_8 = 800,
    F_9 = 900,
    F_9_DOT_6 = 960,
    F_10 = 1000,
    F_11 = 1100,
    F_13 = 1300,
    F_14 = 1400,
    F_16 = 1600,
    F_18 = 1800,
    F_19 = 1900,
    F_20 = 2000,
    F_22 = 2200,
    F_UNKNOWN = 0xFFFF,
  };

  enum ZoomDirection {
    ZOOM_OUT = 0,
    ZOOM_IN = 1,
  };

  enum ZoomSpeed {
    SLOWEST = 72,         
    SLOW = 73,            
    MODERATELY_SLOW = 74, 
    NORMAL = 75,          
    MODERATELY_FAST = 76, 
    FAST = 77,            
    FASTEST = 78,         
  };

  typedef enum
  {
    DJI_CAMERA_FOCUS_MODE_MANUAL = 0, // 手动对焦
    DJI_CAMERA_FOCUS_MODE_SHOT_AF = 1, // 自动对焦
    DJI_CAMERA_FOCUS_MODE_CONTIN_AF = 2, // 连续自动对焦
    DJI_CAMERA_FOCUS_MODE_MANUAL_FINE = 3, // 手动精细对焦（自动对焦后，再手动进行精细对焦）
  } DJI_CAMERA_FOCUS_MODE;
  typedef enum
  {
    DJI_CAMERA_DJPH1_CALIBRATE_RESULT_IDLE = 0,
    DJI_CAMERA_DJPH1_CALIBRATE_RESULT_SUCCESS = 1,
    DJI_CAMERA_DJPH1_CALIBRATE_RESULT_TOOCLOSE = 2,
  } DJI_CAMERA_DJPH1_CALIBRATE_RESULT;
// X5相机协议类型
  typedef enum
  {
    DJI_X5_CAMERA_PROTOCOL_TYPE_DEFAULT = 0, // 默认协议
    DJI_X5_CAMERA_PROTOCOL_TYPE_ASSISTANT_FOCUS = 1, // 辅助对焦
    DJI_X5_CAMERA_PROTOCOL_TYPE_CMODE = 2, // CMode协议
  } DJI_X5_CAMERA_PROTOCOL_TYPE;

#pragma pack(1)
// ========== structs ==========
  typedef struct dji_camera_focus_area_struct
  {
    // 点对焦区域X
    float focus_index_x;
    // 点对焦区域Y
    float focus_index_y;
  } dji_camera_focus_area_struct;

  typedef struct dji_camera_aperture_range
  {
    // 最小光圈Size 实际值X100,  这才是最大光圈 最小的值
    uint16_t min_aperture_size;
    // 最大光圈Size 实际值X100， 这才是最小光圈， 最大的值
    uint16_t max_aperture_size;
  } dji_camera_aperture_range;

  typedef struct dji_camera_assist_digital_zoom_para
  {
    // 手动对焦时的数字对焦辅助 0关闭，1开启
    uint8_t mf_assist_state:1;
    // 自动对焦时的数字对焦辅助  0关闭，1开启
    uint8_t af_assist_state:1;
    uint8_t reserved       :6;
  } dji_camera_assist_digital_zoom_para;

  typedef struct dji_camera_real_focus_area_struct
  {
    // X轴实际对焦窗口起始下标
    uint8_t focus_index_x;
    // X轴实际对焦窗口个数
    // 220&240下推送为0时，由app决定显示对焦框的大小
    uint8_t focus_count_x;
    // Y轴实际对焦窗口起始下标
    uint8_t focus_index_y;
    // Y轴实际对焦窗口个数
    // 220&240下推送为0时，由app决定显示对焦框的大小
    uint8_t focus_count_y;
  } dji_camera_real_focus_area_struct;

  typedef struct dji_camera_focusing_state
  {
    // 0: Idle, 1: Focusing, 2: Successful, 3: Failed, 4: Unknown
    uint8_t state            :2;
    uint8_t is_back_to_center:1;
    uint8_t reserved         :5;
  } dji_camera_focusing_state;

  typedef struct dji_camera_lens_state
  {
    // 机身对焦模式
    uint8_t camera_body_focusing_mode:2;  // enum-type: DJI_CAMERA_FOCUS_MODE
    // 镜头对焦模式
    uint8_t camera_lens_focusing_mode:2;  // enum-type: DJI_CAMERA_FOCUS_MODE
    // 变焦特性 （0 = 手动，1 ＝ 电动)
    uint8_t auto_focal_lenstype      :1;
    // 定焦特性 （0 ＝ AF 镜头，1 ＝ MF 镜头）
    uint8_t fix_focal_lenstype       :1;
    // 镜头焦距特性（0 ＝ 定焦镜头，1 ＝ 变焦镜头）
    uint8_t lens_focal_distancetype  :1;
    // 镜头连接状态，0 = 未连接，1 = 已连接
    uint8_t connect_state            :1;
  } dji_camera_lens_state;
// ========== structs end ======

// ========== commands =========
// 该命令用于推送相机镜头参数
  typedef struct dji_camera_len_para_push
  {
    // 相机镜头状态
    dji_camera_lens_state lens_state;
    // 最大电机行程
    uint16_t max_focus_engine_scole;
    // 当前电机行程
    uint16_t cur_focus_engine_value;
    // 当前物距
    float object_distance;
    // 光圈范围
    dji_camera_aperture_range aperture_range;
    // 对焦区域
    dji_camera_focus_area_struct focus_area;
    // 对焦状态
    dji_camera_focusing_state focusing_state;
    // 合焦概率
    uint8_t focusing_probability;
    // 最小焦距(单位 0.1mm)
    uint16_t min_focus_length;
    // 最大焦距 (单位 0.1mm)
    uint16_t max_focus_length;
    // 当前焦距 (单位 0.1mm)
    uint16_t current_focus_length;
    // 焦距最小变化量 （单位 0.1mm）
    uint16_t min_focus_interval;
    dji_camera_assist_digital_zoom_para assist_digital_zoom_para;
    uint8_t focal_window_size_x;
    uint8_t focal_window_size_y;
    uint8_t assist_zoom_working;
    // 实际对焦区域,将视图切分为格子然后通过起始index跟格子数确定对焦窗口。HG210有 12x8 个格子
    dji_camera_real_focus_area_struct real_focus_area;
    // X5相机协议
    uint8_t x5_camera_protocol_type;  // enum-type: DJI_X5_CAMERA_PROTOCOL_TYPE
    // 自动对焦时的 对焦电机状态0 ＝正常， 1= 初始化失败， 2＝电机卡住， 3=电机损坏 其它reserved
    uint8_t af_focus_state;
    // 镜头标定状态 0 = 未标定 1 ＝ 已标定  2= 标定中
    uint8_t calibrate_state;
    // MF标定操作执行结果
    uint8_t djph1_calibrate_result; // enum-type: DJI_CAMERA_DJPH1_CALIBRATE_RESULT
    // 镜头标定的无穷远位置 用于app一键无穷远
    uint16_t calibrate_infinity_len;
    // cleandirt状态
    uint8_t ffcamera_clean_dirt_status;
    // 是否支持连续的数字变焦，1为支持，0为不支持。
    uint8_t support_continuous_dzoom;
    // 数字变焦的起始等效焦距值。此值一般为光学变焦的tele值，最小单位为0.1mm；例如，数值变焦起始等效焦距值为48.0mm，此值为480。
    uint16_t dzoom_start_focus_length;
    // 目标焦距 (单位 0.1mm)，用户设置的希望达到的焦距。
    // 如果是用速度模式设置焦距，则目标焦距和当前焦距相同。
    uint16_t target_focus_length;
  } dji_camera_len_para_push;

  typedef struct CommonAck {
    uint8_t ret_code;    
  } CommonAck;           // pack(1)

  typedef uint8_t
      ShootPhotoModeData; 
  typedef uint8_t PhotoAEBCountData;

  typedef uint8_t PhotoNumBurstData;

  typedef struct PhotoIntervalData {
    uint8_t photoNumConticap; 
    int16_t timeInterval;     
  } PhotoIntervalData;

  typedef struct CaptureParamData {
    ShootPhotoModeData
        captureMode; 
    PhotoNumBurstData photoNumBurst; 
    uint8_t conticapType; 
    PhotoIntervalData intervalSetting; 
  } CaptureParamData;                  // pack(1)

  typedef enum :uint8_t
  {
    DJI_CAMERA_CONTI_CAP_TYPE_SINGLE = 0, // 单拍
    DJI_CAMERA_CONTI_CAP_TYPE_MULTIPLE = 1, // 多拍
    DJI_CAMERA_CONTI_CAP_TYPE_TIMELAPSE = 2, // 延时
  } DJI_CAMERA_CONTI_CAP_TYPE;

  typedef struct dji_camera_timelapse_capture_with_ms
  {
    DJI_CAMERA_CONTI_CAP_TYPE timelapse_type; // enum-type: DJI_CAMERA_CONTI_CAP_TYPE
    uint8_t timelapse_count;
    uint16_t timelapse_interval;
    uint16_t timelapse_interval_ms;
  } dji_camera_timelapse_capture_with_ms;

  typedef struct CaptureParamReq {
    CaptureParamData
        captureParam; 
  } CaptureParamReq;  // pack(1)

  typedef struct CaptureParamAck {
    uint8_t ret_code;              
    CaptureParamData captureParam; 
  } CaptureParamAck;               // pack(1)

  typedef struct RecordVideoReq {
    uint8_t recording_control : 2; 
    uint8_t
        recording_type : 4; 
    uint8_t reserved : 2;
  } RecordVideoReq;  // pack(1)

  typedef uint8_t WorkModeData; 
  typedef struct WorkModeReq {
    WorkModeData workingMode; 
  } WorkModeReq;              // pack(1)

  typedef struct WorkModeAck {
    uint8_t ret_code;         
    WorkModeData workingMode; 
  } WorkModeAck;              // pack(1)

  typedef struct ShootPhotoReq {
    ShootPhotoModeData
        takePhotoType; 
  } ShootPhotoReq;     // pack(1)

  typedef uint8_t
      FocusModeData; 
  typedef struct FocusModeReq {
    FocusModeData focusMode; 
  } FocusModeReq;            // pack(1)

  typedef struct FocusModeAck {
    uint8_t ret_code;        
    FocusModeData focusMode; 
  } FocusModeAck;            // pack(1)

  typedef uint8_t
      ExposureModeData; 
  typedef struct ExposureModeReq {
    ExposureModeData
        exposureModeMode; 
    uint8_t reserve;
  } ExposureModeReq;  // pack(1)

  typedef struct ExposureModeAck {
    uint8_t ret_code;    
    ExposureModeData
        exposureMode; 
    uint8_t reserve;
  } ExposureModeAck;  // pack(1)

  typedef uint8_t zoomDirectionData;

  typedef uint8_t zoomSpeedData;

  typedef struct zoomOptiParamType {
    zoomDirectionData
        zoomType; 
    zoomSpeedData zoomSpeed; 
    union {
      struct {
        uint8_t zoomDirection; 
        uint8_t padding;       
      } zoomContiParam;
      uint16_t
          zoomFocusLength; 
    } zoomParam;
  } zoomOptiParamType;

  // Camera zoom parameters
  typedef struct zoom_config_t
  {
    uint8_t digital_zoom_mode   : 2;  /* 0:step 1:position 2:continuous */
    uint8_t digital_reserve   : 1;  /* reserve */
    uint8_t digital_zoom_enable : 1;  /* 0:not_ctrl 1:ctrl */
    uint8_t optical_zoom_mode   : 2;  /* 0:step 1:position 2:continuous */
    uint8_t optical_reserve   : 1;  /* reserve */
    uint8_t optical_zoom_enable : 1;  /* 0:not_ctrl 1:ctrl */
  } zoom_config_t;

  typedef union zoom_param_t
  {
    struct
    {
      uint16_t zoom_cont_speed        : 8;  /* continuous speed 0~100 */
      uint16_t zoom_cont_direction    : 1;
      uint16_t zoom_cont_reserve      : 7;
    }cont_param;
    struct
    {
      uint16_t zoom_step_level    : 8;  /* level time * 100 = 1 times */
      uint16_t zoom_step_direction    : 1;
      uint16_t zoom_step_reserve      : 7;
    }step_param;
    struct
    {
      uint16_t zoom_pos_level;            /* 180 = 1.8times */
    }pos_param;
  } zoom_param_t;

  typedef struct camera_zoom_data_type
  {
    zoom_config_t zoom_config;
    zoom_param_t optical_zoom_param;
    zoom_param_t digital_zoom_param;
  }camera_zoom_data_type;

  typedef struct zoomOptiParamReq {
    zoomOptiParamType zoomOptiParam; 
  } zoomOptiParamReq;

  typedef uint8_t TapZoomEnableData;

  typedef uint8_t TapZoomMultiplierData;

  typedef struct TapZoomEnableReq {
    TapZoomEnableData tapZoomEnable;  
    TapZoomMultiplierData multiplier; 
  } TapZoomEnableReq;                 // pack(1)

  typedef struct TapZoomEnableAck {
    uint8_t ret_code;    
    TapZoomEnableData tapZoomEnable;  
    TapZoomMultiplierData multiplier; 
  } TapZoomEnableAck;                 // pack(1)

  typedef struct FloatPoint {
    float x;     
    float y;     
  } FloatPoint;  // pack(1)

  typedef FloatPoint TapZoomPosData;  // pack(1)

  typedef FloatPoint TapFocusPosData;  // pack(1)

  typedef struct FloatPointReq {
    FloatPoint p;        
  } FloatPointReq;

  typedef FloatPointReq TapZoomPosReq;  // pack(1)

  typedef FloatPointReq TapFocusPosReq;  // pack(1)

  typedef struct TapFocusPosAck {
    uint8_t ret_code;    
    TapZoomPosData p;    
    int8_t hor_region_num;
    int8_t ver_region_num;
  } TapFocusPosAck;  // pack(1)

  typedef uint8_t ISOParamData; 
  typedef struct ISOParamReq {
    ISOParamData iso;    
  } ISOParamReq;         // pack(1)

  typedef struct ISOParamAck {
    uint8_t ret_code;    
    ISOParamData iso;    
  } ISOParamAck;         // pack(1)

  typedef uint16_t ApertureData;

  typedef struct ApertureReq {
    ApertureData size;   
  } ApertureReq;         // pack(1)

  typedef struct ApertureAck {
    uint8_t ret_code;    
    ApertureData size;   
  } ApertureAck;         // pack(1)

  typedef struct ShutterParamType {
    uint16_t integer_part : 15; 
    uint16_t reciprocal : 1;    
    uint8_t decimal_part;       
  } ShutterSpeedType;           // pack(1)

  typedef uint8_t ShutterSpeedData;  // pack(1)

  typedef struct ShutterReq {
    uint8_t shutter_mode; 
    ShutterSpeedType shutterSpeed; 
  } ShutterReq;                    // pack(1)

  typedef struct ShutterAck {
    uint8_t ret_code;     
    uint8_t shutter_mode; 
    ShutterSpeedType shutter;
  } ShutterAck;  // pack(1)

  typedef uint8_t
      ExposureCompensationData; 
  typedef struct ExposureCompensationReq {
    ExposureCompensationData
        ev; 
  } ExposureCompensationReq;  // pack(1)

  typedef struct ExposureCompensationAck {
    uint8_t ret_code; 
    ExposureCompensationData
        ev_param; 
  } ExposureCompensationAck;  // pack(1)

#pragma pack()

  typedef struct UCBRetCodeHandler {
    void (*UserCallBack)(ErrorCode::ErrorCodeType errCode, UserData userData);

    UserData userData;
  } UCBRetCodeHandler;

  template <typename T>
  struct UCBRetParamStruct {
    void (*UserCallBack)(ErrorCode::ErrorCodeType errCode, T param,
                         UserData userData);

    UserData userData;
  };

  template <typename T>
  using UCBRetParamHandler = UCBRetParamStruct<T>;

 public:
  CameraModule(Linker* linker, PayloadIndexType payloadIndex,
               std::string name, bool enable);

  ~CameraModule();

 public:
  void startShootPhotoAsync(
      ShootPhotoMode mode,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType startShootPhotoSync(ShootPhotoMode mode,
                                               int timeout);

  void stopShootPhotoAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType stopShootPhotoSync(int timeout);

  void setShootPhotoModeAsync(
      ShootPhotoMode takePhotoMode,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setShootPhotoModeSync(ShootPhotoMode takePhotoMode,
                                                 int timeout);

  void getShootPhotoModeAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           ShootPhotoMode takePhotoMode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getShootPhotoModeSync(ShootPhotoMode& takePhotoMode,
                                                 int timeout);

  void setPhotoBurstCountAsync(
      PhotoBurstCount count,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setPhotoBurstCountSync(PhotoBurstCount count,
                                                  int timeout);

  void getPhotoBurstCountAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           PhotoBurstCount count, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getPhotoBurstCountSync(PhotoBurstCount& count,
                                                  int timeout);

  void setPhotoAEBCountAsync(
      PhotoAEBCount count,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setPhotoAEBCountSync(PhotoAEBCount count,
                                                int timeout);

  void getPhotoAEBCountAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           PhotoAEBCount count, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getPhotoAEBCountSync(PhotoAEBCount& count,
                                                int timeout);

  void setPhotoTimeIntervalSettingsAsync(
      PhotoIntervalData intervalSetting,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setPhotoTimeIntervalSettingsSync(
      PhotoIntervalData intervalSetting, int timeout);

  void getPhotoIntervalDatasAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           PhotoIntervalData intervalSetting,
                           UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getPhotoIntervalDatasSync(
      PhotoIntervalData& intervalSetting, int timeout);

  void startRecordVideoAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType startRecordVideoSync(int timeout);

  void stopRecordVideoAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType stopRecordVideoSync(int timeout);

  void setModeAsync(WorkMode mode,
                    void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                         UserData userData),
                    UserData userData);

  ErrorCode::ErrorCodeType setModeSync(WorkMode mode, int timeout);

  void getModeAsync(void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                         WorkMode workingMode,
                                         UserData userData),
                    UserData userData);

  ErrorCode::ErrorCodeType getModeSync(WorkMode& workingMode, int timeout);

  void setFocusModeAsync(FocusMode mode,
                         void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                              UserData userData),
                         UserData userData);

  ErrorCode::ErrorCodeType setFocusModeSync(FocusMode mode, int timeout);

  void getFocusModeAsync(void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                              FocusMode mode,
                                              UserData userData),
                         UserData userData);

  ErrorCode::ErrorCodeType getFocusModeSync(FocusMode& focusMode, int timeout);

  void setFocusTargetAsync(
      TapFocusPosData tapFocusPos,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setFocusTargetSync(TapFocusPosData tapFocusPos,
                                              int timeout);

  void getFocusTargetAsync(void (*UserCallBack)(ErrorCode::ErrorCodeType,
                                                TapFocusPosData tapFocusPos,
                                                UserData userData),
                           UserData userData);

  ErrorCode::ErrorCodeType getFocusTargetSync(TapFocusPosData& tapFocusPos,
                                              int timeout);

  void startContinuousOpticalZoomAsync(
      zoomDirectionData zoomDirection, zoomSpeedData zoomSpeed,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType startContinuousOpticalZoomSync(
      zoomDirectionData zoomDirection, zoomSpeedData zoomSpeed, int timeout);


  ErrorCode::ErrorCodeType setOpticalZoomFactorSync(float factor, int timeout);

  ErrorCode::ErrorCodeType getOpticalZoomFactorSync(
      float &factor, int timeout);

  void stopContinuousOpticalZoomAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType stopContinuousOpticalZoomSync(int timeout);

  void setTapZoomEnabledAsync(
      bool param,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setTapZoomEnabledSync(bool param, int timeout);

  void getTapZoomEnabledAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, bool param,
                           UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getTapZoomEnabledSync(bool& param, int timeout);

  void setTapZoomMultiplierAsync(
      TapZoomMultiplierData param,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setTapZoomMultiplierSync(TapZoomMultiplierData param,
                                                    int timeout);

  void getTapZoomMultiplierAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           TapZoomMultiplierData param, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getTapZoomMultiplierSync(
      TapZoomMultiplierData& param, int timeout);

  void tapZoomAtTargetAsync(
      TapZoomPosData tapZoomPos,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType tapZoomAtTargetSync(TapZoomPosData tapZoomPos,
                                               int timeout);

  void setExposureModeAsync(
      ExposureMode mode,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setExposureModeSync(ExposureMode mode, int timeout);

  void getExposureModeAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, ExposureMode mode,
                           UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getExposureModeSync(ExposureMode& mode, int timeout);

  void setISOAsync(ISO iso,
                   void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                        UserData userData),
                   UserData userData);

  ErrorCode::ErrorCodeType setISOSync(ISO iso, int timeout);

  void getISOAsync(void (*UserCallBack)(ErrorCode::ErrorCodeType, ISO iso,
                                        UserData userData),
                   UserData userData);

  ErrorCode::ErrorCodeType getISOSync(ISO& iso, int timeout);

  void setApertureAsync(Aperture size,
                        void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                             UserData userData),
                        UserData userData);

  ErrorCode::ErrorCodeType setApertureSync(Aperture size, int timeout);

  void getApertureAsync(void (*UserCallBack)(ErrorCode::ErrorCodeType,
                                             Aperture size, UserData userData),
                        UserData userData);

  ErrorCode::ErrorCodeType getApertureSync(Aperture& size, int timeout);

  void setShutterSpeedAsync(
      ShutterSpeed shutterSpeed,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setShutterSpeedSync(ShutterSpeed shutterSpeed,
                                               int timeout);

  void getShutterSpeedAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           ShutterSpeed shutterSpeed, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getShutterSpeedSync(ShutterSpeed& shutterSpeed,
                                               int timeout);

  void setExposureCompensationAsync(
      ExposureCompensation ev,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setExposureCompensationSync(ExposureCompensation ev,
                                                       int timeout);

  void getExposureCompensationAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           ExposureCompensation ev, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getExposureCompensationSync(ExposureCompensation& ev,
                                                       int timeout);

  ErrorCode::ErrorCodeType obtainDownloadRightSync(bool enable, int timeout);

  std::string getCameraVersion();
  std::string getFirmwareVersion();

  typedef struct LensInfoPacketType {
    uint32_t updateTimeStamp; //ms
    dji_camera_len_para_push data;
  } LensInfoPacketType;
  void updateLensInfo(dji_camera_len_para_push data);
  LensInfoPacketType getLensInfo();

 private:
  LensInfoPacketType lensInfo;
  T_OsdkMutexHandle lensUpdatedMutex;

  static void getTapZoomEnabledDecoder(ErrorCode::ErrorCodeType retCode,
                                       TapZoomEnableAck data, UserData userData);

  static void getTapZoomMultiplierDecoder(ErrorCode::ErrorCodeType retCode,
                                          TapZoomEnableAck data,
                                          UserData userData);

  static void getShootPhotoModeDataDecoder(ErrorCode::ErrorCodeType retCode,
                                           CaptureParamData captureParam,
                                           UserData userData);
  static void getPhotoBurstCountDecoder(ErrorCode::ErrorCodeType retCode,
                                        CaptureParamData captureParam,
                                        UserData userData);

  static void getPhotoAEBCountDecoder(ErrorCode::ErrorCodeType retCode,
                                      CaptureParamData captureParam,
                                      UserData userData);
  static void getPhotoIntervalDatasDecoder(ErrorCode::ErrorCodeType retCode,
                                           CaptureParamData captureParam,
                                           UserData userData);

  static void callbackToSetTapZoomMultiplier(ErrorCode::ErrorCodeType retCode,
                                             bool enable, UserData userData);
  static void callbackToSetTapZoomEnabled(ErrorCode::ErrorCodeType retCode,
                                          TapZoomMultiplierData multiplier,
                                          UserData userData);
  static void callbackToSetShootPhotoMode(ErrorCode::ErrorCodeType retCode,
                                          CaptureParamData captureParam,
                                          UserData userData);
  static void callbackToSetPhotoBurstCount(ErrorCode::ErrorCodeType retCode,
                                           CaptureParamData captureParam,
                                           UserData userData);
  static void callbackToSetPhotoTimeIntervalSettings(
    ErrorCode::ErrorCodeType retCode, CaptureParamData captureParam,
    UserData userData);

  template <typename DataT>
  void getInterfaceAsync(const uint8_t cmd[2],
                         void (*userCB)(ErrorCode::ErrorCodeType, DataT data,
                                        UserData),
                         UserData userData, int timeout = 500,
                         int retry_time = 2);

  ErrorCode::ErrorCodeType getInterfaceSync(const uint8_t cmd[2],
                                            uint8_t *outData,
                                            uint32_t &outDataLen, int timeout,
                                            int rtyTimes);

  void setInterfaceAsync(
      const uint8_t cmd[2], const uint8_t *pdata, uint32_t dataLen,
      void (*userCB)(ErrorCode::ErrorCodeType, UserData),
      UserData userData, int timeout = 500, int retry_time = 2);

  ErrorCode::ErrorCodeType setInterfaceSync(const uint8_t cmd[2],
                                            const uint8_t *pdata,
                                            uint32_t dataLen, int timeout,
                                            uint8_t rtyTimes);

  void actionInterfaceAsync(
      const uint8_t cmd[2], const uint8_t *pdata, uint32_t dataLen,
      void (*userCB)(ErrorCode::ErrorCodeType, UserData),
      UserData userData, int timeout = 500, int retry_time = 2);

  ErrorCode::ErrorCodeType actionInterfaceSync(const uint8_t cmd[2],
                                               const uint8_t *pdata,
                                               uint32_t dataLen,
                                               int timeout,
                                               uint8_t rtyTimes);

 private:
  std::string cameraVersion;
  std::string firmwareVersion;
  void requestCameraVersion();
  void getCaptureParamDataAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           CaptureParamData captureParam, UserData userData),
      UserData userData);
  void getTapZoomDataAckAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           TapZoomEnableAck data, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getCaptureParamDataSync(
      CaptureParamData& captureParam, int timeout);

  CaptureParamData CreateDefCaptureParamData(ShootPhotoMode mode = SINGLE);
  T_OsdkTaskHandle camModuleHandle;
  static void camHWInfoTask(void *arg);
}; /* CameraModule camera */
}  // namespace OSDK
}  // namespace DJI

#endif  // ONBOARDSDK_DJI_CAMERA_MODULE_HPP