ObTypes.h

Go to the documentation of this file.

// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2020 Orbbec  Corporation. All Rights Reserved.
 
#pragma once
#if(defined(WIN32) || defined(_WIN32) || defined(WINCE))
#ifdef OB_EXPORTS
#define OB_EXTENSION_API __declspec(dllexport)
#define OB_EXTENSION_INTERNAL_API __declspec(dllexport)
#elif defined(OB2_EXPORTS)
#define OB_EXTENSION_API __declspec(dllexport)
#define OB_EXTENSION_INTERNAL_API
#else
#ifndef OB_STATIC
#define OB_EXTENSION_API __declspec(dllimport)
#define OB_EXTENSION_INTERNAL_API __declspec(dllimport)
#else
#define OB_EXTENSION_API
#define OB_EXTENSION_INTERNAL_API
#endif
#endif
#else
#ifndef OB_STATIC
#define OB_EXTENSION_API __attribute__((visibility("default")))
#define OB_EXTENSION_INTERNAL_API __attribute__((visibility("default")))
#else
#define OB_EXTENSION_API
#define OB_EXTENSION_INTERNAL_API
#endif
#endif
 
#if defined(__GNUC__) || defined(__clang__)
#define DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define DEPRECATED __declspec(deprecated)
#else
#pragma message("WARNING: You need to implement DEPRECATED for this compiler")
#define DEPRECATED
#endif
 
#pragma pack(push, 1)  // struct 1-byte align
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdbool.h>
#include <stdint.h>
 
typedef struct ContextImpl             ob_context;
typedef struct DeviceImpl              ob_device;
typedef struct DeviceInfoImpl          ob_device_info;
typedef struct DeviceListImpl          ob_device_list;
typedef struct CameraParamListImpl     ob_camera_param_list;
typedef struct SensorImpl              ob_sensor;
typedef struct SensorListImpl          ob_sensor_list;
typedef struct StreamProfileImpl       ob_stream_profile;
typedef struct StreamProfileListImpl   ob_stream_profile_list;
typedef struct CFrameImpl              ob_frame;
typedef struct FilterImpl              ob_filter;
typedef struct PipelineImpl            ob_pipeline;
typedef struct ConfigImpl              ob_config;
typedef struct RecorderImpl            ob_recorder;
typedef struct PlaybackImpl            ob_playback;
typedef struct OBDepthWorkModeListImpl ob_depth_work_mode_list;
typedef struct FilterListImpl          ob_filter_list;
typedef struct OBFilterListImpl        ob_filters;
typedef struct DevicePresetListImpl    ob_device_preset_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_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
 
typedef enum {
    HP_STATUS_OK                      = 0,      
    HP_STATUS_NO_DEVICE_FOUND         = 1,      
    HP_STATUS_CONTROL_TRANSFER_FAILED = 2,      
    HP_STATUS_UNKNOWN_ERROR           = 0xffff, 
} OBHPStatusCode,
    ob_hp_status_code;
 
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_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_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,  
} 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_TYPE_COUNT,     
} OBFrameType,
    ob_frame_type;
 
typedef enum {
    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_DISP16     = 34,   
    OB_FORMAT_UNKNOWN    = 0xff, 
} 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
 
typedef enum {
    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  
} OBUpgradeState,
    ob_upgrade_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 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;  
} OBCameraDistortion, ob_camera_distortion;
 
typedef enum {
    OB_DISTORTION_NONE,                   
    OB_DISTORTION_MODIFIED_BROWN_CONRADY, 
    OB_DISTORTION_INVERSE_BROWN_CONRADY,  
    OB_DISTORTION_BROWN_CONRADY,          
} OBCameraDistortionModel,
    ob_camera_distortion_model;
 
typedef struct {
    int                     width;  
    int                     height; 
    float                   ppx;    
    float                   ppy;    
    float                   fx;     
    float                   fy;     
    OBCameraDistortionModel model;  
    float coeffs[5]; 
} OBCameraAlignIntrinsic, ob_camera_align_intrinsic;
 
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 {
    OBCameraIntrinsic  depthIntrinsic;   
    OBCameraIntrinsic  rgbIntrinsic;     
    OBCameraDistortion depthDistortion;  
 
    OBCameraDistortion rgbDistortion;  
    OBD2CTransform     transform;      
} OBCameraParam_V0, ob_camera_param_v0;
 
typedef struct {
    OBCameraIntrinsic  intrinsics[OB_SENSOR_COUNT];            
    OBCameraDistortion distortion[OB_SENSOR_COUNT];            
    OBExtrinsic extrinsics[OB_SENSOR_COUNT][OB_SENSOR_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 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,      
} 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,      
    OB_SAMPLE_RATE_6_25_HZ,       
    OB_SAMPLE_RATE_12_5_HZ,       
    OB_SAMPLE_RATE_25_HZ,         
    OB_SAMPLE_RATE_50_HZ,         
    OB_SAMPLE_RATE_100_HZ,        
    OB_SAMPLE_RATE_200_HZ,        
    OB_SAMPLE_RATE_500_HZ,        
    OB_SAMPLE_RATE_1_KHZ,         
    OB_SAMPLE_RATE_2_KHZ,         
    OB_SAMPLE_RATE_4_KHZ,         
    OB_SAMPLE_RATE_8_KHZ,         
    OB_SAMPLE_RATE_16_KHZ,        
    OB_SAMPLE_RATE_32_KHZ,        
} OBGyroSampleRate,
    ob_gyro_sample_rate, OBAccelSampleRate, ob_accel_sample_rate, OB_SAMPLE_RATE;
 
typedef enum {
    OB_GYRO_FS_UNKNOWN = 0, 
    OB_GYRO_FS_16dps   = 1, 
    OB_GYRO_FS_31dps,       
    OB_GYRO_FS_62dps,       
    OB_GYRO_FS_125dps,      
    OB_GYRO_FS_250dps,      
    OB_GYRO_FS_500dps,      
    OB_GYRO_FS_1000dps,     
    OB_GYRO_FS_2000dps,     
} OBGyroFullScaleRange,
    ob_gyro_full_scale_range, OB_GYRO_FULL_SCALE_RANGE;
 
typedef enum {
    OB_ACCEL_FS_UNKNOWN = 0, 
    OB_ACCEL_FS_2g      = 1, 
    OB_ACCEL_FS_4g,          
    OB_ACCEL_FS_8g,          
    OB_ACCEL_FS_16g,         
} OBAccelFullScaleRange,
    ob_accel_full_scale_range, OB_ACCEL_FULL_SCALE_RANGE;
 
typedef struct {
    float x;  
    float y;  
    float z;  
} OBAccelValue, OBGyroValue, ob_accel_value, ob_gyro_value;
 
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_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;
 
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_INDUSTRY_DEFAULT,
    OB_INDUSTRY_MODE1,
    OB_INDUSTRY_MODE2,
    OB_INDUSTRY_MODE3,
    OB_INDUSTRY_MODE4,
    OB_INDUSTRY_MODE5,
} OBDepthIndustryMode,
    ob_depth_industry_mode;
 
 
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_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 struct {
    uint8_t checksum[16];
 
    char name[32];
} 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  magnitude;  // magnitude
    float    alpha;      // smooth_alpha
    uint16_t disp_diff;  // smooth_delta
    uint16_t radius;     // hole_fill
} OBSpatialAdvancedFilterParams, ob_spatial_advanced_filter_params;
 
 
typedef struct {
    uint8_t  size;  //median filter window size
} OBSpatialFastFilterParams, ob_spatial_fast_filter_params;
 
 
typedef struct  {
    uint8_t  size ;
    uint8_t  magnitude ; // magnitude
    uint16_t disp_diff ;
} OBSpatialModerateFilterParams, ob_spatial_moderate_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 OBDataBundle {
    OBCmdVersion cmdVersion;
 
    void *data;
 
    uint32_t dataSize;
 
    uint32_t itemTypeSize;
 
    uint32_t itemCount;
} OBDataBundle, ob_data_bundle;
 
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_FULL_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;
 
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,
    OBMultiDeviceSyncMode;
 
typedef struct {
    ob_multi_device_sync_mode 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 struct {
    uint8_t enable;
    uint8_t offset0;
    uint8_t offset1;
    uint8_t reserved;
} DISP_OFFSET_CONFIG, ob_disp_offset_config, OBDispOffsetConfig;
 
typedef enum {
    UVC_BACKEND_AUTO   = 0,
    UVC_BACKEND_LIBUVC = 1,
    UVC_BACKEND_V4L2   = 2,
} UVC_BACKEND,
    ob_uvc_backend, OBUvcBackend;
 
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_COUNT,
} ob_frame_metadata_type,
    OBFrameMetadataType;
 
// 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_upgrade_callback)(ob_upgrade_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)(void *buffer, void *user_data);
 
typedef void(ob_log_callback)(ob_log_severity severity, const char *message, void *user_data);
 
#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)