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_application_config_t            ob_application_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;
typedef struct ob_color_preset_list_t             ob_color_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_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_LIDAR_SCAN_ANY OB_LIDAR_SCAN_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, 
    OB_ERROR_UNKNOWN = 1, 
 
    // // 00001 ~ 0999: Common errors (reserved range)
    OB_ERROR_INVALID_PARAMETER       = 100, 
    OB_ERROR_INVALID_DATA            = 101, 
    OB_ERROR_INVALID_DATA_LEN        = 102, 
    OB_ERROR_BUFFER_TOO_SMALL        = 103, 
    OB_ERROR_MEMORY                  = 104, 
    OB_ERROR_WAIT_TIMEOUT            = 105, 
    OB_ERROR_NOT_IMPLEMENTED         = 106, 
    OB_ERROR_UNSUPPORTED_OPERATION   = 107, 
    OB_ERROR_WRONG_API_CALL_SEQUENCE = 108, 
    OB_ERROR_NO_DEVICE               = 109, 
    OB_ERROR_DEVICE_CONNECT_FAILED   = 110, 
    OB_ERROR_DEVICE_ACCESS_DENIED    = 111, 
    OB_ERROR_DEVICE_DISCONNECTED     = 112, 
    OB_ERROR_DEVICE_UNAVAILABLE      = 113, 
    OB_ERROR_ITEM_NOT_FOUND          = 114, 
    OB_ERROR_IO_FAILURE              = 115, 
    OB_ERROR_RESOURCE_BUSY           = 116, 
 
    // - Pipeline/Frame
    OB_ERROR_FRAME_QUEUE_OVERFLOW = 200, 
    OB_ERROR_FRAME_DATA           = 201, 
    OB_ERROR_FRAME_DATA_LEN       = 202, 
 
    // 1000 ~ 1999: Device errors
    OB_ERROR_DEVICE_UNKNOWN                  = 1000, 
    OB_ERROR_DEVICE_RESPONSE_BAD_MAGIC       = 1001, 
    OB_ERROR_DEVICE_RESPONSE_WRONG_ID        = 1002, 
    OB_ERROR_DEVICE_RESPONSE_WRONG_OPCODE    = 1003, 
    OB_ERROR_DEVICE_RESPONSE_WRONG_DATA_SIZE = 1004, 
    OB_ERROR_DEVICE_RESPONSE_ERROR           = 1005, 
    OB_ERROR_DEVICE_RESPONSE_WARNING         = 1006, 
    OB_ERROR_DEVICE_RESPONSE_CHANNEL_FAILURE = 1007, 
 
} OBStatus,
    OBErrorCode, ob_status, ob_error_code;

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,   
    OB_EXCEPTION_TYPE_ACCESS_DENIED,           
    OB_EXCEPTION_TYPE_DEVICE_UNAVAILABLE,      
    OB_EXCEPTION_TYPE_INVALID_DATA,            
    OB_EXCEPTION_TYPE_NOT_FOUND,               
    OB_EXCEPTION_TYPE_RESOURCE_BUSY,           
    OB_EXCEPTION_TYPE_LICENSE_VERIFY_FAILED,   
} 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_GVCP_PORT_SCHEME_STANDARD = 0, 
    OB_GVCP_PORT_SCHEME_B        = 1, 
} OBGvcpPortScheme,
    ob_gvcp_port_scheme;

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_LIDAR       = 10, 
    OB_SENSOR_COLOR_LEFT  = 11, 
    OB_SENSOR_COLOR_RIGHT = 12, 
    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_LIDAR       = 10, 
    OB_STREAM_COLOR_LEFT  = 11, 
    OB_STREAM_COLOR_RIGHT = 12, 
    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_LIDAR_POINTS = 12, 
    OB_FRAME_COLOR_LEFT   = 13, 
    OB_FRAME_COLOR_RIGHT  = 14, 
    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, 
    OB_FORMAT_LIDAR_POINT        = 35, 
    OB_FORMAT_LIDAR_SPHERE_POINT = 36, 
    OB_FORMAT_LIDAR_SCAN         = 37, 
    OB_FORMAT_LIDAR_CALIBRATION  = 38, 
} 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_REBOOT_AND_REUPDATE = 7,   
    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, 
    ERR_FILE_READ                 = -12, 
    ERR_TRANSFER                  = -13  
} 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 {
    const uint8_t *data;      
    uint32_t       dataSize;  
} OBDataView, ob_data_view;

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, 
    ALIGN_C2D_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 enum {
    OB_LIDAR_SCAN_UNKNOWN = 0,
    OB_LIDAR_SCAN_5HZ     = 1,
    OB_LIDAR_SCAN_10HZ    = 2,
    OB_LIDAR_SCAN_15HZ    = 3,
    OB_LIDAR_SCAN_20HZ    = 4,
    OB_LIDAR_SCAN_25HZ    = 5,
    OB_LIDAR_SCAN_30HZ    = 6,
    OB_LIDAR_SCAN_40HZ    = 7,
} OBLiDARScanRate,
    ob_lidar_scan_rate, OB_LIDAR_SCAN_RATE;

typedef uint64_t OBDeviceState, ob_device_state;

typedef enum {
    OB_PIPELINE_ISSUE_NONE   = 0x00, 
    OB_PIPELINE_ISSUE_SDK    = 0x01, 
    OB_PIPELINE_ISSUE_DRIVER = 0x02, 
    OB_PIPELINE_ISSUE_FW     = 0x04, 
    OB_PIPELINE_ISSUE_HW     = 0x08, 
} OBPipelineIssue,
    ob_pipeline_issue;

#define OB_SDK_STATUS_FRAME_DROP_DATA (1ULL << 0)      
#define OB_SDK_STATUS_FRAME_DROP_TIMESTAMP (1ULL << 1) 
#define OB_SDK_STATUS_FRAME_DROP_MATCH (1ULL << 2)     
#define OB_SDK_STATUS_FRAME_QUEUE_OVERFLOW (1ULL << 3) 
#define OB_SDK_STATUS_FRAME_WAIT_TIMEOUT (1ULL << 4)   
#define OB_SDK_STATUS_STREAM_NO_FRAME (1ULL << 5)      

typedef struct {
    OBPipelineIssue issue;       
    uint64_t        sdkStatus;   
    uint64_t        devStatus;   
    uint64_t        drvStatus;   
    uint64_t        reserved[3]; 
} OBPipelineStatus, ob_pipeline_status;

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 struct {
    float    angle;      
    float    distance;   
    uint16_t intensity;  
} OBLiDARScanPoint, ob_lidar_scan_point;

typedef struct {
    float   x;             
    float   y;             
    float   z;             
    uint8_t reflectivity;  
    uint8_t tag;           
} OBLiDARPoint, ob_lidar_point;

typedef struct {
    float   distance;      
    float   theta;         
    float   phi;           
    uint8_t reflectivity;  
    uint8_t tag;           
} OBLiDARSpherePoint, ob_lidar_sphere_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 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 {
    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;  
} OBEdgeNoiseRemovalFilterParams, ob_edge_noise_removal_filter_params;

typedef struct {
    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;       
    uint32_t width;            
    uint32_t height;           
} OBMgcNoiseRemovalFilterParams, ob_mgc_noise_removal_filter_params;

typedef struct {
    uint16_t max_lut[16];  
    uint16_t min_diff;     
    uint32_t width;        
    uint32_t height;       
} OBLutNoiseRemovalFilterParams, ob_lut_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
 
// IP bit masks
#define OB_NET_IP_FLAG_DHCP (0x01u)
#define OB_NET_IP_FLAG_PERSISTENT (0x02u)

typedef struct {
    uint16_t flags;      
    uint8_t address[4];  
    uint8_t mask[4];     
    uint8_t gateway[4];  
} OBNetIpConfigV2, ob_net_ip_config_v2, DEVICE_IP_ADDR_CONFIG_V2;

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_DEFAULT = 0,

    OB_WARM_BIASED_AWB = 1,
} OBColorPreset,
    ob_color_preset;

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_SOFTWARE_SYNCED = 1 << 8,

    OB_MULTI_DEVICE_SYNC_MODE_GROUP_ACTIONS = 1 << 9,
} 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 ob_priv_filter_activate_options {
    uint32_t    struct_size;        
    const char *model_path;  
}OBPrivFilterActivateOptions, ob_priv_filter_activate_options;

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 struct {
    uint32_t originWidth;   
    uint32_t originHeight;  
    uint32_t factor;        
} OBHardwareDecimationConfig, ob_hardware_decimation_config;

typedef struct {
    uint16_t rGain;  
    uint16_t bGain;  
    uint16_t gGain;  
} OBAwbGainParams, ob_awb_gain_params;

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 {
    OB_START_OF_EXPOSURE = 0, 
    OB_MIDDLE_OF_EXPOSURE,    
    OB_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
#define START_OF_EXPOSURE OB_START_OF_EXPOSURE
#define MIDDLE_OF_EXPOSURE OB_MIDDLE_OF_EXPOSURE
#define END_OF_EXPOSURE OB_END_OF_EXPOSURE

typedef enum {
    OB_DEVICE_ACCESS_DENIED    = 0,  
    OB_DEVICE_EXCLUSIVE_ACCESS = 1,  
    OB_DEVICE_CONTROL_ACCESS   = 2,  
    OB_DEVICE_MONITOR_ACCESS   = 3,  
    OB_DEVICE_DEFAULT_ACCESS   = 4,  
} ob_device_access_mode,
    OBDeviceAccessMode;

typedef enum {
    OB_DEVICE_ACCESS_STATE_UNKNOWN          = 0,  
    OB_DEVICE_ACCESS_STATE_UNSUPPORTED      = 1,  
    OB_DEVICE_ACCESS_STATE_AVAILABLE        = 2,  
    OB_DEVICE_ACCESS_STATE_CONTROLLED       = 3,  
    OB_DEVICE_ACCESS_STATE_EXCLUSIVE        = 4,  
    OB_DEVICE_ACCESS_STATE_UNREACHABLE      = 5,  
    OB_DEVICE_ACCESS_STATE_FW_NOT_SUPPORTED = 6,  
} ob_device_access_state,
    OBDeviceAccessState;
 
typedef enum {
    OB_IP_SOURCE_NONE       = 0,  
    OB_IP_SOURCE_LLA        = 1,  
    OB_IP_SOURCE_DHCP       = 2,  
    OB_IP_SOURCE_PERSISTENT = 3,  
} ob_ip_source_type,
    OBIpSourceType;

typedef enum {
    OB_CLOCK_TYPE_REALTIME  = 0, 
    OB_CLOCK_TYPE_MONOTONIC = 1, 
} OBClockType,
    ob_clock_type;

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);

typedef void (*ob_pipeline_status_callback)(ob_pipeline_status status, void *user_data);

typedef uint64_t OBCallbackId, ob_callback_id;
#define INVALID_CALLBACK_ID (0)

#define ob_is_video_sensor_type(sensor_type)                                                                                                         \
    (sensor_type == OB_SENSOR_COLOR || sensor_type == OB_SENSOR_COLOR_LEFT || sensor_type == OB_SENSOR_COLOR_RIGHT || 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_COLOR_LEFT || stream_type == OB_STREAM_COLOR_RIGHT || 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_color_sensor(sensor_type) (sensor_type == OB_SENSOR_COLOR || sensor_type == OB_SENSOR_COLOR_LEFT || sensor_type == OB_SENSOR_COLOR_RIGHT)
#define isColorSensor is_color_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_color_stream(stream_type) (stream_type == OB_STREAM_COLOR || stream_type == OB_STREAM_COLOR_LEFT || stream_type == OB_STREAM_COLOR_RIGHT)
#define isColorStream is_color_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 is_color_frame(frame_type) (frame_type == OB_FRAME_COLOR || frame_type == OB_FRAME_COLOR_LEFT || frame_type == OB_FRAME_COLOR_RIGHT)
#define isColorFrame is_color_frame

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