ObTypes.h

Go to the documentation of this file.

// Copyright (c) Orbbec Inc. All Rights Reserved.
// Licensed under the MIT License.

 
#pragma once
 
#include "Export.h"
 
#include <stdbool.h>
#include <stdint.h>
 
#pragma pack(push, 1)  // struct 1-byte align
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct ob_context_t                       ob_context;
typedef struct ob_device_t                        ob_device;
typedef struct ob_device_info_t                   ob_device_info;
typedef struct ob_device_list_t                   ob_device_list;
typedef struct ob_record_device_t                 ob_record_device;
typedef struct ob_playback_device_t               ob_playback_device;
typedef struct ob_camera_param_list_t             ob_camera_param_list;
typedef struct ob_sensor_t                        ob_sensor;
typedef struct ob_sensor_list_t                   ob_sensor_list;
typedef struct ob_stream_profile_t                ob_stream_profile;
typedef struct ob_stream_profile_list_t           ob_stream_profile_list;
typedef struct ob_frame_t                         ob_frame;
typedef struct ob_filter_t                        ob_filter;
typedef struct ob_filter_list_t                   ob_filter_list;
typedef struct ob_pipeline_t                      ob_pipeline;
typedef struct ob_config_t                        ob_config;
typedef struct ob_depth_work_mode_list_t          ob_depth_work_mode_list;
typedef struct ob_device_preset_list_t            ob_device_preset_list;
typedef struct ob_filter_config_schema_list_t     ob_filter_config_schema_list;
typedef struct ob_device_frame_interleave_list_t  ob_device_frame_interleave_list;
typedef struct ob_preset_resolution_config_list_t ob_preset_resolution_config_list;
 
#define OB_WIDTH_ANY 0
#define OB_HEIGHT_ANY 0
#define OB_FPS_ANY 0
#define OB_FORMAT_ANY OB_FORMAT_UNKNOWN
#define OB_PROFILE_DEFAULT 0
#define OB_DEFAULT_STRIDE_BYTES 0
#define OB_ACCEL_FULL_SCALE_RANGE_ANY OB_ACCEL_FS_UNKNOWN
#define OB_ACCEL_SAMPLE_RATE_ANY OB_SAMPLE_RATE_UNKNOWN
#define OB_GYRO_FULL_SCALE_RANGE_ANY OB_GYRO_FS_UNKNOWN
#define OB_GYRO_SAMPLE_RATE_ANY OB_SAMPLE_RATE_UNKNOWN

#define OB_PATH_MAX (1024)

typedef enum {
    OB_PERMISSION_DENY       = 0,   
    OB_PERMISSION_READ       = 1,   
    OB_PERMISSION_WRITE      = 2,   
    OB_PERMISSION_READ_WRITE = 3,   
    OB_PERMISSION_ANY        = 255, 
} OBPermissionType,
    ob_permission_type;

typedef enum {
    OB_STATUS_OK    = 0, 
    OB_STATUS_ERROR = 1, 
} OBStatus,
    ob_status;

typedef enum {
    OB_LOG_SEVERITY_DEBUG, 
    OB_LOG_SEVERITY_INFO,  
    OB_LOG_SEVERITY_WARN,  
    OB_LOG_SEVERITY_ERROR, 
    OB_LOG_SEVERITY_FATAL, 
    OB_LOG_SEVERITY_OFF    
} OBLogSeverity,
    ob_log_severity, DEVICE_LOG_SEVERITY_LEVEL, OBDeviceLogSeverityLevel, ob_device_log_severity_level;
#define OB_LOG_SEVERITY_NONE OB_LOG_SEVERITY_OFF

typedef enum {
    OB_EXCEPTION_TYPE_UNKNOWN,             
    OB_EXCEPTION_STD_EXCEPTION,            
    OB_EXCEPTION_TYPE_CAMERA_DISCONNECTED, 
    OB_EXCEPTION_TYPE_PLATFORM,            
    OB_EXCEPTION_TYPE_INVALID_VALUE,       
    OB_EXCEPTION_TYPE_WRONG_API_CALL_SEQUENCE, 
    OB_EXCEPTION_TYPE_NOT_IMPLEMENTED,         
    OB_EXCEPTION_TYPE_IO,                      
    OB_EXCEPTION_TYPE_MEMORY,                  
    OB_EXCEPTION_TYPE_UNSUPPORTED_OPERATION,   
} OBExceptionType,
    ob_exception_type;

typedef struct ob_error {
    ob_status         status;          
    char              message[256];    
    char              function[256];   
    char              args[256];       
    ob_exception_type exception_type;  
} ob_error;

typedef enum {
    OB_SENSOR_UNKNOWN    = 0, 
    OB_SENSOR_IR         = 1, 
    OB_SENSOR_COLOR      = 2, 
    OB_SENSOR_DEPTH      = 3, 
    OB_SENSOR_ACCEL      = 4, 
    OB_SENSOR_GYRO       = 5, 
    OB_SENSOR_IR_LEFT    = 6, 
    OB_SENSOR_IR_RIGHT   = 7, 
    OB_SENSOR_RAW_PHASE  = 8, 
    OB_SENSOR_CONFIDENCE = 9, 
    OB_SENSOR_TYPE_COUNT,     
} OBSensorType,
    ob_sensor_type;

typedef enum {
    OB_STREAM_UNKNOWN    = -1, 
    OB_STREAM_VIDEO      = 0,  
    OB_STREAM_IR         = 1,  
    OB_STREAM_COLOR      = 2,  
    OB_STREAM_DEPTH      = 3,  
    OB_STREAM_ACCEL      = 4,  
    OB_STREAM_GYRO       = 5,  
    OB_STREAM_IR_LEFT    = 6,  
    OB_STREAM_IR_RIGHT   = 7,  
    OB_STREAM_RAW_PHASE  = 8,  
    OB_STREAM_CONFIDENCE = 9,  
    OB_STREAM_TYPE_COUNT,      
} OBStreamType,
    ob_stream_type;

typedef enum {
    OB_FRAME_UNKNOWN    = -1, 
    OB_FRAME_VIDEO      = 0,  
    OB_FRAME_IR         = 1,  
    OB_FRAME_COLOR      = 2,  
    OB_FRAME_DEPTH      = 3,  
    OB_FRAME_ACCEL      = 4,  
    OB_FRAME_SET        = 5,  
    OB_FRAME_POINTS     = 6,  
    OB_FRAME_GYRO       = 7,  
    OB_FRAME_IR_LEFT    = 8,  
    OB_FRAME_IR_RIGHT   = 9,  
    OB_FRAME_RAW_PHASE  = 10, 
    OB_FRAME_CONFIDENCE = 11, 
    OB_FRAME_TYPE_COUNT,      
} OBFrameType,
    ob_frame_type;

typedef enum {
    OB_PIXEL_UNKNOWN   = -1,  // Unknown pixel type, or undefined pixel type for current frame
    OB_PIXEL_DEPTH     = 0,   // Depth pixel type, the value of the pixel is the distance from the camera to the object
    OB_PIXEL_DISPARITY = 2,   // Disparity for structured light camera
    OB_PIXEL_RAW_PHASE = 3,   // Raw phase for tof camera
    OB_PIXEL_TOF_DEPTH = 4,   // Depth for tof camera
} OBPixelType,
    ob_pixel_type;

typedef enum {
    OB_FORMAT_UNKNOWN    = -1, 
    OB_FORMAT_YUYV       = 0,  
    OB_FORMAT_YUY2       = 1,  
    OB_FORMAT_UYVY       = 2,  
    OB_FORMAT_NV12       = 3,  
    OB_FORMAT_NV21       = 4,  
    OB_FORMAT_MJPG       = 5,  
    OB_FORMAT_H264       = 6,  
    OB_FORMAT_H265       = 7,  
    OB_FORMAT_Y16        = 8,  
    OB_FORMAT_Y8         = 9,  
    OB_FORMAT_Y10        = 10, 
    OB_FORMAT_Y11        = 11, 
    OB_FORMAT_Y12        = 12, 
    OB_FORMAT_GRAY       = 13, 
    OB_FORMAT_HEVC       = 14, 
    OB_FORMAT_I420       = 15, 
    OB_FORMAT_ACCEL      = 16, 
    OB_FORMAT_GYRO       = 17, 
    OB_FORMAT_POINT      = 19, 
    OB_FORMAT_RGB_POINT  = 20, 
    OB_FORMAT_RLE        = 21, 
    OB_FORMAT_RGB        = 22, 
    OB_FORMAT_BGR        = 23, 
    OB_FORMAT_Y14        = 24, 
    OB_FORMAT_BGRA       = 25, 
    OB_FORMAT_COMPRESSED = 26, 
    OB_FORMAT_RVL        = 27, 
    OB_FORMAT_Z16        = 28, 
    OB_FORMAT_YV12       = 29, 
    OB_FORMAT_BA81       = 30, 
    OB_FORMAT_RGBA       = 31, 
    OB_FORMAT_BYR2       = 32, 
    OB_FORMAT_RW16       = 33, 
    OB_FORMAT_Y12C4      = 34, 
} OBFormat,
    ob_format;
 
#define OB_FORMAT_RGB888 OB_FORMAT_RGB  // Alias of OB_FORMAT_RGB for compatibility
#define OB_FORMAT_MJPEG OB_FORMAT_MJPG  // Alias of OB_FORMAT_MJPG for compatibility
 
// Check if the format is a fixed data size format
#define IS_FIXED_SIZE_FORMAT(format)                                                                                                         \
    (format != OB_FORMAT_MJPG && format != OB_FORMAT_H264 && format != OB_FORMAT_H265 && format != OB_FORMAT_HEVC && format != OB_FORMAT_RLE \
     && format != OB_FORMAT_RVL)
 
// Check if the format is a packed format, which means the data of pixels is not continuous or bytes aligned in memory
#define IS_PACKED_FORMAT(format) \
    (format == OB_FORMAT_Y10 || format == OB_FORMAT_Y11 || format == OB_FORMAT_Y12 || format == OB_FORMAT_Y14 || format == OB_FORMAT_RLE)

typedef enum {
    STAT_DONE_WITH_DUPLICATES = 6,   
    STAT_VERIFY_SUCCESS       = 5,   
    STAT_FILE_TRANSFER        = 4,   
    STAT_DONE                 = 3,   
    STAT_IN_PROGRESS          = 2,   
    STAT_START                = 1,   
    STAT_VERIFY_IMAGE         = 0,   
    ERR_VERIFY                = -1,  
    ERR_PROGRAM               = -2,  
    ERR_ERASE                 = -3,  
    ERR_FLASH_TYPE            = -4,  
    ERR_IMAGE_SIZE            = -5,  
    ERR_OTHER                 = -6,  
    ERR_DDR                   = -7,  
    ERR_TIMEOUT               = -8,  
    ERR_MISMATCH              = -9,  
    ERR_UNSUPPORT_DEV         = -10, 
    ERR_INVALID_COUNT         = -11, 
} OBUpgradeState,
    OBFwUpdateState, ob_upgrade_state, ob_fw_update_state;

typedef enum {
    FILE_TRAN_STAT_TRANSFER         = 2,  
    FILE_TRAN_STAT_DONE             = 1,  
    FILE_TRAN_STAT_PREPAR           = 0,  
    FILE_TRAN_ERR_DDR               = -1, 
    FILE_TRAN_ERR_NOT_ENOUGH_SPACE  = -2, 
    FILE_TRAN_ERR_PATH_NOT_WRITABLE = -3, 
    FILE_TRAN_ERR_MD5_ERROR         = -4, 
    FILE_TRAN_ERR_WRITE_FLASH_ERROR = -5, 
    FILE_TRAN_ERR_TIMEOUT           = -6  
} OBFileTranState,
    ob_file_tran_state;

typedef enum {
    DATA_TRAN_STAT_VERIFY_DONE  = 4,  
    DATA_TRAN_STAT_STOPPED      = 3,  
    DATA_TRAN_STAT_DONE         = 2,  
    DATA_TRAN_STAT_VERIFYING    = 1,  
    DATA_TRAN_STAT_TRANSFERRING = 0,  
    DATA_TRAN_ERR_BUSY          = -1, 
    DATA_TRAN_ERR_UNSUPPORTED   = -2, 
    DATA_TRAN_ERR_TRAN_FAILED   = -3, 
    DATA_TRAN_ERR_VERIFY_FAILED = -4, 
    DATA_TRAN_ERR_OTHER         = -5  
} OBDataTranState,
    ob_data_tran_state;

typedef struct {
    uint8_t *data;          
    uint32_t size;          
    uint32_t offset;        
    uint32_t fullDataSize;  
} OBDataChunk, ob_data_chunk;

typedef struct {
    int32_t cur;   
    int32_t max;   
    int32_t min;   
    int32_t step;  
    int32_t def;   
} OBIntPropertyRange, ob_int_property_range;

typedef struct {
    float cur;   
    float max;   
    float min;   
    float step;  
    float def;   
} OBFloatPropertyRange, ob_float_property_range;

typedef struct {
    uint16_t cur;   
    uint16_t max;   
    uint16_t min;   
    uint16_t step;  
    uint16_t def;   
} OBUint16PropertyRange, ob_uint16_property_range;

typedef struct {
    uint8_t cur;   
    uint8_t max;   
    uint8_t min;   
    uint8_t step;  
    uint8_t def;   
} OBUint8PropertyRange, ob_uint8_property_range;

typedef struct {
    bool cur;   
    bool max;   
    bool min;   
    bool step;  
    bool def;   
} OBBoolPropertyRange, ob_bool_property_range;

typedef enum {
    OB_DISTORTION_NONE,                   
    OB_DISTORTION_MODIFIED_BROWN_CONRADY, 
    OB_DISTORTION_INVERSE_BROWN_CONRADY,  
    OB_DISTORTION_BROWN_CONRADY,          
    OB_DISTORTION_BROWN_CONRADY_K6,       
    OB_DISTORTION_KANNALA_BRANDT4,        
} OBCameraDistortionModel,
    ob_camera_distortion_model;

typedef struct {
    float   fx;      
    float   fy;      
    float   cx;      
    float   cy;      
    int16_t width;   
    int16_t height;  
} OBCameraIntrinsic, ob_camera_intrinsic;

typedef struct {
    double noiseDensity;          
    double randomWalk;            
    double referenceTemp;         
    double bias[3];               
    double gravity[3];            
    double scaleMisalignment[9];  
    double tempSlope[9];          
} OBAccelIntrinsic, ob_accel_intrinsic;

typedef struct {
    double noiseDensity;          
    double randomWalk;            
    double referenceTemp;         
    double bias[3];               
    double scaleMisalignment[9];  
    double tempSlope[9];          
} OBGyroIntrinsic, ob_gyro_intrinsic;

typedef struct {
    float                   k1;  
    float                   k2;  
    float                   k3;  
    float                   k4;  
    float                   k5;  
    float                   k6;  
    float                   p1;  
    float                   p2;  
    OBCameraDistortionModel model;
} OBCameraDistortion, ob_camera_distortion;

typedef struct {
    float rot[9];    
    float trans[3];  
} OBD2CTransform, ob_d2c_transform, OBTransform, ob_transform, OBExtrinsic, ob_extrinsic;

typedef struct {
    OBCameraIntrinsic  depthIntrinsic;   
    OBCameraIntrinsic  rgbIntrinsic;     
    OBCameraDistortion depthDistortion;  
    OBCameraDistortion rgbDistortion;    
    OBD2CTransform     transform;        
    bool               isMirrored;       
} OBCameraParam, ob_camera_param;
 
typedef struct {
    int16_t width;                  
    int16_t height;                 
    int     irDecimationFactor;     
    int     depthDecimationFactor;  
} OBPresetResolutionConfig, ob_preset_resolution_ratio_config;

typedef struct {
    OBCameraIntrinsic  intrinsics[OB_SENSOR_TYPE_COUNT];  
    OBCameraDistortion distortion[OB_SENSOR_TYPE_COUNT];  
    OBExtrinsic        extrinsics[OB_SENSOR_TYPE_COUNT]
                          [OB_SENSOR_TYPE_COUNT];  
} OBCalibrationParam, ob_calibration_param;

typedef struct {
    int      margin_x_th;       
    int      margin_y_th;       
    int      limit_x_th;        
    int      limit_y_th;        
    uint32_t width;             
    uint32_t height;            
    bool     enable_direction;  
} ob_margin_filter_config, OBMarginFilterConfig;

typedef struct {
    uint32_t width;
    uint32_t height;
    int      max_width_left;
    int      max_width_right;
    int      max_radius;
    int      margin_x_th;
    int      margin_y_th;
    int      limit_x_th;
    int      limit_y_th;
} OBMGCFilterConfig, ob_mgc_filter_config;

typedef enum {
    ALIGN_DISABLE,     
    ALIGN_D2C_HW_MODE, 
    ALIGN_D2C_SW_MODE, 
} OBAlignMode,
    ob_align_mode;

typedef enum {
    ADAPTIVE_PERFORMANCE_MODE, 
    HIGH_PERFORMANCE_MODE,     
} OBCameraPerformanceMode,
    ob_camera_performance_mode;

typedef struct {
    uint32_t x;       
    uint32_t y;       
    uint32_t width;   
    uint32_t height;  
} OBRect, ob_rect;

typedef enum {
    FORMAT_YUYV_TO_RGB = 0, 
    FORMAT_I420_TO_RGB,     
    FORMAT_NV21_TO_RGB,     
    FORMAT_NV12_TO_RGB,     
    FORMAT_MJPG_TO_I420,    
    FORMAT_RGB_TO_BGR,      
    FORMAT_MJPG_TO_NV21,    
    FORMAT_MJPG_TO_RGB,     
    FORMAT_MJPG_TO_BGR,     
    FORMAT_MJPG_TO_BGRA,    
    FORMAT_UYVY_TO_RGB,     
    FORMAT_BGR_TO_RGB,      
    FORMAT_MJPG_TO_NV12,    
    FORMAT_YUYV_TO_BGR,     
    FORMAT_YUYV_TO_RGBA,    
    FORMAT_YUYV_TO_BGRA,    
    FORMAT_YUYV_TO_Y16,     
    FORMAT_YUYV_TO_Y8,      
    FORMAT_RGBA_TO_RGB,     
    FORMAT_BGRA_TO_BGR,     
    FORMAT_Y16_TO_RGB,      
    FORMAT_Y8_TO_RGB,       
} OBConvertFormat,
    ob_convert_format;
 
// DEPRECATED: Only used for old version program compatibility, will be completely deleted in subsequent iterative versions
#define FORMAT_MJPEG_TO_I420 FORMAT_MJPG_TO_I420
#define FORMAT_MJPEG_TO_NV21 FORMAT_MJPG_TO_NV21
#define FORMAT_MJPEG_TO_BGRA FORMAT_MJPG_TO_BGRA
#define FORMAT_YUYV_TO_RGB888 FORMAT_YUYV_TO_RGB
#define FORMAT_I420_TO_RGB888 FORMAT_I420_TO_RGB
#define FORMAT_NV21_TO_RGB888 FORMAT_NV21_TO_RGB
#define FORMAT_NV12_TO_RGB888 FORMAT_NV12_TO_RGB
#define FORMAT_UYVY_TO_RGB888 FORMAT_UYVY_TO_RGB
#define FORMAT_MJPG_TO_RGB888 FORMAT_MJPG_TO_RGB
#define FORMAT_MJPG_TO_BGR888 FORMAT_MJPG_TO_BGR
#define FORMAT_MJPEG_TO_RGB888 FORMAT_MJPG_TO_RGB
#define FORMAT_MJPEG_TO_BGR888 FORMAT_MJPG_TO_BGR
#define FORMAT_RGB888_TO_BGR FORMAT_RGB_TO_BGR

typedef enum {
    OB_SAMPLE_RATE_UNKNOWN   = 0,
    OB_SAMPLE_RATE_1_5625_HZ = 1,  
    OB_SAMPLE_RATE_3_125_HZ  = 2,  
    OB_SAMPLE_RATE_6_25_HZ   = 3,  
    OB_SAMPLE_RATE_12_5_HZ   = 4,  
    OB_SAMPLE_RATE_25_HZ     = 5,  
    OB_SAMPLE_RATE_50_HZ     = 6,  
    OB_SAMPLE_RATE_100_HZ    = 7,  
    OB_SAMPLE_RATE_200_HZ    = 8,  
    OB_SAMPLE_RATE_500_HZ    = 9,  
    OB_SAMPLE_RATE_1_KHZ     = 10, 
    OB_SAMPLE_RATE_2_KHZ     = 11, 
    OB_SAMPLE_RATE_4_KHZ     = 12, 
    OB_SAMPLE_RATE_8_KHZ     = 13, 
    OB_SAMPLE_RATE_16_KHZ    = 14, 
    OB_SAMPLE_RATE_32_KHZ    = 15, 
    OB_SAMPLE_RATE_400_HZ    = 16, 
    OB_SAMPLE_RATE_800_HZ    = 17, 
} OBIMUSampleRate,
    OBGyroSampleRate, ob_gyro_sample_rate, OBAccelSampleRate, ob_accel_sample_rate, OB_SAMPLE_RATE;

typedef enum {
    OB_GYRO_FS_UNKNOWN = -1,
    OB_GYRO_FS_16dps   = 1,  
    OB_GYRO_FS_31dps   = 2,  
    OB_GYRO_FS_62dps   = 3,  
    OB_GYRO_FS_125dps  = 4,  
    OB_GYRO_FS_250dps  = 5,  
    OB_GYRO_FS_500dps  = 6,  
    OB_GYRO_FS_1000dps = 7,  
    OB_GYRO_FS_2000dps = 8,  
    OB_GYRO_FS_400dps  = 9,  
    OB_GYRO_FS_800dps  = 10, 
} OBGyroFullScaleRange,
    ob_gyro_full_scale_range, OB_GYRO_FULL_SCALE_RANGE;

typedef enum {
    OB_ACCEL_FS_UNKNOWN = -1,
    OB_ACCEL_FS_2g      = 1, 
    OB_ACCEL_FS_4g      = 2, 
    OB_ACCEL_FS_8g      = 3, 
    OB_ACCEL_FS_16g     = 4, 
    OB_ACCEL_FS_3g      = 5, 
    OB_ACCEL_FS_6g      = 6, 
    OB_ACCEL_FS_12g     = 7, 
    OB_ACCEL_FS_24g     = 8, 
} OBAccelFullScaleRange,
    ob_accel_full_scale_range, OB_ACCEL_FULL_SCALE_RANGE;

typedef struct {
    float x;  
    float y;  
    float z;  
} OBAccelValue, OBGyroValue, OBFloat3D, ob_accel_value, ob_gyro_value, ob_float_3d;

typedef uint64_t OBDeviceState, ob_device_state;

typedef struct {
    float cpuTemp;         
    float irTemp;          
    float ldmTemp;         
    float mainBoardTemp;   
    float tecTemp;         
    float imuTemp;         
    float rgbTemp;         
    float irLeftTemp;      
    float irRightTemp;     
    float chipTopTemp;     
    float chipBottomTemp;  
} OBDeviceTemperature, ob_device_temperature, DEVICE_TEMPERATURE;

typedef enum {
    DEPTH_CROPPING_MODE_AUTO  = 0, 
    DEPTH_CROPPING_MODE_CLOSE = 1, 
    DEPTH_CROPPING_MODE_OPEN  = 2, 
} OBDepthCroppingMode,
    ob_depth_cropping_mode, OB_DEPTH_CROPPING_MODE;

typedef enum {
    OB_DEVICE_TYPE_UNKNOWN               = -1, 
    OB_STRUCTURED_LIGHT_MONOCULAR_CAMERA = 0,  
    OB_STRUCTURED_LIGHT_BINOCULAR_CAMERA = 1,  
    OB_TOF_CAMERA                        = 2,  
} OBDeviceType,
    ob_device_type, OB_DEVICE_TYPE;

typedef enum {
    OB_MEDIA_COLOR_STREAM    = 1,   
    OB_MEDIA_DEPTH_STREAM    = 2,   
    OB_MEDIA_IR_STREAM       = 4,   
    OB_MEDIA_GYRO_STREAM     = 8,   
    OB_MEDIA_ACCEL_STREAM    = 16,  
    OB_MEDIA_CAMERA_PARAM    = 32,  
    OB_MEDIA_DEVICE_INFO     = 64,  
    OB_MEDIA_STREAM_INFO     = 128, 
    OB_MEDIA_IR_LEFT_STREAM  = 256, 
    OB_MEDIA_IR_RIGHT_STREAM = 512, 
 
    OB_MEDIA_ALL = OB_MEDIA_COLOR_STREAM | OB_MEDIA_DEPTH_STREAM | OB_MEDIA_IR_STREAM | OB_MEDIA_GYRO_STREAM | OB_MEDIA_ACCEL_STREAM | OB_MEDIA_CAMERA_PARAM
                   | OB_MEDIA_DEVICE_INFO | OB_MEDIA_STREAM_INFO | OB_MEDIA_IR_LEFT_STREAM | OB_MEDIA_IR_RIGHT_STREAM, 
} OBMediaType,
    ob_media_type, OB_MEDIA_TYPE;

typedef enum {
    OB_MEDIA_BEGIN = 0, 
    OB_MEDIA_PAUSE,     
    OB_MEDIA_RESUME,    
    OB_MEDIA_END,       
} OBMediaState,
    ob_media_state, OB_MEDIA_STATE_EM;

typedef enum {
    OB_PRECISION_1MM,   
    OB_PRECISION_0MM8,  
    OB_PRECISION_0MM4,  
    OB_PRECISION_0MM1,  
    OB_PRECISION_0MM2,  
    OB_PRECISION_0MM5,  
    OB_PRECISION_0MM05, 
    OB_PRECISION_UNKNOWN,
    OB_PRECISION_COUNT,
} OBDepthPrecisionLevel,
    ob_depth_precision_level, OB_DEPTH_PRECISION_LEVEL, OBDepthUnit, ob_depth_unit;

typedef struct {
    double  zpd;           // the distance to calib plane
    double  zpps;          // zpps=z0/fx
    float   baseline;      // baseline length, for monocular camera,it means the distance of laser to the center of IR-CMOS
    double  fx;            // focus
    uint8_t bitSize;       // disparity bit size (raw disp bit size, for example: MX6000 is 12, MX6600 is 14)
    float   unit;          // reference units: unit=10 denote 1cm; unit=1 denote 1mm; unit=0.5 denote 0.5mm; and so on
    float   minDisparity;  // dual disparity coefficient
    uint8_t packMode;      // data pack mode
    float   dispOffset;    // disparity offset, actual disp=chip disp + disp_offset
    int32_t invalidDisp;   // invalid disparity, usually is 0, dual IR add a auxiliary value.
    int32_t dispIntPlace;  // disp integer digits, default is 8, Gemini2 XL is 10
    uint8_t isDualCamera;  // 0 monocular camera, 1 dual camera
} OBDisparityParam, ob_disparity_param;

typedef enum {
    OB_TOF_FILTER_RANGE_CLOSE  = 0,   
    OB_TOF_FILTER_RANGE_MIDDLE = 1,   
    OB_TOF_FILTER_RANGE_LONG   = 2,   
    OB_TOF_FILTER_RANGE_DEBUG  = 100, 
} OBTofFilterRange,
    ob_tof_filter_range, TOF_FILTER_RANGE;
typedef struct {
    float x;  
    float y;  
    float z;  
} OBPoint, ob_point, OBPoint3f, ob_point3f;

typedef struct {
    float x;  
    float y;  
} OBPoint2f, ob_point2f;
 
typedef struct {
    float *xTable;  
    float *yTable;  
    int    width;   
    int    height;  
} OBXYTables, ob_xy_tables;

typedef struct {
    float x;  
    float y;  
    float z;  
    float r;  
    float g;  
    float b;  
} OBColorPoint, ob_color_point;

typedef enum {
    OB_COMPRESSION_LOSSLESS = 0, 
    OB_COMPRESSION_LOSSY    = 1, 
} OBCompressionMode,
    ob_compression_mode, OB_COMPRESSION_MODE;

typedef struct {
    int threshold;
} OBCompressionParams, ob_compression_params, OB_COMPRESSION_PARAMS;

typedef struct {
    int32_t upper;  
    int32_t lower;  
} OBTofExposureThresholdControl, ob_tof_exposure_threshold_control, TOF_EXPOSURE_THRESHOLD_CONTROL;

typedef enum {
    OB_SYNC_MODE_CLOSE = 0x00,

    OB_SYNC_MODE_STANDALONE = 0x01,

    OB_SYNC_MODE_PRIMARY = 0x02,

    OB_SYNC_MODE_SECONDARY = 0x03,

    OB_SYNC_MODE_PRIMARY_MCU_TRIGGER = 0x04,

    OB_SYNC_MODE_PRIMARY_IR_TRIGGER = 0x05,

    OB_SYNC_MODE_PRIMARY_SOFT_TRIGGER = 0x06,

    OB_SYNC_MODE_SECONDARY_SOFT_TRIGGER = 0x07,

    OB_SYNC_MODE_IR_IMU_SYNC = 0x08,

    OB_SYNC_MODE_UNKNOWN = 0xff,
 
} OBSyncMode,
    ob_sync_mode, OB_SYNC_MODE;

typedef struct {
    OBSyncMode syncMode;

    uint16_t irTriggerSignalInDelay;

    uint16_t rgbTriggerSignalInDelay;

    uint16_t deviceTriggerSignalOutDelay;

    uint16_t deviceTriggerSignalOutPolarity;

    uint16_t mcuTriggerFrequency;

    uint16_t deviceId;
 
} OBDeviceSyncConfig, ob_device_sync_config, OB_DEVICE_SYNC_CONFIG;

typedef enum {
    OB_DEVICE_DEPTH_WORK_MODE = 0,
    OB_CUSTOM_DEPTH_WORK_MODE = 1,
} OBDepthWorkModeTag,
    ob_depth_work_mode_tag;

typedef struct {
    uint8_t checksum[16];

    char name[32];
    OBDepthWorkModeTag tag;
 
} OBDepthWorkMode, ob_depth_work_mode;

typedef struct {
    int  sequenceSelectId;
    char name[8];
} OBSequenceIdItem, ob_sequence_id_item;

typedef enum {
    OB_HOLE_FILL_TOP     = 0,
    OB_HOLE_FILL_NEAREST = 1,  // "max" means farest for depth, and nearest for disparity; FILL_NEAREST
    OB_HOLE_FILL_FAREST  = 2,  // FILL_FAREST
} OBHoleFillingMode,
    ob_hole_filling_mode;
 
typedef struct {
    uint8_t radius;  // window_size
} OBSpatialFastFilterParams, ob_spatial_fast_filter_params;
 
typedef struct {
    uint8_t  radius;     // window_size
    uint8_t  magnitude;  // magnitude
    uint16_t disp_diff;  // smooth_delta
} OBSpatialModerateFilterParams, ob_spatial_moderate_filter_params;
 
typedef struct {
    uint8_t  magnitude;  // magnitude
    float    alpha;      // smooth_alpha
    uint16_t disp_diff;  // smooth_delta
    uint16_t radius;     // hole_fill
} OBSpatialAdvancedFilterParams, ob_spatial_advanced_filter_params;
 
typedef enum OB_EDGE_NOISE_REMOVAL_TYPE {
    OB_MG_FILTER  = 0,
    OB_MGH_FILTER = 1,  // horizontal MG
    OB_MGA_FILTER = 2,  // asym MG
    OB_MGC_FILTER = 3,
} OBEdgeNoiseRemovalType,
    ob_edge_noise_removal_type;
 
typedef struct {
    OBEdgeNoiseRemovalType type;
    uint16_t               marginLeftTh;
    uint16_t               marginRightTh;
    uint16_t               marginTopTh;
    uint16_t               marginBottomTh;
} OBEdgeNoiseRemovalFilterParams, ob_edge_noise_removal_filter_params;

typedef enum OB_DDO_NOISE_REMOVAL_TYPE {
    OB_NR_LUT     = 0,  // SPLIT
    OB_NR_OVERALL = 1,  // NON_SPLIT
} OBDDONoiseRemovalType,
    ob_ddo_noise_removal_type;
 
typedef struct {
    uint16_t              max_size;
    uint16_t              disp_diff;
    OBDDONoiseRemovalType type;
} OBNoiseRemovalFilterParams, ob_noise_removal_filter_params;

typedef struct {
    uint8_t major;

    uint8_t minor;

    uint8_t patch;
} OBProtocolVersion, ob_protocol_version;

typedef enum {
    OB_CMD_VERSION_V0 = (uint16_t)0,  
    OB_CMD_VERSION_V1 = (uint16_t)1,  
    OB_CMD_VERSION_V2 = (uint16_t)2,  
    OB_CMD_VERSION_V3 = (uint16_t)3,  
 
    OB_CMD_VERSION_NOVERSION = (uint16_t)0xfffe,
    OB_CMD_VERSION_INVALID   = (uint16_t)0xffff,  
} OB_CMD_VERSION,
    OBCmdVersion, ob_cmd_version;

typedef struct {
    uint16_t dhcp;

    uint8_t address[4];

    uint8_t mask[4];

    uint8_t gateway[4];
} OBNetIpConfig, ob_net_ip_config, DEVICE_IP_ADDR_CONFIG;
 
#define OBDeviceIpAddrConfig OBNetIpConfig
#define ob_device_ip_addr_config OBNetIpConfig

typedef enum {
    OB_COMM_USB = 0x00,  
    OB_COMM_NET = 0x01,  
} OBCommunicationType,
    ob_communication_type, OB_COMMUNICATION_TYPE;

typedef enum {
    OB_USB_POWER_NO_PLUGIN = 0,  
    OB_USB_POWER_5V_0A9    = 1,  
    OB_USB_POWER_5V_1A5    = 2,  
    OB_USB_POWER_5V_3A0    = 3,  
} OBUSBPowerState,
    ob_usb_power_state;

typedef enum {
    OB_DC_POWER_NO_PLUGIN = 0,  
    OB_DC_POWER_PLUGIN    = 1,  
} OBDCPowerState,
    ob_dc_power_state;

typedef enum {
    OB_ROTATE_DEGREE_0   = 0,    
    OB_ROTATE_DEGREE_90  = 90,   
    OB_ROTATE_DEGREE_180 = 180,  
    OB_ROTATE_DEGREE_270 = 270,  
} ob_rotate_degree_type,
    OBRotateDegreeType;

typedef enum {
    OB_POWER_LINE_FREQ_MODE_CLOSE = 0,  
    OB_POWER_LINE_FREQ_MODE_50HZ  = 1,  
    OB_POWER_LINE_FREQ_MODE_60HZ  = 2,  
} ob_power_line_freq_mode,
    OBPowerLineFreqMode;

typedef enum {
    OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE = 0,

    OB_FRAME_AGGREGATE_OUTPUT_COLOR_FRAME_REQUIRE,

    OB_FRAME_AGGREGATE_OUTPUT_ANY_SITUATION,
    OB_FRAME_AGGREGATE_OUTPUT_DISABLE,
} OB_FRAME_AGGREGATE_OUTPUT_MODE,
    OBFrameAggregateOutputMode, ob_frame_aggregate_output_mode;
#define OB_FRAME_AGGREGATE_OUTPUT_FULL_FRAME_REQUIRE OB_FRAME_AGGREGATE_OUTPUT_ALL_TYPE_FRAME_REQUIRE

typedef enum {
    OB_LEFT_HAND_COORDINATE_SYSTEM  = 0,
    OB_RIGHT_HAND_COORDINATE_SYSTEM = 1,
} OB_COORDINATE_SYSTEM_TYPE,
    OBCoordinateSystemType, ob_coordinate_system_type;

typedef enum {
    OB_USER_MODE = 0,

    OB_DEVELOPER_MODE = 1,
} OB_DEVICE_DEVELOPMENT_MODE,
    OBDeviceDevelopmentMode, ob_device_development_mode;

typedef enum {

    OB_MULTI_DEVICE_SYNC_MODE_FREE_RUN = 1 << 0,

    OB_MULTI_DEVICE_SYNC_MODE_STANDALONE = 1 << 1,

    OB_MULTI_DEVICE_SYNC_MODE_PRIMARY = 1 << 2,

    OB_MULTI_DEVICE_SYNC_MODE_SECONDARY = 1 << 3,

    OB_MULTI_DEVICE_SYNC_MODE_SECONDARY_SYNCED = 1 << 4,

    OB_MULTI_DEVICE_SYNC_MODE_SOFTWARE_TRIGGERING = 1 << 5,

    OB_MULTI_DEVICE_SYNC_MODE_HARDWARE_TRIGGERING = 1 << 6,

    OB_MULTI_DEVICE_SYNC_MODE_IR_IMU_SYNC = 1 << 7,
 
} ob_multi_device_sync_mode,
    OBMultiDeviceSyncMode;

typedef struct {
    OBMultiDeviceSyncMode syncMode;

    int depthDelayUs;

    int colorDelayUs;

    int trigger2ImageDelayUs;

    bool triggerOutEnable;

    int triggerOutDelayUs;

    int framesPerTrigger;
} ob_multi_device_sync_config, OBMultiDeviceSyncConfig;

typedef struct {
    bool enable;

    int timestamp_reset_delay_us;

    bool timestamp_reset_signal_output_enable;
} ob_device_timestamp_reset_config, OBDeviceTimestampResetConfig;

typedef struct {
    float baseline;
    float zpd;
} BASELINE_CALIBRATION_PARAM, ob_baseline_calibration_param, OBBaselineCalibrationParam;

typedef struct {

    uint8_t  enable;
    uint8_t  sequence_name;  
    uint32_t exposure_1;     
    uint32_t gain_1;         
    uint32_t exposure_2;     
    uint32_t gain_2;         
} HDR_CONFIG, ob_hdr_config, OBHdrConfig;

typedef struct {
    int16_t x0_left;
    int16_t y0_top;
    int16_t x1_right;
    int16_t y1_bottom;
} AE_ROI, ob_region_of_interest, OBRegionOfInterest;
 
typedef enum {
    OB_FILTER_CONFIG_VALUE_TYPE_INVALID = -1,
    OB_FILTER_CONFIG_VALUE_TYPE_INT     = 0,
    OB_FILTER_CONFIG_VALUE_TYPE_FLOAT   = 1,
    OB_FILTER_CONFIG_VALUE_TYPE_BOOLEAN = 2,
} OBFilterConfigValueType,
    ob_filter_config_value_type;
typedef struct {
    const char             *name;  
    OBFilterConfigValueType type;  
    double                  min;   
    double                  max;   
    double                  step;  
    double                  def;   
    const char             *desc;  
} OBFilterConfigSchemaItem, ob_filter_config_schema_item;

typedef struct {
    char numberStr[16];
} OBDeviceSerialNumber, ob_device_serial_number, OBSerialNumber, ob_serial_number;

typedef struct {
    uint8_t enable;
    uint8_t offset0;
    uint8_t offset1;
    uint8_t reserved;
} OBDispOffsetConfig, ob_disp_offset_config;

typedef enum {
    OB_FRAME_METADATA_TYPE_TIMESTAMP = 0,

    OB_FRAME_METADATA_TYPE_SENSOR_TIMESTAMP = 1,

    OB_FRAME_METADATA_TYPE_FRAME_NUMBER = 2,

    OB_FRAME_METADATA_TYPE_AUTO_EXPOSURE = 3,

    OB_FRAME_METADATA_TYPE_EXPOSURE = 4,

    OB_FRAME_METADATA_TYPE_GAIN = 5,

    OB_FRAME_METADATA_TYPE_AUTO_WHITE_BALANCE = 6,

    OB_FRAME_METADATA_TYPE_WHITE_BALANCE = 7,

    OB_FRAME_METADATA_TYPE_BRIGHTNESS = 8,

    OB_FRAME_METADATA_TYPE_CONTRAST = 9,

    OB_FRAME_METADATA_TYPE_SATURATION = 10,

    OB_FRAME_METADATA_TYPE_SHARPNESS = 11,

    OB_FRAME_METADATA_TYPE_BACKLIGHT_COMPENSATION = 12,

    OB_FRAME_METADATA_TYPE_HUE = 13,

    OB_FRAME_METADATA_TYPE_GAMMA = 14,

    OB_FRAME_METADATA_TYPE_POWER_LINE_FREQUENCY = 15,

    OB_FRAME_METADATA_TYPE_LOW_LIGHT_COMPENSATION = 16,

    OB_FRAME_METADATA_TYPE_MANUAL_WHITE_BALANCE = 17,

    OB_FRAME_METADATA_TYPE_ACTUAL_FRAME_RATE = 18,

    OB_FRAME_METADATA_TYPE_FRAME_RATE = 19,

    OB_FRAME_METADATA_TYPE_AE_ROI_LEFT = 20,

    OB_FRAME_METADATA_TYPE_AE_ROI_TOP = 21,

    OB_FRAME_METADATA_TYPE_AE_ROI_RIGHT = 22,

    OB_FRAME_METADATA_TYPE_AE_ROI_BOTTOM = 23,

    OB_FRAME_METADATA_TYPE_EXPOSURE_PRIORITY = 24,

    OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_NAME = 25,

    OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_SIZE = 26,

    OB_FRAME_METADATA_TYPE_HDR_SEQUENCE_INDEX = 27,

    OB_FRAME_METADATA_TYPE_LASER_POWER = 28,

    OB_FRAME_METADATA_TYPE_LASER_POWER_LEVEL = 29,

    OB_FRAME_METADATA_TYPE_LASER_STATUS = 30,

    OB_FRAME_METADATA_TYPE_GPIO_INPUT_DATA = 31,

    OB_FRAME_METADATA_TYPE_DISPARITY_SEARCH_OFFSET = 32,

    OB_FRAME_METADATA_TYPE_DISPARITY_SEARCH_RANGE = 33,

    OB_FRAME_METADATA_TYPE_COUNT,
} ob_frame_metadata_type,
    OBFrameMetadataType;

typedef enum {
    OB_UVC_BACKEND_TYPE_AUTO,

    OB_UVC_BACKEND_TYPE_LIBUVC,

    OB_UVC_BACKEND_TYPE_V4L2,

    OB_UVC_BACKEND_TYPE_MSMF,
} ob_uvc_backend_type,
    OBUvcBackendType;

typedef enum {
    OB_PLAYBACK_UNKNOWN,
    OB_PLAYBACK_PLAYING, 
    OB_PLAYBACK_PAUSED,  
    OB_PLAYBACK_STOPPED, 
    OB_PLAYBACK_COUNT,
} ob_playback_status,
    OBPlaybackStatus;

typedef enum {
    START_OF_EXPOSURE = 0, 
    MIDDLE_OF_EXPOSURE,    
    END_OF_EXPOSURE,       
} ob_intra_camera_sync_reference,
    OBIntraCameraSyncReference;
 
// For compatibility
#define OB_FRAME_METADATA_TYPE_LASER_POWER_MODE OB_FRAME_METADATA_TYPE_LASER_POWER_LEVEL
#define OB_FRAME_METADATA_TYPE_EMITTER_MODE OB_FRAME_METADATA_TYPE_LASER_STATUS

typedef void (*ob_file_send_callback)(ob_file_tran_state state, const char *message, uint8_t percent, void *user_data);

typedef void (*ob_device_fw_update_callback)(ob_fw_update_state state, const char *message, uint8_t percent, void *user_data);

typedef void (*ob_device_state_callback)(ob_device_state state, const char *message, void *user_data);

typedef void (*ob_set_data_callback)(ob_data_tran_state state, uint8_t percent, void *user_data);

typedef void (*ob_get_data_callback)(ob_data_tran_state state, ob_data_chunk *dataChunk, void *user_data);

typedef void (*ob_media_state_callback)(ob_media_state state, void *user_data);

typedef void (*ob_device_changed_callback)(ob_device_list *removed, ob_device_list *added, void *user_data);
 
// typedef void (*ob_net_device_added_callback)(const char *added, void *user_data);
// typedef void (*ob_net_device_removed_callback)(const char *removed, void *user_data);

typedef void (*ob_frame_callback)(ob_frame *frame, void *user_data);
#define ob_filter_callback ob_frame_callback
#define ob_playback_callback ob_frame_callback

typedef void (*ob_frameset_callback)(ob_frame *frameset, void *user_data);

typedef void(ob_frame_destroy_callback)(uint8_t *buffer, void *user_data);

typedef void(ob_log_callback)(ob_log_severity severity, const char *message, void *user_data);
 
typedef void (*ob_playback_status_changed_callback)(ob_playback_status status, void *user_data);
#define ob_is_video_sensor_type(sensor_type)                                                                                             \
    (sensor_type == OB_SENSOR_COLOR || sensor_type == OB_SENSOR_DEPTH || sensor_type == OB_SENSOR_IR || sensor_type == OB_SENSOR_IR_LEFT \
     || sensor_type == OB_SENSOR_IR_RIGHT || sensor_type == OB_SENSOR_CONFIDENCE)

#define ob_is_video_stream_type(stream_type)                                                                                             \
    (stream_type == OB_STREAM_COLOR || stream_type == OB_STREAM_DEPTH || stream_type == OB_STREAM_IR || stream_type == OB_STREAM_IR_LEFT \
     || stream_type == OB_STREAM_IR_RIGHT || stream_type == OB_STREAM_VIDEO || stream_type == OB_STREAM_CONFIDENCE)

#define is_ir_sensor(sensor_type) (sensor_type == OB_SENSOR_IR || sensor_type == OB_SENSOR_IR_LEFT || sensor_type == OB_SENSOR_IR_RIGHT)
#define isIRSensor is_ir_sensor

#define is_ir_stream(stream_type) (stream_type == OB_STREAM_IR || stream_type == OB_STREAM_IR_LEFT || stream_type == OB_STREAM_IR_RIGHT)
#define isIRStream is_ir_stream

#define is_ir_frame(frame_type) (frame_type == OB_FRAME_IR || frame_type == OB_FRAME_IR_LEFT || frame_type == OB_FRAME_IR_RIGHT)
#define isIRFrame is_ir_frame

#define OB_DEFAULT_DECRYPT_KEY (nullptr)
 
#ifdef __cplusplus
}
#endif
 
#pragma pack(pop)