realsense2 (JavaCPP Presets for librealsense2 2.53.1-1.5.9 API)

java.lang.Object
- org.bytedeco.librealsense2.presets.realsense2
- - org.bytedeco.librealsense2.global.realsense2

All Implemented Interfaces:: InfoMapper

public class realsense2
extends realsense2

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`RS2_AMBIENT_LIGHT_LOW_AMBIENT` enum rs2_ambient_light
`static int`	`RS2_AMBIENT_LIGHT_NO_AMBIENT` enum rs2_ambient_light
`static int`	`RS2_API_BUILD_VERSION`
`static String`	`RS2_API_FULL_VERSION_STR`
`static int`	`RS2_API_MAJOR_VERSION` \file rs.h \brief Exposes librealsense functionality for C compilers
`static int`	`RS2_API_MINOR_VERSION`
`static int`	`RS2_API_PATCH_VERSION`
`static int`	`RS2_API_VERSION`
`static String`	`RS2_API_VERSION_STR`
`static int`	`RS2_CALIB_TARGET_COUNT` enum rs2_calib_target_type
`static int`	`RS2_CALIB_TARGET_POS_GAUSSIAN_DOT_VERTICES` enum rs2_calib_target_type
`static int`	`RS2_CALIB_TARGET_RECT_GAUSSIAN_DOT_VERTICES` enum rs2_calib_target_type
`static int`	`RS2_CALIB_TARGET_ROI_RECT_GAUSSIAN_DOT_VERTICES` enum rs2_calib_target_type
`static int`	`RS2_CALIBRATION_AUTO_DEPTH_TO_RGB` enum rs2_calibration_type
`static int`	`RS2_CALIBRATION_BAD_CONDITIONS` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_BAD_RESULT` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_FAILED` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_MANUAL_DEPTH_TO_RGB` enum rs2_calibration_type
`static int`	`RS2_CALIBRATION_NOT_NEEDED` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_RETRY` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_SCENE_INVALID` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_SPECIAL_FRAME` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_STARTED` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_STATUS_COUNT` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_STATUS_FIRST` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_STATUS_LAST` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_SUCCESSFUL` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_THERMAL` enum rs2_calibration_type
`static int`	`RS2_CALIBRATION_TRIGGERED` enum rs2_calibration_status
`static int`	`RS2_CALIBRATION_TYPE_COUNT` enum rs2_calibration_type
`static int`	`RS2_CAMERA_INFO_ADVANCED_MODE` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_ASIC_SERIAL_NUMBER` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_CAMERA_LOCKED` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_COUNT` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_DEBUG_OP_CODE` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_FIRMWARE_UPDATE_ID` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_FIRMWARE_VERSION` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_IP_ADDRESS` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_NAME` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_PHYSICAL_PORT` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_PRODUCT_ID` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_PRODUCT_LINE` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_RECOMMENDED_FIRMWARE_VERSION` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_SERIAL_NUMBER` enum rs2_camera_info
`static int`	`RS2_CAMERA_INFO_USB_TYPE_DESCRIPTOR` enum rs2_camera_info
`static int`	`RS2_DEFAULT_TIMEOUT` \file rs_pipeline.h \brief Exposes RealSense processing-block functionality for C compilers
`static int`	`RS2_DIGITAL_GAIN_AUTO` enum rs2_digital_gain
`static int`	`RS2_DIGITAL_GAIN_HIGH` enum rs2_digital_gain
`static int`	`RS2_DIGITAL_GAIN_LOW` enum rs2_digital_gain
`static int`	`RS2_DISTORTION_BROWN_CONRADY` enum rs2_distortion
`static int`	`RS2_DISTORTION_COUNT` enum rs2_distortion
`static int`	`RS2_DISTORTION_FTHETA` enum rs2_distortion
`static int`	`RS2_DISTORTION_INVERSE_BROWN_CONRADY` enum rs2_distortion
`static int`	`RS2_DISTORTION_KANNALA_BRANDT4` enum rs2_distortion
`static int`	`RS2_DISTORTION_MODIFIED_BROWN_CONRADY` enum rs2_distortion
`static int`	`RS2_DISTORTION_NONE` enum rs2_distortion
`static int`	`RS2_DSM_CORRECTION_AOT` enum rs2_dsm_correction_model
`static int`	`RS2_DSM_CORRECTION_COUNT` enum rs2_dsm_correction_model
`static int`	`RS2_DSM_CORRECTION_NONE` enum rs2_dsm_correction_model
`static int`	`RS2_DSM_CORRECTION_TOA` enum rs2_dsm_correction_model
`static int`	`RS2_EMITTER_FREQUENCY_57_KHZ` enum rs2_emitter_frequency_mode
`static int`	`RS2_EMITTER_FREQUENCY_91_KHZ` enum rs2_emitter_frequency_mode
`static int`	`RS2_EMITTER_FREQUENCY_COUNT` enum rs2_emitter_frequency_mode
`static int`	`RS2_EXCEPTION_TYPE_BACKEND` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_CAMERA_DISCONNECTED` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_COUNT` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_DEVICE_IN_RECOVERY_MODE` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_INVALID_VALUE` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_IO` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_NOT_IMPLEMENTED` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_UNKNOWN` enum rs2_exception_type
`static int`	`RS2_EXCEPTION_TYPE_WRONG_API_CALL_SEQUENCE` enum rs2_exception_type
`static int`	`RS2_EXTENSION_ADVANCED_MODE` enum rs2_extension
`static int`	`RS2_EXTENSION_AUTO_CALIBRATED_DEVICE` enum rs2_extension
`static int`	`RS2_EXTENSION_AUTO_CALIBRATION_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_CALIBRATED_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_CALIBRATION_CHANGE_DEVICE` enum rs2_extension
`static int`	`RS2_EXTENSION_COLOR_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_COMPOSITE_FRAME` enum rs2_extension
`static int`	`RS2_EXTENSION_COUNT` enum rs2_extension
`static int`	`RS2_EXTENSION_DEBUG` enum rs2_extension
`static int`	`RS2_EXTENSION_DEBUG_STREAM_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_DECIMATION_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_DEPTH_FRAME` enum rs2_extension
`static int`	`RS2_EXTENSION_DEPTH_HUFFMAN_DECODER` enum rs2_extension
`static int`	`RS2_EXTENSION_DEPTH_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_DEPTH_STEREO_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_DEVICE_CALIBRATION` enum rs2_extension
`static int`	`RS2_EXTENSION_DISPARITY_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_DISPARITY_FRAME` enum rs2_extension
`static int`	`RS2_EXTENSION_FISHEYE_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_FW_LOGGER` enum rs2_extension
`static int`	`RS2_EXTENSION_GLOBAL_TIMER` enum rs2_extension
`static int`	`RS2_EXTENSION_HDR_MERGE` enum rs2_extension
`static int`	`RS2_EXTENSION_HOLE_FILLING_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_INFO` enum rs2_extension
`static int`	`RS2_EXTENSION_L500_DEPTH_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_MAX_USABLE_RANGE_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_MOTION` enum rs2_extension
`static int`	`RS2_EXTENSION_MOTION_FRAME` enum rs2_extension
`static int`	`RS2_EXTENSION_MOTION_PROFILE` enum rs2_extension
`static int`	`RS2_EXTENSION_MOTION_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_OPTIONS` enum rs2_extension
`static int`	`RS2_EXTENSION_PLAYBACK` enum rs2_extension
`static int`	`RS2_EXTENSION_POINTS` enum rs2_extension
`static int`	`RS2_EXTENSION_POSE` enum rs2_extension
`static int`	`RS2_EXTENSION_POSE_FRAME` enum rs2_extension
`static int`	`RS2_EXTENSION_POSE_PROFILE` enum rs2_extension
`static int`	`RS2_EXTENSION_POSE_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_RECOMMENDED_FILTERS` enum rs2_extension
`static int`	`RS2_EXTENSION_RECORD` enum rs2_extension
`static int`	`RS2_EXTENSION_ROI` enum rs2_extension
`static int`	`RS2_EXTENSION_SEQUENCE_ID_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_SERIALIZABLE` enum rs2_extension
`static int`	`RS2_EXTENSION_SOFTWARE_DEVICE` enum rs2_extension
`static int`	`RS2_EXTENSION_SOFTWARE_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_SPATIAL_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_TEMPORAL_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_THRESHOLD_FILTER` enum rs2_extension
`static int`	`RS2_EXTENSION_TM2` enum rs2_extension
`static int`	`RS2_EXTENSION_TM2_SENSOR` enum rs2_extension
`static int`	`RS2_EXTENSION_UNKNOWN` enum rs2_extension
`static int`	`RS2_EXTENSION_UPDATABLE` enum rs2_extension
`static int`	`RS2_EXTENSION_UPDATE_DEVICE` enum rs2_extension
`static int`	`RS2_EXTENSION_VIDEO` enum rs2_extension
`static int`	`RS2_EXTENSION_VIDEO_FRAME` enum rs2_extension
`static int`	`RS2_EXTENSION_VIDEO_PROFILE` enum rs2_extension
`static int`	`RS2_EXTENSION_WHEEL_ODOMETER` enum rs2_extension
`static int`	`RS2_EXTENSION_ZERO_ORDER_FILTER` enum rs2_extension
`static int`	`RS2_FORMAT_6DOF` enum rs2_format
`static int`	`RS2_FORMAT_ANY` enum rs2_format
`static int`	`RS2_FORMAT_BGR8` enum rs2_format
`static int`	`RS2_FORMAT_BGRA8` enum rs2_format
`static int`	`RS2_FORMAT_COUNT` enum rs2_format
`static int`	`RS2_FORMAT_DISPARITY16` enum rs2_format
`static int`	`RS2_FORMAT_DISPARITY32` enum rs2_format
`static int`	`RS2_FORMAT_DISTANCE` enum rs2_format
`static int`	`RS2_FORMAT_FG` enum rs2_format
`static int`	`RS2_FORMAT_GPIO_RAW` enum rs2_format
`static int`	`RS2_FORMAT_INVI` enum rs2_format
`static int`	`RS2_FORMAT_INZI` enum rs2_format
`static int`	`RS2_FORMAT_MJPEG` enum rs2_format
`static int`	`RS2_FORMAT_MOTION_RAW` enum rs2_format
`static int`	`RS2_FORMAT_MOTION_XYZ32F` enum rs2_format
`static int`	`RS2_FORMAT_RAW10` enum rs2_format
`static int`	`RS2_FORMAT_RAW16` enum rs2_format
`static int`	`RS2_FORMAT_RAW8` enum rs2_format
`static int`	`RS2_FORMAT_RGB8` enum rs2_format
`static int`	`RS2_FORMAT_RGBA8` enum rs2_format
`static int`	`RS2_FORMAT_UYVY` enum rs2_format
`static int`	`RS2_FORMAT_W10` enum rs2_format
`static int`	`RS2_FORMAT_XYZ32F` enum rs2_format
`static int`	`RS2_FORMAT_Y10BPACK` enum rs2_format
`static int`	`RS2_FORMAT_Y12I` enum rs2_format
`static int`	`RS2_FORMAT_Y16` enum rs2_format
`static int`	`RS2_FORMAT_Y16I` enum rs2_format
`static int`	`RS2_FORMAT_Y411` enum rs2_format
`static int`	`RS2_FORMAT_Y8` enum rs2_format
`static int`	`RS2_FORMAT_Y8I` enum rs2_format
`static int`	`RS2_FORMAT_YUYV` enum rs2_format
`static int`	`RS2_FORMAT_Z16` enum rs2_format
`static int`	`RS2_FORMAT_Z16H` enum rs2_format
`static int`	`RS2_FRAME_METADATA_ACTUAL_EXPOSURE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_ACTUAL_FPS` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_AUTO_EXPOSURE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_AUTO_WHITE_BALANCE_TEMPERATURE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_BACKEND_TIMESTAMP` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_BACKLIGHT_COMPENSATION` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_BRIGHTNESS` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_CALIB_INFO` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_CONTRAST` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_COUNT` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_CRC` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_EXPOSURE_PRIORITY` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_EXPOSURE_ROI_BOTTOM` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_EXPOSURE_ROI_LEFT` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_EXPOSURE_ROI_RIGHT` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_EXPOSURE_ROI_TOP` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_FRAME_COUNTER` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_FRAME_EMITTER_MODE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_FRAME_LASER_POWER` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_FRAME_LASER_POWER_MODE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_FRAME_LED_POWER` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_FRAME_TIMESTAMP` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_GAIN_LEVEL` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_GAMMA` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_GPIO_INPUT_DATA` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_HUE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_INPUT_HEIGHT` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_INPUT_WIDTH` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_LOW_LIGHT_COMPENSATION` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_MANUAL_WHITE_BALANCE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_POWER_LINE_FREQUENCY` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_PRESET` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_RAW_FRAME_SIZE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_SATURATION` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_SENSOR_TIMESTAMP` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_SEQUENCE_ID` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_SEQUENCE_NAME` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_SEQUENCE_SIZE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_SHARPNESS` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_SUB_PRESET_INFO` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_TEMPERATURE` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_TIME_OF_ARRIVAL` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_TRIGGER` enum rs2_frame_metadata_value
`static int`	`RS2_FRAME_METADATA_WHITE_BALANCE` enum rs2_frame_metadata_value
`static int`	`RS2_HOST_PERF_COUNT` enum rs2_host_perf_mode
`static int`	`RS2_HOST_PERF_DEFAULT` enum rs2_host_perf_mode
`static int`	`RS2_HOST_PERF_HIGH` enum rs2_host_perf_mode
`static int`	`RS2_HOST_PERF_LOW` enum rs2_host_perf_mode
`static int`	`RS2_L500_VISUAL_PRESET_AUTOMATIC` enum rs2_l500_visual_preset
`static int`	`RS2_L500_VISUAL_PRESET_COUNT` enum rs2_l500_visual_preset
`static int`	`RS2_L500_VISUAL_PRESET_CUSTOM` enum rs2_l500_visual_preset
`static int`	`RS2_L500_VISUAL_PRESET_DEFAULT` enum rs2_l500_visual_preset
`static int`	`RS2_L500_VISUAL_PRESET_LOW_AMBIENT` enum rs2_l500_visual_preset
`static int`	`RS2_L500_VISUAL_PRESET_MAX_RANGE` enum rs2_l500_visual_preset
`static int`	`RS2_L500_VISUAL_PRESET_NO_AMBIENT` enum rs2_l500_visual_preset
`static int`	`RS2_L500_VISUAL_PRESET_SHORT_RANGE` enum rs2_l500_visual_preset
`static int`	`RS2_LOG_SEVERITY_ALL` enum rs2_log_severity
`static int`	`RS2_LOG_SEVERITY_COUNT` enum rs2_log_severity
`static int`	`RS2_LOG_SEVERITY_DEBUG` enum rs2_log_severity
`static int`	`RS2_LOG_SEVERITY_ERROR` enum rs2_log_severity
`static int`	`RS2_LOG_SEVERITY_FATAL` enum rs2_log_severity
`static int`	`RS2_LOG_SEVERITY_INFO` enum rs2_log_severity
`static int`	`RS2_LOG_SEVERITY_NONE` enum rs2_log_severity
`static int`	`RS2_LOG_SEVERITY_WARN` enum rs2_log_severity
`static int`	`RS2_MATCHER_COUNT` enum rs2_matchers
`static int`	`RS2_MATCHER_DEFAULT` enum rs2_matchers
`static int`	`RS2_MATCHER_DI` enum rs2_matchers
`static int`	`RS2_MATCHER_DI_C` enum rs2_matchers
`static int`	`RS2_MATCHER_DIC` enum rs2_matchers
`static int`	`RS2_MATCHER_DIC_C` enum rs2_matchers
`static int`	`RS2_MATCHER_DLR` enum rs2_matchers
`static int`	`RS2_MATCHER_DLR_C` enum rs2_matchers
`static int`	`RS2_NOTIFICATION_CATEGORY_COUNT` enum rs2_notification_category
`static int`	`RS2_NOTIFICATION_CATEGORY_FIRMWARE_UPDATE_RECOMMENDED` enum rs2_notification_category
`static int`	`RS2_NOTIFICATION_CATEGORY_FRAME_CORRUPTED` enum rs2_notification_category
`static int`	`RS2_NOTIFICATION_CATEGORY_FRAMES_TIMEOUT` enum rs2_notification_category
`static int`	`RS2_NOTIFICATION_CATEGORY_HARDWARE_ERROR` enum rs2_notification_category
`static int`	`RS2_NOTIFICATION_CATEGORY_HARDWARE_EVENT` enum rs2_notification_category
`static int`	`RS2_NOTIFICATION_CATEGORY_POSE_RELOCALIZATION` enum rs2_notification_category
`static int`	`RS2_NOTIFICATION_CATEGORY_UNKNOWN_ERROR` enum rs2_notification_category
`static int`	`RS2_OPTION_ACCURACY` enum rs2_option
`static int`	`RS2_OPTION_ALTERNATE_IR` enum rs2_option
`static int`	`RS2_OPTION_AMBIENT_LIGHT` enum rs2_option
`static int`	`RS2_OPTION_APD_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_ASIC_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_AUTO_EXPOSURE_CONVERGE_STEP` enum rs2_option
`static int`	`RS2_OPTION_AUTO_EXPOSURE_LIMIT` enum rs2_option
`static int`	`RS2_OPTION_AUTO_EXPOSURE_LIMIT_TOGGLE` enum rs2_option
`static int`	`RS2_OPTION_AUTO_EXPOSURE_MODE` enum rs2_option
`static int`	`RS2_OPTION_AUTO_EXPOSURE_PRIORITY` enum rs2_option
`static int`	`RS2_OPTION_AUTO_GAIN_LIMIT` enum rs2_option
`static int`	`RS2_OPTION_AUTO_GAIN_LIMIT_TOGGLE` enum rs2_option
`static int`	`RS2_OPTION_AUTO_RX_SENSITIVITY` enum rs2_option
`static int`	`RS2_OPTION_AVALANCHE_PHOTO_DIODE` enum rs2_option
`static int`	`RS2_OPTION_BACKLIGHT_COMPENSATION` enum rs2_option
`static int`	`RS2_OPTION_BRIGHTNESS` enum rs2_option
`static int`	`RS2_OPTION_COLOR_SCHEME` enum rs2_option
`static int`	`RS2_OPTION_CONFIDENCE_THRESHOLD` enum rs2_option
`static int`	`RS2_OPTION_CONTRAST` enum rs2_option
`static int`	`RS2_OPTION_COUNT` enum rs2_option
`static int`	`RS2_OPTION_DEPTH_OFFSET` enum rs2_option
`static int`	`RS2_OPTION_DEPTH_UNITS` enum rs2_option
`static int`	`RS2_OPTION_DIGITAL_GAIN` enum rs2_option
`static int`	`RS2_OPTION_EMITTER_ALWAYS_ON` enum rs2_option
`static int`	`RS2_OPTION_EMITTER_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_EMITTER_FREQUENCY` enum rs2_option
`static int`	`RS2_OPTION_EMITTER_ON_OFF` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_AUTO_EXPOSURE` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_AUTO_WHITE_BALANCE` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_DYNAMIC_CALIBRATION` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_IR_REFLECTIVITY` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_MAP_PRESERVATION` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_MAPPING` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_MAX_USABLE_RANGE` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_MOTION_CORRECTION` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_POSE_JUMPING` enum rs2_option
`static int`	`RS2_OPTION_ENABLE_RELOCALIZATION` enum rs2_option
`static int`	`RS2_OPTION_ERROR_POLLING_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_EXPOSURE` enum rs2_option
`static int`	`RS2_OPTION_FILTER_MAGNITUDE` enum rs2_option
`static int`	`RS2_OPTION_FILTER_OPTION` enum rs2_option
`static int`	`RS2_OPTION_FILTER_SMOOTH_ALPHA` enum rs2_option
`static int`	`RS2_OPTION_FILTER_SMOOTH_DELTA` enum rs2_option
`static int`	`RS2_OPTION_FRAMES_QUEUE_SIZE` enum rs2_option
`static int`	`RS2_OPTION_FREEFALL_DETECTION_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_GAIN` enum rs2_option
`static int`	`RS2_OPTION_GAMMA` enum rs2_option
`static int`	`RS2_OPTION_GLOBAL_TIME_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_HARDWARE_PRESET` enum rs2_option
`static int`	`RS2_OPTION_HDR_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_HISTOGRAM_EQUALIZATION_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_HOLES_FILL` enum rs2_option
`static int`	`RS2_OPTION_HOST_PERFORMANCE` enum rs2_option
`static int`	`RS2_OPTION_HUE` enum rs2_option
`static int`	`RS2_OPTION_HUMIDITY_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_INTER_CAM_SYNC_MODE` enum rs2_option
`static int`	`RS2_OPTION_INVALIDATION_BYPASS` enum rs2_option
`static int`	`RS2_OPTION_LASER_POWER` enum rs2_option
`static int`	`RS2_OPTION_LED_POWER` enum rs2_option
`static int`	`RS2_OPTION_LLD_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_MA_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_MAX_DISTANCE` enum rs2_option
`static int`	`RS2_OPTION_MC_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_MIN_DISTANCE` enum rs2_option
`static int`	`RS2_OPTION_MOTION_MODULE_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_MOTION_RANGE` enum rs2_option
`static int`	`RS2_OPTION_NOISE_ESTIMATION` enum rs2_option
`static int`	`RS2_OPTION_NOISE_FILTERING` enum rs2_option
`static int`	`RS2_OPTION_OUTPUT_TRIGGER_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_POST_PROCESSING_SHARPENING` enum rs2_option
`static int`	`RS2_OPTION_POWER_LINE_FREQUENCY` enum rs2_option
`static int`	`RS2_OPTION_PRE_PROCESSING_SHARPENING` enum rs2_option
`static int`	`RS2_OPTION_PROJECTOR_TEMPERATURE` enum rs2_option
`static int`	`RS2_OPTION_RECEIVER_SENSITIVITY` enum rs2_option
`static int`	`RS2_OPTION_RESET_CAMERA_ACCURACY_HEALTH` enum rs2_option
`static int`	`RS2_OPTION_SATURATION` enum rs2_option
`static int`	`RS2_OPTION_SENSOR_MODE` enum rs2_option
`static int`	`RS2_OPTION_SEQUENCE_ID` enum rs2_option
`static int`	`RS2_OPTION_SEQUENCE_NAME` enum rs2_option
`static int`	`RS2_OPTION_SEQUENCE_SIZE` enum rs2_option
`static int`	`RS2_OPTION_SHARPNESS` enum rs2_option
`static int`	`RS2_OPTION_STEREO_BASELINE` enum rs2_option
`static int`	`RS2_OPTION_STREAM_FILTER` enum rs2_option
`static int`	`RS2_OPTION_STREAM_FORMAT_FILTER` enum rs2_option
`static int`	`RS2_OPTION_STREAM_INDEX_FILTER` enum rs2_option
`static int`	`RS2_OPTION_TEXTURE_SOURCE` enum rs2_option
`static int`	`RS2_OPTION_THERMAL_COMPENSATION` enum rs2_option
`static int`	`RS2_OPTION_TOTAL_FRAME_DROPS` enum rs2_option
`static int`	`RS2_OPTION_TRANSMITTER_FREQUENCY` enum rs2_option
`static int`	`RS2_OPTION_TRIGGER_CAMERA_ACCURACY_HEALTH` enum rs2_option
`static int`	`RS2_OPTION_VERTICAL_BINNING` enum rs2_option
`static int`	`RS2_OPTION_VISUAL_PRESET` enum rs2_option
`static int`	`RS2_OPTION_WHITE_BALANCE` enum rs2_option
`static int`	`RS2_OPTION_ZERO_ORDER_ENABLED` enum rs2_option
`static int`	`RS2_OPTION_ZERO_ORDER_POINT_X` enum rs2_option
`static int`	`RS2_OPTION_ZERO_ORDER_POINT_Y` enum rs2_option
`static int`	`RS2_PLAYBACK_STATUS_COUNT` enum rs2_playback_status
`static int`	`RS2_PLAYBACK_STATUS_PAUSED` enum rs2_playback_status
`static int`	`RS2_PLAYBACK_STATUS_PLAYING` enum rs2_playback_status
`static int`	`RS2_PLAYBACK_STATUS_STOPPED` enum rs2_playback_status
`static int`	`RS2_PLAYBACK_STATUS_UNKNOWN` enum rs2_playback_status
`static int`	`RS2_PRODUCT_LINE_ANY`
`static int`	`RS2_PRODUCT_LINE_ANY_INTEL`
`static int`	`RS2_PRODUCT_LINE_D400`
`static int`	`RS2_PRODUCT_LINE_DEPTH`
`static int`	`RS2_PRODUCT_LINE_L500`
`static int`	`RS2_PRODUCT_LINE_NON_INTEL`
`static int`	`RS2_PRODUCT_LINE_SR300`
`static int`	`RS2_PRODUCT_LINE_T200`
`static int`	`RS2_PRODUCT_LINE_TRACKING`
`static int`	`RS2_RS400_VISUAL_PRESET_COUNT` enum rs2_rs400_visual_preset
`static int`	`RS2_RS400_VISUAL_PRESET_CUSTOM` enum rs2_rs400_visual_preset
`static int`	`RS2_RS400_VISUAL_PRESET_DEFAULT` enum rs2_rs400_visual_preset
`static int`	`RS2_RS400_VISUAL_PRESET_HAND` enum rs2_rs400_visual_preset
`static int`	`RS2_RS400_VISUAL_PRESET_HIGH_ACCURACY` enum rs2_rs400_visual_preset
`static int`	`RS2_RS400_VISUAL_PRESET_HIGH_DENSITY` enum rs2_rs400_visual_preset
`static int`	`RS2_RS400_VISUAL_PRESET_MEDIUM_DENSITY` enum rs2_rs400_visual_preset
`static int`	`RS2_RS400_VISUAL_PRESET_REMOVE_IR_PATTERN` enum rs2_rs400_visual_preset
`static int`	`RS2_SENSOR_MODE_COUNT` enum rs2_sensor_mode
`static int`	`RS2_SENSOR_MODE_QVGA` enum rs2_sensor_mode
`static int`	`RS2_SENSOR_MODE_VGA` enum rs2_sensor_mode
`static int`	`RS2_SENSOR_MODE_XGA` enum rs2_sensor_mode
`static int`	`RS2_SR300_VISUAL_PRESET_BACKGROUND_SEGMENTATION` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_COUNT` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_DEFAULT` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_FACE_ANALYTICS` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_FACE_LOGIN` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_GESTURE_RECOGNITION` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_GR_CURSOR` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_IR_ONLY` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_LONG_RANGE` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_MID_RANGE` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_OBJECT_SCANNING` enum rs2_sr300_visual_preset
`static int`	`RS2_SR300_VISUAL_PRESET_SHORT_RANGE` enum rs2_sr300_visual_preset
`static int`	`RS2_STREAM_ACCEL` enum rs2_stream
`static int`	`RS2_STREAM_ANY` enum rs2_stream
`static int`	`RS2_STREAM_COLOR` enum rs2_stream
`static int`	`RS2_STREAM_CONFIDENCE` enum rs2_stream
`static int`	`RS2_STREAM_COUNT` enum rs2_stream
`static int`	`RS2_STREAM_DEPTH` enum rs2_stream
`static int`	`RS2_STREAM_FISHEYE` enum rs2_stream
`static int`	`RS2_STREAM_GPIO` enum rs2_stream
`static int`	`RS2_STREAM_GYRO` enum rs2_stream
`static int`	`RS2_STREAM_INFRARED` enum rs2_stream
`static int`	`RS2_STREAM_POSE` enum rs2_stream
`static int`	`RS2_TIMESTAMP_DOMAIN_COUNT` enum rs2_timestamp_domain
`static int`	`RS2_TIMESTAMP_DOMAIN_GLOBAL_TIME` enum rs2_timestamp_domain
`static int`	`RS2_TIMESTAMP_DOMAIN_HARDWARE_CLOCK` enum rs2_timestamp_domain
`static int`	`RS2_TIMESTAMP_DOMAIN_SYSTEM_TIME` enum rs2_timestamp_domain
`static int`	`RS2_UNSIGNED_UPDATE_MODE_FULL`
`static int`	`RS2_UNSIGNED_UPDATE_MODE_READ_ONLY`
`static int`	`RS2_UNSIGNED_UPDATE_MODE_UPDATE`

Constructor Summary

Constructors
Constructor and Description

realsense2()

Constructors
Constructor and Description
`realsense2()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static rs2_frame`	`rs2_allocate_composite_frame(rs2_source source, PointerPointer frames, int count, PointerPointer error)` Allocate new composite frame, aggregating a set of existing frames
`static rs2_frame`	`rs2_allocate_composite_frame(rs2_source source, rs2_frame frames, int count, rs2_error error)`
`static rs2_frame`	`rs2_allocate_points(rs2_source source, rs2_stream_profile new_stream, rs2_frame original, PointerPointer error)` Allocate new points frame using a frame-source provided from a processing block
`static rs2_frame`	`rs2_allocate_points(rs2_source source, rs2_stream_profile new_stream, rs2_frame original, rs2_error error)`
`static rs2_frame`	`rs2_allocate_synthetic_motion_frame(rs2_source source, rs2_stream_profile new_stream, rs2_frame original, int frame_type, PointerPointer error)` Allocate new motion frame using a frame-source provided form a processing block
`static rs2_frame`	`rs2_allocate_synthetic_motion_frame(rs2_source source, rs2_stream_profile new_stream, rs2_frame original, int frame_type, rs2_error error)`
`static rs2_frame`	`rs2_allocate_synthetic_video_frame(rs2_source source, rs2_stream_profile new_stream, rs2_frame original, int new_bpp, int new_width, int new_height, int new_stride, int frame_type, PointerPointer error)` Allocate new video frame using a frame-source provided form a processing block
`static rs2_frame`	`rs2_allocate_synthetic_video_frame(rs2_source source, rs2_stream_profile new_stream, rs2_frame original, int new_bpp, int new_width, int new_height, int new_stride, int frame_type, rs2_error error)`
`static String`	`RS2_API_FULL_VERSION_STR()`
`static String`	`RS2_API_VERSION_STR()`
`static rs2_raw_data_buffer`	`rs2_build_debug_protocol_command(rs2_device device, int opcode, int param1, int param2, int param3, int param4, Pointer data, int size_of_data, PointerPointer error)` Build debug_protocol raw data command from opcode, parameters and data.
`static rs2_raw_data_buffer`	`rs2_build_debug_protocol_command(rs2_device device, int opcode, int param1, int param2, int param3, int param4, Pointer data, int size_of_data, rs2_error error)`
`static float`	`rs2_calculate_target_z_cpp(rs2_device device, rs2_frame_queue queue1, rs2_frame_queue queue2, rs2_frame_queue queue3, float target_width, float target_height, rs2_update_progress_callback callback, PointerPointer error)` Calculate Z for calibration target - distance to the target's plane
`static float`	`rs2_calculate_target_z_cpp(rs2_device device, rs2_frame_queue queue1, rs2_frame_queue queue2, rs2_frame_queue queue3, float target_width, float target_height, rs2_update_progress_callback callback, rs2_error error)`
`static float`	`rs2_calculate_target_z(rs2_device device, rs2_frame_queue queue1, rs2_frame_queue queue2, rs2_frame_queue queue3, float target_width, float target_height, rs2_update_progress_callback_ptr progress_callback, Pointer client_data, PointerPointer error)` Calculate Z for calibration target - distance to the target's plane
`static float`	`rs2_calculate_target_z(rs2_device device, rs2_frame_queue queue1, rs2_frame_queue queue2, rs2_frame_queue queue3, float target_width, float target_height, rs2_update_progress_callback_ptr progress_callback, Pointer client_data, rs2_error error)`
`static BytePointer`	`rs2_calib_target_type_to_string(int type)`
`static BytePointer`	`rs2_calibration_status_to_string(int arg0)`
`static BytePointer`	`rs2_calibration_type_to_string(int arg0)`
`static BytePointer`	`rs2_camera_info_to_string(int info)`
`static int`	`rs2_check_firmware_compatibility(rs2_device device, Pointer fw_image, int fw_image_size, PointerPointer error)` Checks if the device and the provided firmware image are compatible
`static int`	`rs2_check_firmware_compatibility(rs2_device device, Pointer fw_image, int fw_image_size, rs2_error error)`
`static rs2_stream_profile`	`rs2_clone_stream_profile(rs2_stream_profile mode, int stream, int index, int format, PointerPointer error)` Creates a copy of stream profile, assigning new values to some of the fields
`static rs2_stream_profile`	`rs2_clone_stream_profile(rs2_stream_profile mode, int stream, int index, int format, rs2_error error)`
`static rs2_stream_profile`	`rs2_clone_video_stream_profile(rs2_stream_profile mode, int stream, int index, int format, int width, int height, rs2_intrinsics intr, PointerPointer error)` Creates a copy of stream profile, assigning new values to some of the fields
`static rs2_stream_profile`	`rs2_clone_video_stream_profile(rs2_stream_profile mode, int stream, int index, int format, int width, int height, rs2_intrinsics intr, rs2_error error)`
`static void`	`rs2_close(rs2_sensor sensor, PointerPointer error)` stop any streaming from specified subdevice
`static void`	`rs2_close(rs2_sensor sensor, rs2_error error)`
`static int`	`rs2_config_can_resolve(rs2_config config, rs2_pipeline pipe, PointerPointer error)` Check if the config can resolve the configuration filters, to find a matching device and streams profiles.
`static int`	`rs2_config_can_resolve(rs2_config config, rs2_pipeline pipe, rs2_error error)`
`static void`	`rs2_config_disable_all_streams(rs2_config config, PointerPointer error)` Disable all device stream explicitly, to remove any requests on the streams profiles.
`static void`	`rs2_config_disable_all_streams(rs2_config config, rs2_error error)`
`static void`	`rs2_config_disable_indexed_stream(rs2_config config, int stream, int index, PointerPointer error)` Disable a device stream explicitly, to remove any requests on this stream profile.
`static void`	`rs2_config_disable_indexed_stream(rs2_config config, int stream, int index, rs2_error error)`
`static void`	`rs2_config_disable_stream(rs2_config config, int stream, PointerPointer error)` Disable a device stream explicitly, to remove any requests on this stream type.
`static void`	`rs2_config_disable_stream(rs2_config config, int stream, rs2_error error)`
`static void`	`rs2_config_enable_all_stream(rs2_config config, PointerPointer error)` Enable all device streams explicitly.
`static void`	`rs2_config_enable_all_stream(rs2_config config, rs2_error error)`
`static void`	`rs2_config_enable_device_from_file_repeat_option(rs2_config config, BytePointer file, int repeat_playback, PointerPointer error)` Select a recorded device from a file, to be used by the pipeline through playback.
`static void`	`rs2_config_enable_device_from_file_repeat_option(rs2_config config, BytePointer file, int repeat_playback, rs2_error error)`
`static void`	`rs2_config_enable_device_from_file_repeat_option(rs2_config config, String file, int repeat_playback, rs2_error error)`
`static void`	`rs2_config_enable_device_from_file(rs2_config config, BytePointer file, PointerPointer error)` Select a recorded device from a file, to be used by the pipeline through playback.
`static void`	`rs2_config_enable_device_from_file(rs2_config config, BytePointer file, rs2_error error)`
`static void`	`rs2_config_enable_device_from_file(rs2_config config, String file, rs2_error error)`
`static void`	`rs2_config_enable_device(rs2_config config, BytePointer serial, PointerPointer error)` Select a specific device explicitly by its serial number, to be used by the pipeline.
`static void`	`rs2_config_enable_device(rs2_config config, BytePointer serial, rs2_error error)`
`static void`	`rs2_config_enable_device(rs2_config config, String serial, rs2_error error)`
`static void`	`rs2_config_enable_record_to_file(rs2_config config, BytePointer file, PointerPointer error)` Requires that the resolved device would be recorded to file This request cannot be used if enable_device_from_file() is called for the current config, and vise versa
`static void`	`rs2_config_enable_record_to_file(rs2_config config, BytePointer file, rs2_error error)`
`static void`	`rs2_config_enable_record_to_file(rs2_config config, String file, rs2_error error)`
`static void`	`rs2_config_enable_stream(rs2_config config, int stream, int index, int width, int height, int format, int framerate, PointerPointer error)` Enable a device stream explicitly, with selected stream parameters.
`static void`	`rs2_config_enable_stream(rs2_config config, int stream, int index, int width, int height, int format, int framerate, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_config_resolve(rs2_config config, rs2_pipeline pipe, PointerPointer error)` Resolve the configuration filters, to find a matching device and streams profiles.
`static rs2_pipeline_profile`	`rs2_config_resolve(rs2_config config, rs2_pipeline pipe, rs2_error error)`
`static void`	`rs2_connect_tm2_controller(rs2_device device, byte[] mac_addr, rs2_error error)`
`static void`	`rs2_connect_tm2_controller(rs2_device device, ByteBuffer mac_addr, rs2_error error)`
`static void`	`rs2_connect_tm2_controller(rs2_device device, BytePointer mac_addr, PointerPointer error)` Connects to a given tm2 controller
`static void`	`rs2_connect_tm2_controller(rs2_device device, BytePointer mac_addr, rs2_error error)`
`static rs2_device`	`rs2_context_add_device(rs2_context ctx, BytePointer file, PointerPointer error)` Create a new device and add it to the context
`static rs2_device`	`rs2_context_add_device(rs2_context ctx, BytePointer file, rs2_error error)`
`static rs2_device`	`rs2_context_add_device(rs2_context ctx, String file, rs2_error error)`
`static void`	`rs2_context_add_software_device(rs2_context ctx, rs2_device dev, PointerPointer error)` Add an instance of software device to the context
`static void`	`rs2_context_add_software_device(rs2_context ctx, rs2_device dev, rs2_error error)`
`static void`	`rs2_context_remove_device(rs2_context ctx, BytePointer file, PointerPointer error)` Removes a playback device from the context, if exists
`static void`	`rs2_context_remove_device(rs2_context ctx, BytePointer file, rs2_error error)`
`static void`	`rs2_context_remove_device(rs2_context ctx, String file, rs2_error error)`
`static void`	`rs2_context_unload_tracking_module(rs2_context ctx, PointerPointer error)` Removes tracking module.
`static void`	`rs2_context_unload_tracking_module(rs2_context ctx, rs2_error error)`
`static rs2_processing_block`	`rs2_create_align(int align_to, PointerPointer error)` Creates Align processing block.
`static rs2_processing_block`	`rs2_create_align(int align_to, rs2_error error)`
`static rs2_processing_block`	`rs2_create_colorizer(PointerPointer error)` Creates Depth-Colorizer processing block that can be used to quickly visualize the depth data This block will accept depth frames as input and replace them by depth frames with format RGB8 Non-depth frames are passed through Further customization will be added soon (format, color-map, histogram equalization control)
`static rs2_processing_block`	`rs2_create_colorizer(rs2_error error)`
`static rs2_config`	`rs2_create_config(PointerPointer error)` Create a config instance The config allows pipeline users to request filters for the pipeline streams and device selection and configuration.
`static rs2_config`	`rs2_create_config(rs2_error error)`
`static rs2_context`	`rs2_create_context(int api_version, PointerPointer error)` \brief Creates RealSense context that is required for the rest of the API.
`static rs2_context`	`rs2_create_context(int api_version, rs2_error error)`
`static rs2_processing_block`	`rs2_create_decimation_filter_block(PointerPointer error)` Creates Depth post-processing filter block.
`static rs2_processing_block`	`rs2_create_decimation_filter_block(rs2_error error)`
`static rs2_device`	`rs2_create_device_from_sensor(rs2_sensor sensor, PointerPointer error)` This is a helper function allowing the user to discover the device from one of its sensors
`static rs2_device`	`rs2_create_device_from_sensor(rs2_sensor sensor, rs2_error error)`
`static rs2_device_hub`	`rs2_create_device_hub(rs2_context context, PointerPointer error)` \brief Creates RealSense device_hub .
`static rs2_device_hub`	`rs2_create_device_hub(rs2_context context, rs2_error error)`
`static rs2_device`	`rs2_create_device(rs2_device_list info_list, int index, PointerPointer error)` Creates a device by index.
`static rs2_device`	`rs2_create_device(rs2_device_list info_list, int index, rs2_error error)`
`static rs2_processing_block`	`rs2_create_disparity_transform_block(byte transform_to_disparity, PointerPointer error)` Creates a post processing block that provides for depth<->disparity domain transformation for stereo-based depth modules
`static rs2_processing_block`	`rs2_create_disparity_transform_block(byte transform_to_disparity, rs2_error error)`
`static rs2_error`	`rs2_create_error(BytePointer what, BytePointer name, BytePointer args, int type)` Metadata attribute type is defined as 64 bit signed integer
`static rs2_error`	`rs2_create_error(String what, String name, String args, int type)`
`static rs2_raw_data_buffer`	`rs2_create_flash_backup_cpp(rs2_device device, rs2_update_progress_callback callback, PointerPointer error)` Create backup of camera flash memory.
`static rs2_raw_data_buffer`	`rs2_create_flash_backup_cpp(rs2_device device, rs2_update_progress_callback callback, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_create_flash_backup(rs2_device device, rs2_update_progress_callback_ptr callback, Pointer client_data, PointerPointer error)` Create backup of camera flash memory.
`static rs2_raw_data_buffer`	`rs2_create_flash_backup(rs2_device device, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_frame_queue`	`rs2_create_frame_queue(int _capacity, PointerPointer error)` create frame queue.
`static rs2_frame_queue`	`rs2_create_frame_queue(int _capacity, rs2_error error)`
`static rs2_processing_block`	`rs2_create_hdr_merge_processing_block(PointerPointer error)` Creates a hdr_merge processing block.
`static rs2_processing_block`	`rs2_create_hdr_merge_processing_block(rs2_error error)`
`static rs2_processing_block`	`rs2_create_hole_filling_filter_block(PointerPointer error)` Creates Depth post-processing hole filling block.
`static rs2_processing_block`	`rs2_create_hole_filling_filter_block(rs2_error error)`
`static rs2_processing_block`	`rs2_create_huffman_depth_decompress_block(PointerPointer error)` Creates Depth frame decompression module.
`static rs2_processing_block`	`rs2_create_huffman_depth_decompress_block(rs2_error error)`
`static rs2_pipeline`	`rs2_create_pipeline(rs2_context ctx, PointerPointer error)` Create a pipeline instance The pipeline simplifies the user interaction with the device and computer vision processing modules.
`static rs2_pipeline`	`rs2_create_pipeline(rs2_context ctx, rs2_error error)`
`static rs2_processing_block`	`rs2_create_pointcloud(PointerPointer error)` Creates Point-Cloud processing block.
`static rs2_processing_block`	`rs2_create_pointcloud(rs2_error error)`
`static rs2_processing_block`	`rs2_create_processing_block_fptr(rs2_frame_processor_callback_ptr proc, Pointer context, PointerPointer error)` This method creates new custom processing block from function pointer.
`static rs2_processing_block`	`rs2_create_processing_block_fptr(rs2_frame_processor_callback_ptr proc, Pointer context, rs2_error error)`
`static rs2_processing_block`	`rs2_create_processing_block(rs2_frame_processor_callback proc, PointerPointer error)` This method creates new custom processing block.
`static rs2_processing_block`	`rs2_create_processing_block(rs2_frame_processor_callback proc, rs2_error error)`
`static rs2_processing_block`	`rs2_create_rates_printer_block(PointerPointer error)` Creates a rates printer block.
`static rs2_processing_block`	`rs2_create_rates_printer_block(rs2_error error)`
`static rs2_device`	`rs2_create_record_device_ex(rs2_device device, BytePointer file, int compression_enabled, PointerPointer error)` Creates a recording device to record the given device and save it to the given file
`static rs2_device`	`rs2_create_record_device_ex(rs2_device device, BytePointer file, int compression_enabled, rs2_error error)`
`static rs2_device`	`rs2_create_record_device_ex(rs2_device device, String file, int compression_enabled, rs2_error error)`
`static rs2_device`	`rs2_create_record_device(rs2_device device, BytePointer file, PointerPointer error)` Creates a recording device to record the given device and save it to the given file
`static rs2_device`	`rs2_create_record_device(rs2_device device, BytePointer file, rs2_error error)`
`static rs2_device`	`rs2_create_record_device(rs2_device device, String file, rs2_error error)`
`static rs2_sensor`	`rs2_create_sensor(rs2_sensor_list list, int index, PointerPointer error)` create sensor by index
`static rs2_sensor`	`rs2_create_sensor(rs2_sensor_list list, int index, rs2_error error)`
`static rs2_processing_block`	`rs2_create_sequence_id_filter(PointerPointer error)` Creates a sequence_id_filter processing block.
`static rs2_processing_block`	`rs2_create_sequence_id_filter(rs2_error error)`
`static rs2_processing_block`	`rs2_create_spatial_filter_block(PointerPointer error)` Creates Depth post-processing spatial filter block.
`static rs2_processing_block`	`rs2_create_spatial_filter_block(rs2_error error)`
`static rs2_processing_block`	`rs2_create_sync_processing_block(PointerPointer error)` Creates Sync processing block.
`static rs2_processing_block`	`rs2_create_sync_processing_block(rs2_error error)`
`static rs2_processing_block`	`rs2_create_temporal_filter_block(PointerPointer error)` Creates Depth post-processing filter block.
`static rs2_processing_block`	`rs2_create_temporal_filter_block(rs2_error error)`
`static rs2_processing_block`	`rs2_create_threshold(PointerPointer error)` Creates depth thresholding processing block By controlling min and max options on the block, one could filter out depth values that are either too large or too small, as a software post-processing step
`static rs2_processing_block`	`rs2_create_threshold(rs2_error error)`
`static rs2_processing_block`	`rs2_create_units_transform(PointerPointer error)` Creates depth units transformation processing block All of the pixels are transformed from depth units into meters.
`static rs2_processing_block`	`rs2_create_units_transform(rs2_error error)`
`static rs2_processing_block`	`rs2_create_yuy_decoder(PointerPointer error)` Creates YUY decoder processing block.
`static rs2_processing_block`	`rs2_create_yuy_decoder(rs2_error error)`
`static rs2_processing_block`	`rs2_create_zero_order_invalidation_block(PointerPointer error)` Creates Depth post-processing zero order fix block.
`static rs2_processing_block`	`rs2_create_zero_order_invalidation_block(rs2_error error)`
`static void`	`rs2_delete_config(rs2_config config)` Deletes an instance of a config
`static void`	`rs2_delete_context(rs2_context context)` \brief Frees the relevant context object.
`static void`	`rs2_delete_device_hub(rs2_device_hub hub)` \brief Frees the relevant device hub object.
`static void`	`rs2_delete_device_list(rs2_device_list info_list)` Deletes device list, any devices created using this list will remain unaffected.
`static void`	`rs2_delete_device(rs2_device device)` Delete RealSense device
`static void`	`rs2_delete_frame_queue(rs2_frame_queue queue)` deletes frame queue and releases all frames inside it
`static void`	`rs2_delete_options_list(rs2_options_list list)` Deletes options list
`static void`	`rs2_delete_pipeline_profile(rs2_pipeline_profile profile)` Deletes an instance of a pipeline profile
`static void`	`rs2_delete_pipeline(rs2_pipeline pipe)` Delete a pipeline instance.
`static void`	`rs2_delete_processing_block(rs2_processing_block block)` Deletes the processing block
`static void`	`rs2_delete_raw_data(rs2_raw_data_buffer buffer)` Delete rs2_raw_data_buffer
`static void`	`rs2_delete_recommended_processing_blocks(rs2_processing_block_list list)` Deletes processing blocks list
`static void`	`rs2_delete_sensor_list(rs2_sensor_list info_list)` Deletes sensors list, any sensors created from this list will remain unaffected
`static void`	`rs2_delete_sensor(rs2_sensor sensor)` delete relasense sensor
`static void`	`rs2_delete_stream_profile(rs2_stream_profile mode)` Delete stream profile allocated by rs2_clone_stream_profile Should not be called on stream profiles returned by the device
`static void`	`rs2_delete_stream_profiles_list(rs2_stream_profile_list list)` delete stream profiles list
`static void`	`rs2_deproject_pixel_to_point(float[] point, rs2_intrinsics intrin, float[] pixel, float depth)`
`static void`	`rs2_deproject_pixel_to_point(FloatBuffer point, rs2_intrinsics intrin, FloatBuffer pixel, float depth)`
`static void`	`rs2_deproject_pixel_to_point(FloatPointer point, rs2_intrinsics intrin, FloatPointer pixel, float depth)`
`static float`	`rs2_depth_frame_get_distance(rs2_frame frame_ref, int x, int y, PointerPointer error)` Given the 2D depth coordinate (x,y) provide the corresponding depth in metric units
`static float`	`rs2_depth_frame_get_distance(rs2_frame frame_ref, int x, int y, rs2_error error)`
`static float`	`rs2_depth_frame_get_units(rs2_frame frame, PointerPointer error)` retrieve the scaling factor to use when converting a depth frame's get_data() units to meters
`static float`	`rs2_depth_frame_get_units(rs2_frame frame, rs2_error error)`
`static float`	`rs2_depth_stereo_frame_get_baseline(rs2_frame frame_ref, PointerPointer error)` Retrieve the stereoscopic baseline value from frame.
`static float`	`rs2_depth_stereo_frame_get_baseline(rs2_frame frame_ref, rs2_error error)`
`static int`	`rs2_device_hub_is_device_connected(rs2_device_hub hub, rs2_device device, PointerPointer error)` Checks if device is still connected
`static int`	`rs2_device_hub_is_device_connected(rs2_device_hub hub, rs2_device device, rs2_error error)`
`static rs2_device`	`rs2_device_hub_wait_for_device(rs2_device_hub hub, PointerPointer error)` If any device is connected return it, otherwise wait until next RealSense device connects.
`static rs2_device`	`rs2_device_hub_wait_for_device(rs2_device_hub hub, rs2_error error)`
`static int`	`rs2_device_list_contains(rs2_device_list info_list, rs2_device device, PointerPointer error)` Checks if a specific device is contained inside a device list.
`static int`	`rs2_device_list_contains(rs2_device_list info_list, rs2_device device, rs2_error error)`
`static void`	`rs2_disconnect_tm2_controller(rs2_device device, int id, PointerPointer error)` Disconnects a given tm2 controller
`static void`	`rs2_disconnect_tm2_controller(rs2_device device, int id, rs2_error error)`
`static BytePointer`	`rs2_distortion_to_string(int distortion)`
`static int`	`rs2_embedded_frames_count(rs2_frame composite, PointerPointer error)` Get number of frames embedded within a composite frame
`static int`	`rs2_embedded_frames_count(rs2_frame composite, rs2_error error)`
`static BytePointer`	`rs2_emitter_frequency_mode_to_string(int mode)`
`static void`	`rs2_enable_rolling_log_file(int max_size, PointerPointer error)` Enable rolling log file when used with rs2_log_to_file: Upon reaching (max_size/2) bytes, the log will be renamed with an ".old" suffix and a new log created.
`static void`	`rs2_enable_rolling_log_file(int max_size, rs2_error error)`
`static void`	`rs2_enqueue_frame(rs2_frame frame, Pointer queue)` enqueue new frame into a queue
`static void`	`rs2_enter_update_state(rs2_device device, PointerPointer error)` Enter the device to update state, this will cause the updatable device to disconnect and reconnect as update device.
`static void`	`rs2_enter_update_state(rs2_device device, rs2_error error)`
`static BytePointer`	`rs2_exception_type_to_string(int type)`
`static rs2_raw_data_buffer`	`rs2_export_localization_map(rs2_sensor sensor, PointerPointer error)` Extract and store the localization map of tm2 tracking device to file
`static rs2_raw_data_buffer`	`rs2_export_localization_map(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_export_to_ply(rs2_frame frame, BytePointer fname, rs2_frame texture, PointerPointer error)` When called on Points frame type, this method creates a ply file of the model with the given file name.
`static void`	`rs2_export_to_ply(rs2_frame frame, BytePointer fname, rs2_frame texture, rs2_error error)`
`static void`	`rs2_export_to_ply(rs2_frame frame, String fname, rs2_frame texture, rs2_error error)`
`static BytePointer`	`rs2_extension_to_string(int type)`
`static BytePointer`	`rs2_extension_type_to_string(int type)`
`static rs2_frame`	`rs2_extract_frame(rs2_frame composite, int index, PointerPointer error)` Extract frame from within a composite frame
`static rs2_frame`	`rs2_extract_frame(rs2_frame composite, int index, rs2_error error)`
`static void`	`rs2_extract_target_dimensions(rs2_frame frame, int calib_type, float[] target_dims, int target_dims_size, rs2_error error)`
`static void`	`rs2_extract_target_dimensions(rs2_frame frame, int calib_type, FloatBuffer target_dims, int target_dims_size, rs2_error error)`
`static void`	`rs2_extract_target_dimensions(rs2_frame frame, int calib_type, FloatPointer target_dims, int target_dims_size, PointerPointer error)` Extract the target dimensions on the specific target
`static void`	`rs2_extract_target_dimensions(rs2_frame frame, int calib_type, FloatPointer target_dims, int target_dims_size, rs2_error error)`
`static BytePointer`	`rs2_format_to_string(int format)`
`static void`	`rs2_fov(rs2_intrinsics intrin, float[] to_fov)`
`static void`	`rs2_fov(rs2_intrinsics intrin, FloatBuffer to_fov)`
`static void`	`rs2_fov(rs2_intrinsics intrin, FloatPointer to_fov)`
`static void`	`rs2_frame_add_ref(rs2_frame frame, PointerPointer error)` create additional reference to a frame without duplicating frame data
`static void`	`rs2_frame_add_ref(rs2_frame frame, rs2_error error)`
`static BytePointer`	`rs2_frame_metadata_to_string(int metadata)`
`static BytePointer`	`rs2_frame_metadata_value_to_string(int metadata)`
`static int`	`rs2_frame_queue_size(rs2_frame_queue queue, PointerPointer error)` queries the number of frames
`static int`	`rs2_frame_queue_size(rs2_frame_queue queue, rs2_error error)`
`static void`	`rs2_free_error(rs2_error error)`
`static rs2_stream_profile_list`	`rs2_get_active_streams(rs2_sensor sensor, PointerPointer error)` check how subdevice is streaming
`static rs2_stream_profile_list`	`rs2_get_active_streams(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_get_ae_control(rs2_device dev, STAEControl group, int mode, PointerPointer error)`
`static void`	`rs2_get_ae_control(rs2_device dev, STAEControl group, int mode, rs2_error error)`
`static void`	`rs2_get_amp_factor(rs2_device dev, STAFactor group, int mode, PointerPointer error)`
`static void`	`rs2_get_amp_factor(rs2_device dev, STAFactor group, int mode, rs2_error error)`
`static int`	`rs2_get_api_version(PointerPointer error)` Retrieve the API version from the source code.
`static int`	`rs2_get_api_version(rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_get_calibration_table(rs2_device dev, PointerPointer error)` Read current calibration table from flash.
`static rs2_raw_data_buffer`	`rs2_get_calibration_table(rs2_device dev, rs2_error error)`
`static void`	`rs2_get_census(rs2_device dev, STCensusRadius group, int mode, PointerPointer error)`
`static void`	`rs2_get_census(rs2_device dev, STCensusRadius group, int mode, rs2_error error)`
`static void`	`rs2_get_color_control(rs2_device dev, STColorControl group, int mode, PointerPointer error)`
`static void`	`rs2_get_color_control(rs2_device dev, STColorControl group, int mode, rs2_error error)`
`static void`	`rs2_get_color_correction(rs2_device dev, STColorCorrection group, int mode, PointerPointer error)`
`static void`	`rs2_get_color_correction(rs2_device dev, STColorCorrection group, int mode, rs2_error error)`
`static rs2_stream_profile_list`	`rs2_get_debug_stream_profiles(rs2_sensor sensor, PointerPointer error)` retrieve list of debug stream profiles that given subdevice can provide
`static rs2_stream_profile_list`	`rs2_get_debug_stream_profiles(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_get_depth_control(rs2_device dev, STDepthControlGroup group, int mode, PointerPointer error)`
`static void`	`rs2_get_depth_control(rs2_device dev, STDepthControlGroup group, int mode, rs2_error error)`
`static float`	`rs2_get_depth_scale(rs2_sensor sensor, PointerPointer error)` When called on a depth sensor, this method will return the number of meters represented by a single depth unit
`static float`	`rs2_get_depth_scale(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_get_depth_table(rs2_device dev, STDepthTableControl group, int mode, PointerPointer error)`
`static void`	`rs2_get_depth_table(rs2_device dev, STDepthTableControl group, int mode, rs2_error error)`
`static int`	`rs2_get_device_count(rs2_device_list info_list, PointerPointer error)` Determines number of devices in a list.
`static int`	`rs2_get_device_count(rs2_device_list info_list, rs2_error error)`
`static BytePointer`	`rs2_get_device_info(rs2_device device, int info, PointerPointer error)` Retrieve camera specific information, like versions of various internal components.
`static BytePointer`	`rs2_get_device_info(rs2_device device, int info, rs2_error error)`
`static void`	`rs2_get_dsm_params(rs2_sensor sensor, rs2_dsm_params p_params_out, PointerPointer error)` Get the DSM parameters for a sensor
`static void`	`rs2_get_dsm_params(rs2_sensor sensor, rs2_dsm_params p_params_out, rs2_error error)`
`static BytePointer`	`rs2_get_error_message(rs2_error error)`
`static void`	`rs2_get_extrinsics(rs2_stream_profile from, rs2_stream_profile to, rs2_extrinsics extrin, PointerPointer error)`
`static void`	`rs2_get_extrinsics(rs2_stream_profile from, rs2_stream_profile to, rs2_extrinsics extrin, rs2_error error)`
`static BytePointer`	`rs2_get_failed_args(rs2_error error)`
`static BytePointer`	`rs2_get_failed_function(rs2_error error)`
`static int`	`rs2_get_frame_bits_per_pixel(rs2_frame frame, PointerPointer error)` retrieve bits per pixels in the frame image (note that bits per pixel is not necessarily divided by 8, as in 12bpp)
`static int`	`rs2_get_frame_bits_per_pixel(rs2_frame frame, rs2_error error)`
`static long`	`rs2_get_frame_data_address(rs2_frame frame, PointerPointer error)`
`static long`	`rs2_get_frame_data_address(rs2_frame frame, rs2_error error)`
`static int`	`rs2_get_frame_data_size(rs2_frame frame, PointerPointer error)` retrieve data size from frame handle
`static int`	`rs2_get_frame_data_size(rs2_frame frame, rs2_error error)`
`static Pointer`	`rs2_get_frame_data(rs2_frame frame, PointerPointer error)` retrieve data from frame handle
`static Pointer`	`rs2_get_frame_data(rs2_frame frame, rs2_error error)`
`static int`	`rs2_get_frame_height(rs2_frame frame, PointerPointer error)` retrieve frame height in pixels
`static int`	`rs2_get_frame_height(rs2_frame frame, rs2_error error)`
`static long`	`rs2_get_frame_metadata(rs2_frame frame, int frame_metadata, PointerPointer error)` retrieve metadata from frame handle
`static long`	`rs2_get_frame_metadata(rs2_frame frame, int frame_metadata, rs2_error error)`
`static long`	`rs2_get_frame_number(rs2_frame frame, PointerPointer error)` retrieve frame number from frame handle
`static long`	`rs2_get_frame_number(rs2_frame frame, rs2_error error)`
`static int`	`rs2_get_frame_points_count(rs2_frame frame, PointerPointer error)` When called on Points frame type, this method returns the number of vertices in the frame
`static int`	`rs2_get_frame_points_count(rs2_frame frame, rs2_error error)`
`static rs2_sensor`	`rs2_get_frame_sensor(rs2_frame frame, PointerPointer error)` retrieve frame parent sensor from frame handle
`static rs2_sensor`	`rs2_get_frame_sensor(rs2_frame frame, rs2_error error)`
`static rs2_stream_profile`	`rs2_get_frame_stream_profile(rs2_frame frame, PointerPointer error)` Returns the stream profile that was used to start the stream of this frame
`static rs2_stream_profile`	`rs2_get_frame_stream_profile(rs2_frame frame, rs2_error error)`
`static int`	`rs2_get_frame_stride_in_bytes(rs2_frame frame, PointerPointer error)` retrieve frame stride in bytes (number of bytes from start of line N to start of line N+1)
`static int`	`rs2_get_frame_stride_in_bytes(rs2_frame frame, rs2_error error)`
`static rs2_pixel`	`rs2_get_frame_texture_coordinates(rs2_frame frame, PointerPointer error)` When called on Points frame type, this method returns a pointer to an array of texture coordinates per vertex Each coordinate represent a (u,v) pair within [0,1] range, to be mapped to texture image
`static rs2_pixel`	`rs2_get_frame_texture_coordinates(rs2_frame frame, rs2_error error)`
`static int`	`rs2_get_frame_timestamp_domain(rs2_frame frameset, PointerPointer error)` retrieve timestamp domain from frame handle.
`static int`	`rs2_get_frame_timestamp_domain(rs2_frame frameset, rs2_error error)`
`static double`	`rs2_get_frame_timestamp(rs2_frame frame, PointerPointer error)` retrieve timestamp from frame handle in milliseconds
`static double`	`rs2_get_frame_timestamp(rs2_frame frame, rs2_error error)`
`static rs2_vertex`	`rs2_get_frame_vertices(rs2_frame frame, PointerPointer error)` When called on Points frame type, this method returns a pointer to an array of 3D vertices of the model The coordinate system is: X right, Y up, Z away from the camera.
`static rs2_vertex`	`rs2_get_frame_vertices(rs2_frame frame, rs2_error error)`
`static int`	`rs2_get_frame_width(rs2_frame frame, PointerPointer error)` retrieve frame width in pixels
`static int`	`rs2_get_frame_width(rs2_frame frame, rs2_error error)`
`static BytePointer`	`rs2_get_full_log_message(rs2_log_message msg, PointerPointer error)`
`static BytePointer`	`rs2_get_full_log_message(rs2_log_message msg, rs2_error error)`
`static void`	`rs2_get_hdad(rs2_device dev, STHdad group, int mode, PointerPointer error)`
`static void`	`rs2_get_hdad(rs2_device dev, STHdad group, int mode, rs2_error error)`
`static int`	`rs2_get_librealsense_exception_type(rs2_error error)`
`static BytePointer`	`rs2_get_log_message_filename(rs2_log_message msg, PointerPointer error)`
`static BytePointer`	`rs2_get_log_message_filename(rs2_log_message msg, rs2_error error)`
`static int`	`rs2_get_log_message_line_number(rs2_log_message msg, PointerPointer error)`
`static int`	`rs2_get_log_message_line_number(rs2_log_message msg, rs2_error error)`
`static float`	`rs2_get_max_usable_depth_range(rs2_sensor sensor, PointerPointer error)` When called on a depth sensor, this method will return the maximum range of the camera given the amount of ambient light in the scene
`static float`	`rs2_get_max_usable_depth_range(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_get_motion_intrinsics(rs2_stream_profile mode, rs2_motion_device_intrinsic intrinsics, PointerPointer error)` Obtain the intrinsics of a specific stream configuration from the device.
`static void`	`rs2_get_motion_intrinsics(rs2_stream_profile mode, rs2_motion_device_intrinsic intrinsics, rs2_error error)`
`static int`	`rs2_get_notification_category(rs2_notification notification, PointerPointer error)` retrieve category from notification handle
`static int`	`rs2_get_notification_category(rs2_notification notification, rs2_error error)`
`static BytePointer`	`rs2_get_notification_description(rs2_notification notification, PointerPointer error)` retrieve description from notification handle
`static BytePointer`	`rs2_get_notification_description(rs2_notification notification, rs2_error error)`
`static BytePointer`	`rs2_get_notification_serialized_data(rs2_notification notification, PointerPointer error)` retrieve serialized data from notification handle
`static BytePointer`	`rs2_get_notification_serialized_data(rs2_notification notification, rs2_error error)`
`static int`	`rs2_get_notification_severity(rs2_notification notification, PointerPointer error)` retrieve severity from notification handle
`static int`	`rs2_get_notification_severity(rs2_notification notification, rs2_error error)`
`static double`	`rs2_get_notification_timestamp(rs2_notification notification, PointerPointer error)` retrieve timestamp from notification handle
`static double`	`rs2_get_notification_timestamp(rs2_notification notification, rs2_error error)`
`static BytePointer`	`rs2_get_option_description(rs2_options options, int option, PointerPointer error)` get option description
`static BytePointer`	`rs2_get_option_description(rs2_options options, int option, rs2_error error)`
`static int`	`rs2_get_option_from_list(rs2_options_list options, int i, PointerPointer error)` get the specific option from options list
`static int`	`rs2_get_option_from_list(rs2_options_list options, int i, rs2_error error)`
`static BytePointer`	`rs2_get_option_name(rs2_options options, int option, PointerPointer error)` get option name
`static BytePointer`	`rs2_get_option_name(rs2_options options, int option, rs2_error error)`
`static void`	`rs2_get_option_range(rs2_options sensor, int option, float[] min, float[] max, float[] step, float[] def, rs2_error error)`
`static void`	`rs2_get_option_range(rs2_options sensor, int option, FloatBuffer min, FloatBuffer max, FloatBuffer step, FloatBuffer def, rs2_error error)`
`static void`	`rs2_get_option_range(rs2_options sensor, int option, FloatPointer min, FloatPointer max, FloatPointer step, FloatPointer def, PointerPointer error)` retrieve the available range of values of a supported option
`static void`	`rs2_get_option_range(rs2_options sensor, int option, FloatPointer min, FloatPointer max, FloatPointer step, FloatPointer def, rs2_error error)`
`static BytePointer`	`rs2_get_option_value_description(rs2_options options, int option, float value, PointerPointer error)` get option value description (in case specific option value hold special meaning)
`static BytePointer`	`rs2_get_option_value_description(rs2_options options, int option, float value, rs2_error error)`
`static float`	`rs2_get_option(rs2_options options, int option, PointerPointer error)` read option value from the sensor
`static float`	`rs2_get_option(rs2_options options, int option, rs2_error error)`
`static int`	`rs2_get_options_list_size(rs2_options_list options, PointerPointer error)` get the size of options list
`static int`	`rs2_get_options_list_size(rs2_options_list options, rs2_error error)`
`static rs2_options_list`	`rs2_get_options_list(rs2_options options, PointerPointer error)` get the list of supported options of options container
`static rs2_options_list`	`rs2_get_options_list(rs2_options options, rs2_error error)`
`static BytePointer`	`rs2_get_processing_block_info(rs2_processing_block block, int info, PointerPointer error)` Retrieve processing block specific information, like name.
`static BytePointer`	`rs2_get_processing_block_info(rs2_processing_block block, int info, rs2_error error)`
`static rs2_processing_block`	`rs2_get_processing_block(rs2_processing_block_list list, int index, PointerPointer error)` Returns specific processing blocks from processing blocks list
`static rs2_processing_block`	`rs2_get_processing_block(rs2_processing_block_list list, int index, rs2_error error)`
`static void`	`rs2_get_rau_support_vector_control(rs2_device dev, STRauSupportVectorControl group, int mode, PointerPointer error)`
`static void`	`rs2_get_rau_support_vector_control(rs2_device dev, STRauSupportVectorControl group, int mode, rs2_error error)`
`static void`	`rs2_get_rau_thresholds_control(rs2_device dev, STRauColorThresholdsControl group, int mode, PointerPointer error)`
`static void`	`rs2_get_rau_thresholds_control(rs2_device dev, STRauColorThresholdsControl group, int mode, rs2_error error)`
`static int`	`rs2_get_raw_data_size(rs2_raw_data_buffer buffer, PointerPointer error)` get the size of rs2_raw_data_buffer
`static int`	`rs2_get_raw_data_size(rs2_raw_data_buffer buffer, rs2_error error)`
`static BytePointer`	`rs2_get_raw_data(rs2_raw_data_buffer buffer, PointerPointer error)` Retrieve char array from rs2_raw_data_buffer
`static BytePointer`	`rs2_get_raw_data(rs2_raw_data_buffer buffer, rs2_error error)`
`static BytePointer`	`rs2_get_raw_log_message(rs2_log_message msg, PointerPointer error)`
`static BytePointer`	`rs2_get_raw_log_message(rs2_log_message msg, rs2_error error)`
`static int`	`rs2_get_recommended_processing_blocks_count(rs2_processing_block_list list, PointerPointer error)` Returns the processing blocks list size
`static int`	`rs2_get_recommended_processing_blocks_count(rs2_processing_block_list list, rs2_error error)`
`static rs2_processing_block_list`	`rs2_get_recommended_processing_blocks(rs2_sensor sensor, PointerPointer error)` Returns the list of recommended processing blocks for a specific sensor.
`static rs2_processing_block_list`	`rs2_get_recommended_processing_blocks(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_get_region_of_interest(rs2_sensor sensor, int[] min_x, int[] min_y, int[] max_x, int[] max_y, rs2_error error)`
`static void`	`rs2_get_region_of_interest(rs2_sensor sensor, IntBuffer min_x, IntBuffer min_y, IntBuffer max_x, IntBuffer max_y, rs2_error error)`
`static void`	`rs2_get_region_of_interest(rs2_sensor sensor, IntPointer min_x, IntPointer min_y, IntPointer max_x, IntPointer max_y, PointerPointer error)` \brief gets the active region of interest to be used by auto-exposure algorithm
`static void`	`rs2_get_region_of_interest(rs2_sensor sensor, IntPointer min_x, IntPointer min_y, IntPointer max_x, IntPointer max_y, rs2_error error)`
`static void`	`rs2_get_rsm(rs2_device dev, STRsm group, int mode, PointerPointer error)`
`static void`	`rs2_get_rsm(rs2_device dev, STRsm group, int mode, rs2_error error)`
`static BytePointer`	`rs2_get_sensor_info(rs2_sensor sensor, int info, PointerPointer error)` retrieve sensor specific information, like versions of various internal components
`static BytePointer`	`rs2_get_sensor_info(rs2_sensor sensor, int info, rs2_error error)`
`static int`	`rs2_get_sensors_count(rs2_sensor_list info_list, PointerPointer error)` Determines number of sensors in a list
`static int`	`rs2_get_sensors_count(rs2_sensor_list info_list, rs2_error error)`
`static void`	`rs2_get_slo_color_thresholds_control(rs2_device dev, STSloColorThresholdsControl group, int mode, PointerPointer error)`
`static void`	`rs2_get_slo_color_thresholds_control(rs2_device dev, STSloColorThresholdsControl group, int mode, rs2_error error)`
`static void`	`rs2_get_slo_penalty_control(rs2_device dev, STSloPenaltyControl group, int mode, PointerPointer error)`
`static void`	`rs2_get_slo_penalty_control(rs2_device dev, STSloPenaltyControl group, int mode, rs2_error error)`
`static int`	`rs2_get_static_node(rs2_sensor sensor, BytePointer guid, rs2_vector pos, rs2_quaternion orient, PointerPointer error)` Retrieve a named location tag
`static int`	`rs2_get_static_node(rs2_sensor sensor, BytePointer guid, rs2_vector pos, rs2_quaternion orient, rs2_error error)`
`static int`	`rs2_get_static_node(rs2_sensor sensor, String guid, rs2_vector pos, rs2_quaternion orient, rs2_error error)`
`static float`	`rs2_get_stereo_baseline(rs2_sensor sensor, PointerPointer error)` Retrieve the stereoscopic baseline value from sensor.
`static float`	`rs2_get_stereo_baseline(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_get_stream_profile_data(rs2_stream_profile mode, int[] stream, int[] format, int[] index, int[] unique_id, int[] framerate, rs2_error error)`
`static void`	`rs2_get_stream_profile_data(rs2_stream_profile mode, IntBuffer stream, IntBuffer format, IntBuffer index, IntBuffer unique_id, IntBuffer framerate, rs2_error error)`
`static void`	`rs2_get_stream_profile_data(rs2_stream_profile mode, IntPointer stream, IntPointer format, IntPointer index, IntPointer unique_id, IntPointer framerate, PointerPointer error)` Extract common parameters of a stream profiles
`static void`	`rs2_get_stream_profile_data(rs2_stream_profile mode, IntPointer stream, IntPointer format, IntPointer index, IntPointer unique_id, IntPointer framerate, rs2_error error)`
`static rs2_stream_profile`	`rs2_get_stream_profile(rs2_stream_profile_list list, int index, PointerPointer error)` Get pointer to specific stream profile
`static rs2_stream_profile`	`rs2_get_stream_profile(rs2_stream_profile_list list, int index, rs2_error error)`
`static int`	`rs2_get_stream_profiles_count(rs2_stream_profile_list list, PointerPointer error)` get the number of supported stream profiles
`static int`	`rs2_get_stream_profiles_count(rs2_stream_profile_list list, rs2_error error)`
`static rs2_stream_profile_list`	`rs2_get_stream_profiles(rs2_sensor sensor, PointerPointer error)` check if physical subdevice is supported
`static rs2_stream_profile_list`	`rs2_get_stream_profiles(rs2_sensor sensor, rs2_error error)`
`static double`	`rs2_get_time(PointerPointer error)` return the time at specific time point
`static double`	`rs2_get_time(rs2_error error)`
`static void`	`rs2_get_video_stream_intrinsics(rs2_stream_profile mode, rs2_intrinsics intrinsics, PointerPointer error)` When called on a video profile, returns the intrinsics of specific stream configuration
`static void`	`rs2_get_video_stream_intrinsics(rs2_stream_profile mode, rs2_intrinsics intrinsics, rs2_error error)`
`static void`	`rs2_get_video_stream_resolution(rs2_stream_profile mode, int[] width, int[] height, rs2_error error)`
`static void`	`rs2_get_video_stream_resolution(rs2_stream_profile mode, IntBuffer width, IntBuffer height, rs2_error error)`
`static void`	`rs2_get_video_stream_resolution(rs2_stream_profile mode, IntPointer width, IntPointer height, PointerPointer error)` When called on a video stream profile, will return the width and the height of the stream
`static void`	`rs2_get_video_stream_resolution(rs2_stream_profile mode, IntPointer width, IntPointer height, rs2_error error)`
`static void`	`rs2_hardware_reset(rs2_device device, PointerPointer error)` Send hardware reset request to the device.
`static void`	`rs2_hardware_reset(rs2_device device, rs2_error error)`
`static BytePointer`	`rs2_host_perf_mode_to_string(int perf)`
`static int`	`rs2_import_localization_map(rs2_sensor sensor, byte[] lmap_blob, int blob_size, rs2_error error)`
`static int`	`rs2_import_localization_map(rs2_sensor sensor, ByteBuffer lmap_blob, int blob_size, rs2_error error)`
`static int`	`rs2_import_localization_map(rs2_sensor sensor, BytePointer lmap_blob, int blob_size, PointerPointer error)` Imports a localization map from file to tm2 tracking device
`static int`	`rs2_import_localization_map(rs2_sensor sensor, BytePointer lmap_blob, int blob_size, rs2_error error)`
`static int`	`rs2_is_device_extendable_to(rs2_device device, int extension, PointerPointer error)` Test if the given device can be extended to the requested extension.
`static int`	`rs2_is_device_extendable_to(rs2_device device, int extension, rs2_error error)`
`static void`	`rs2_is_enabled(rs2_device dev, int[] enabled, rs2_error error)`
`static void`	`rs2_is_enabled(rs2_device dev, IntBuffer enabled, rs2_error error)`
`static void`	`rs2_is_enabled(rs2_device dev, IntPointer enabled, PointerPointer error)`
`static void`	`rs2_is_enabled(rs2_device dev, IntPointer enabled, rs2_error error)`
`static int`	`rs2_is_frame_extendable_to(rs2_frame frame, int extension_type, PointerPointer error)` Test if the given frame can be extended to the requested extension
`static int`	`rs2_is_frame_extendable_to(rs2_frame frame, int extension_type, rs2_error error)`
`static int`	`rs2_is_option_read_only(rs2_options options, int option, PointerPointer error)` check if an option is read-only
`static int`	`rs2_is_option_read_only(rs2_options options, int option, rs2_error error)`
`static int`	`rs2_is_processing_block_extendable_to(rs2_processing_block block, int extension_type, PointerPointer error)` Test if the given processing block can be extended to the requested extension
`static int`	`rs2_is_processing_block_extendable_to(rs2_processing_block block, int extension_type, rs2_error error)`
`static int`	`rs2_is_sensor_extendable_to(rs2_sensor sensor, int extension, PointerPointer error)` Test if the given sensor can be extended to the requested extension
`static int`	`rs2_is_sensor_extendable_to(rs2_sensor sensor, int extension, rs2_error error)`
`static int`	`rs2_is_stream_profile_default(rs2_stream_profile mode, PointerPointer error)` Returns non-zero if selected profile is recommended for the sensor This is an optional hint we offer to suggest profiles with best performance-quality tradeof
`static int`	`rs2_is_stream_profile_default(rs2_stream_profile mode, rs2_error error)`
`static void`	`rs2_keep_frame(rs2_frame frame)` communicate to the library you intend to keep the frame alive for a while this will remove the frame from the regular count of the frame pool once this function is called, the SDK can no longer guarantee 0-allocations during frame cycling
`static BytePointer`	`rs2_l500_visual_preset_to_string(int preset)`
`static void`	`rs2_load_json(rs2_device dev, Pointer json_content, int content_size, PointerPointer error)`
`static void`	`rs2_load_json(rs2_device dev, Pointer json_content, int content_size, rs2_error error)`
`static int`	`rs2_load_wheel_odometry_config(rs2_sensor sensor, byte[] odometry_config_buf, int blob_size, rs2_error error)`
`static int`	`rs2_load_wheel_odometry_config(rs2_sensor sensor, ByteBuffer odometry_config_buf, int blob_size, rs2_error error)`
`static int`	`rs2_load_wheel_odometry_config(rs2_sensor sensor, BytePointer odometry_config_buf, int blob_size, PointerPointer error)` Load Wheel odometer settings from host to device
`static int`	`rs2_load_wheel_odometry_config(rs2_sensor sensor, BytePointer odometry_config_buf, int blob_size, rs2_error error)`
`static BytePointer`	`rs2_log_severity_to_string(int info)`
`static void`	`rs2_log_to_callback_cpp(int min_severity, rs2_log_callback callback, PointerPointer error)`
`static void`	`rs2_log_to_callback_cpp(int min_severity, rs2_log_callback callback, rs2_error error)`
`static void`	`rs2_log_to_callback(int min_severity, rs2_log_callback_ptr callback, Pointer arg, PointerPointer error)`
`static void`	`rs2_log_to_callback(int min_severity, rs2_log_callback_ptr callback, Pointer arg, rs2_error error)`
`static void`	`rs2_log_to_console(int min_severity, PointerPointer error)`
`static void`	`rs2_log_to_console(int min_severity, rs2_error error)`
`static void`	`rs2_log_to_file(int min_severity, BytePointer file_path, PointerPointer error)`
`static void`	`rs2_log_to_file(int min_severity, BytePointer file_path, rs2_error error)`
`static void`	`rs2_log_to_file(int min_severity, String file_path, rs2_error error)`
`static void`	`rs2_log(int severity, BytePointer message, PointerPointer error)` Add custom message into librealsense log
`static void`	`rs2_log(int severity, BytePointer message, rs2_error error)`
`static void`	`rs2_log(int severity, String message, rs2_error error)`
`static void`	`rs2_loopback_disable(rs2_device device, PointerPointer error)` Restores the given device into normal operation mode
`static void`	`rs2_loopback_disable(rs2_device device, rs2_error error)`
`static void`	`rs2_loopback_enable(rs2_device device, BytePointer from_file, PointerPointer error)` Enter the given device into loopback operation mode that uses the given file as input for raw data
`static void`	`rs2_loopback_enable(rs2_device device, BytePointer from_file, rs2_error error)`
`static void`	`rs2_loopback_enable(rs2_device device, String from_file, rs2_error error)`
`static int`	`rs2_loopback_is_enabled(rs2_device device, PointerPointer error)` Checks if the device is in loopback mode or not
`static int`	`rs2_loopback_is_enabled(rs2_device device, rs2_error error)`
`static BytePointer`	`rs2_matchers_to_string(int stream)`
`static BytePointer`	`rs2_notification_category_to_string(int category)`
`static void`	`rs2_open_multiple(rs2_sensor device, PointerPointer profiles, int count, PointerPointer error)` open subdevice for exclusive access, by committing to composite configuration, specifying one or more stream profiles this method should be used for interdependent streams, such as depth and infrared, that have to be configured together
`static void`	`rs2_open_multiple(rs2_sensor device, rs2_stream_profile profiles, int count, rs2_error error)`
`static void`	`rs2_open(rs2_sensor device, rs2_stream_profile profile, PointerPointer error)` open subdevice for exclusive access, by committing to a configuration
`static void`	`rs2_open(rs2_sensor device, rs2_stream_profile profile, rs2_error error)`
`static BytePointer`	`rs2_option_to_string(int option)`
`static void`	`rs2_override_dsm_params(rs2_sensor sensor, rs2_dsm_params p_params, PointerPointer error)` Set the sensor DSM parameters This should ideally be done when the stream is NOT running.
`static void`	`rs2_override_dsm_params(rs2_sensor sensor, rs2_dsm_params p_params, rs2_error error)`
`static void`	`rs2_override_extrinsics(rs2_sensor sensor, rs2_extrinsics extrinsics, PointerPointer error)` \brief Override extrinsics of a given sensor that supports calibrated_sensor.
`static void`	`rs2_override_extrinsics(rs2_sensor sensor, rs2_extrinsics extrinsics, rs2_error error)`
`static void`	`rs2_override_intrinsics(rs2_sensor sensor, rs2_intrinsics intrinsics, PointerPointer error)` \brief Override intrinsics of a given sensor that supports calibrated_sensor.
`static void`	`rs2_override_intrinsics(rs2_sensor sensor, rs2_intrinsics intrinsics, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_pipeline_get_active_profile(rs2_pipeline pipe, PointerPointer error)` Return the active device and streams profiles, used by the pipeline.
`static rs2_pipeline_profile`	`rs2_pipeline_get_active_profile(rs2_pipeline pipe, rs2_error error)`
`static int`	`rs2_pipeline_poll_for_frames(rs2_pipeline pipe, PointerPointer output_frame, PointerPointer error)` Check if a new set of frames is available and retrieve the latest undelivered set.
`static int`	`rs2_pipeline_poll_for_frames(rs2_pipeline pipe, rs2_frame output_frame, rs2_error error)`
`static rs2_device`	`rs2_pipeline_profile_get_device(rs2_pipeline_profile profile, PointerPointer error)` Retrieve the device used by the pipeline.
`static rs2_device`	`rs2_pipeline_profile_get_device(rs2_pipeline_profile profile, rs2_error error)`
`static rs2_stream_profile_list`	`rs2_pipeline_profile_get_streams(rs2_pipeline_profile profile, PointerPointer error)` Return the selected streams profiles, which are enabled in this profile.
`static rs2_stream_profile_list`	`rs2_pipeline_profile_get_streams(rs2_pipeline_profile profile, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_callback_cpp(rs2_pipeline pipe, rs2_frame_callback callback, PointerPointer error)` Start the pipeline streaming with its default configuration.
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_callback_cpp(rs2_pipeline pipe, rs2_frame_callback callback, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_callback(rs2_pipeline pipe, rs2_frame_callback_ptr on_frame, Pointer user, PointerPointer error)` Start the pipeline streaming with its default configuration.
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_callback(rs2_pipeline pipe, rs2_frame_callback_ptr on_frame, Pointer user, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_config_and_callback_cpp(rs2_pipeline pipe, rs2_config config, rs2_frame_callback callback, PointerPointer error)` Start the pipeline streaming according to the configuraion.
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_config_and_callback_cpp(rs2_pipeline pipe, rs2_config config, rs2_frame_callback callback, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_config_and_callback(rs2_pipeline pipe, rs2_config config, rs2_frame_callback_ptr on_frame, Pointer user, PointerPointer error)` Start the pipeline streaming according to the configuraion.
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_config_and_callback(rs2_pipeline pipe, rs2_config config, rs2_frame_callback_ptr on_frame, Pointer user, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_config(rs2_pipeline pipe, rs2_config config, PointerPointer error)` Start the pipeline streaming according to the configuraion.
`static rs2_pipeline_profile`	`rs2_pipeline_start_with_config(rs2_pipeline pipe, rs2_config config, rs2_error error)`
`static rs2_pipeline_profile`	`rs2_pipeline_start(rs2_pipeline pipe, PointerPointer error)` Start the pipeline streaming with its default configuration.
`static rs2_pipeline_profile`	`rs2_pipeline_start(rs2_pipeline pipe, rs2_error error)`
`static void`	`rs2_pipeline_stop(rs2_pipeline pipe, PointerPointer error)` Stop the pipeline streaming.
`static void`	`rs2_pipeline_stop(rs2_pipeline pipe, rs2_error error)`
`static int`	`rs2_pipeline_try_wait_for_frames(rs2_pipeline pipe, PointerPointer output_frame, int timeout_ms, PointerPointer error)` Wait until a new set of frames becomes available.
`static int`	`rs2_pipeline_try_wait_for_frames(rs2_pipeline pipe, rs2_frame output_frame, int timeout_ms, rs2_error error)`
`static rs2_frame`	`rs2_pipeline_wait_for_frames(rs2_pipeline pipe, int timeout_ms, PointerPointer error)` Wait until a new set of frames becomes available.
`static rs2_frame`	`rs2_pipeline_wait_for_frames(rs2_pipeline pipe, int timeout_ms, rs2_error error)`
`static int`	`rs2_playback_device_get_current_status(rs2_device device, PointerPointer error)` Returns the current state of the playback device
`static int`	`rs2_playback_device_get_current_status(rs2_device device, rs2_error error)`
`static BytePointer`	`rs2_playback_device_get_file_path(rs2_device device, PointerPointer error)` Gets the path of the file used by the playback device
`static BytePointer`	`rs2_playback_device_get_file_path(rs2_device device, rs2_error error)`
`static int`	`rs2_playback_device_is_real_time(rs2_device device, PointerPointer error)` Indicates if playback is in real time mode or non real time
`static int`	`rs2_playback_device_is_real_time(rs2_device device, rs2_error error)`
`static void`	`rs2_playback_device_pause(rs2_device device, PointerPointer error)` Un-pauses the playback Calling resume() while playback status is "Playing" or "Stopped" does nothing
`static void`	`rs2_playback_device_pause(rs2_device device, rs2_error error)`
`static void`	`rs2_playback_device_resume(rs2_device device, PointerPointer error)` Pauses the playback Calling pause() in "Paused" status does nothing If pause() is called while playback status is "Playing" or "Stopped", the playback will not play until resume() is called
`static void`	`rs2_playback_device_resume(rs2_device device, rs2_error error)`
`static void`	`rs2_playback_device_set_playback_speed(rs2_device device, float speed, PointerPointer error)` Set the playing speed
`static void`	`rs2_playback_device_set_playback_speed(rs2_device device, float speed, rs2_error error)`
`static void`	`rs2_playback_device_set_real_time(rs2_device device, int real_time, PointerPointer error)` Set the playback to work in real time or non real time In real time mode, playback will play the same way the file was recorded.
`static void`	`rs2_playback_device_set_real_time(rs2_device device, int real_time, rs2_error error)`
`static void`	`rs2_playback_device_set_status_changed_callback(rs2_device device, rs2_playback_status_changed_callback callback, PointerPointer error)` Register to receive callback from playback device upon its status changes Callbacks are invoked from the reading thread, any heavy processing in the callback handler will affect the reading thread and may cause frame drops\ high latency
`static void`	`rs2_playback_device_set_status_changed_callback(rs2_device device, rs2_playback_status_changed_callback callback, rs2_error error)`
`static void`	`rs2_playback_device_stop(rs2_device device, PointerPointer error)` Stops the playback Calling stop() will stop all streaming playbakc sensors and will reset the playback (returning to beginning of file)
`static void`	`rs2_playback_device_stop(rs2_device device, rs2_error error)`
`static long`	`rs2_playback_get_duration(rs2_device device, PointerPointer error)` Gets the total duration of the file in units of nanoseconds
`static long`	`rs2_playback_get_duration(rs2_device device, rs2_error error)`
`static long`	`rs2_playback_get_position(rs2_device device, PointerPointer error)` Gets the current position of the playback in the file in terms of time.
`static long`	`rs2_playback_get_position(rs2_device device, rs2_error error)`
`static void`	`rs2_playback_seek(rs2_device device, long time, PointerPointer error)` Set the playback to a specified time point of the played data
`static void`	`rs2_playback_seek(rs2_device device, long time, rs2_error error)`
`static BytePointer`	`rs2_playback_status_to_string(int status)`
`static int`	`rs2_poll_for_frame(rs2_frame_queue queue, PointerPointer output_frame, PointerPointer error)` poll if a new frame is available and dequeue if it is
`static int`	`rs2_poll_for_frame(rs2_frame_queue queue, rs2_frame output_frame, rs2_error error)`
`static void`	`rs2_pose_frame_get_pose_data(rs2_frame frame, rs2_pose pose, PointerPointer error)` When called on Pose frame type, this method returns the transformation represented by the pose data
`static void`	`rs2_pose_frame_get_pose_data(rs2_frame frame, rs2_pose pose, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_process_calibration_frame(rs2_device dev, rs2_frame f, float[] health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_process_calibration_frame(rs2_device dev, rs2_frame f, FloatBuffer health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_process_calibration_frame(rs2_device dev, rs2_frame f, FloatPointer health, rs2_update_progress_callback progress_callback, int timeout_ms, PointerPointer error)` During host assisted calibration (Tare or on-chip), this is used to pump new depth frames until calibration is done.
`static rs2_raw_data_buffer`	`rs2_process_calibration_frame(rs2_device dev, rs2_frame f, FloatPointer health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static void`	`rs2_process_frame(rs2_processing_block block, rs2_frame frame, PointerPointer error)` This method is used to pass frame into a processing block
`static void`	`rs2_process_frame(rs2_processing_block block, rs2_frame frame, rs2_error error)`
`static int`	`rs2_processing_block_register_simple_option(rs2_processing_block block, int option_id, float min, float max, float step, float def, PointerPointer error)` This method adds a custom option to a custom processing block.
`static int`	`rs2_processing_block_register_simple_option(rs2_processing_block block, int option_id, float min, float max, float step, float def, rs2_error error)`
`static void`	`rs2_project_color_pixel_to_depth_pixel(float[] to_pixel, short[] data, float depth_scale, float depth_min, float depth_max, rs2_intrinsics depth_intrin, rs2_intrinsics color_intrin, rs2_extrinsics color_to_depth, rs2_extrinsics depth_to_color, float[] from_pixel)`
`static void`	`rs2_project_color_pixel_to_depth_pixel(FloatBuffer to_pixel, ShortBuffer data, float depth_scale, float depth_min, float depth_max, rs2_intrinsics depth_intrin, rs2_intrinsics color_intrin, rs2_extrinsics color_to_depth, rs2_extrinsics depth_to_color, FloatBuffer from_pixel)`
`static void`	`rs2_project_color_pixel_to_depth_pixel(FloatPointer to_pixel, ShortPointer data, float depth_scale, float depth_min, float depth_max, rs2_intrinsics depth_intrin, rs2_intrinsics color_intrin, rs2_extrinsics color_to_depth, rs2_extrinsics depth_to_color, FloatPointer from_pixel)`
`static void`	`rs2_project_point_to_pixel(float[] pixel, rs2_intrinsics intrin, float[] point)`
`static void`	`rs2_project_point_to_pixel(FloatBuffer pixel, rs2_intrinsics intrin, FloatBuffer point)`
`static void`	`rs2_project_point_to_pixel(FloatPointer pixel, rs2_intrinsics intrin, FloatPointer point)`
`static rs2_device_list`	`rs2_query_devices_ex(rs2_context context, int product_mask, PointerPointer error)` create a static snapshot of all connected devices at the time of the call
`static rs2_device_list`	`rs2_query_devices_ex(rs2_context context, int product_mask, rs2_error error)`
`static rs2_device_list`	`rs2_query_devices(rs2_context context, PointerPointer error)` create a static snapshot of all connected devices at the time of the call
`static rs2_device_list`	`rs2_query_devices(rs2_context context, rs2_error error)`
`static rs2_sensor_list`	`rs2_query_sensors(rs2_device device, PointerPointer error)` Create a static snapshot of all connected sensors within a specific device.
`static rs2_sensor_list`	`rs2_query_sensors(rs2_device device, rs2_error error)`
`static BytePointer`	`rs2_record_device_filename(rs2_device device, PointerPointer error)` Gets the name of the file to which the recorder is writing
`static BytePointer`	`rs2_record_device_filename(rs2_device device, rs2_error error)`
`static void`	`rs2_record_device_pause(rs2_device device, PointerPointer error)` Pause the recording device without stopping the actual device from streaming.
`static void`	`rs2_record_device_pause(rs2_device device, rs2_error error)`
`static void`	`rs2_record_device_resume(rs2_device device, PointerPointer error)` Unpause the recording device.
`static void`	`rs2_record_device_resume(rs2_device device, rs2_error error)`
`static void`	`rs2_register_calibration_change_callback_cpp(rs2_device dev, rs2_calibration_change_callback callback, PointerPointer error)` Adds a callback for a sensor that gets called when calibration (intrinsics) changes, e.g.
`static void`	`rs2_register_calibration_change_callback_cpp(rs2_device dev, rs2_calibration_change_callback callback, rs2_error error)`
`static void`	`rs2_register_calibration_change_callback(rs2_device dev, rs2_calibration_change_callback_ptr callback, Pointer user, PointerPointer error)` Adds a callback for a sensor that gets called when calibration (intrinsics) changes, e.g.
`static void`	`rs2_register_calibration_change_callback(rs2_device dev, rs2_calibration_change_callback_ptr callback, Pointer user, rs2_error error)`
`static void`	`rs2_register_extrinsics(rs2_stream_profile from, rs2_stream_profile to, rs2_extrinsics extrin, PointerPointer error)`
`static void`	`rs2_register_extrinsics(rs2_stream_profile from, rs2_stream_profile to, rs2_extrinsics extrin, rs2_error error)`
`static void`	`rs2_release_frame(rs2_frame frame)` relases the frame handle
`static int`	`rs2_remove_static_node(rs2_sensor sensor, BytePointer guid, PointerPointer error)` Remove a named location tag
`static int`	`rs2_remove_static_node(rs2_sensor sensor, BytePointer guid, rs2_error error)`
`static int`	`rs2_remove_static_node(rs2_sensor sensor, String guid, rs2_error error)`
`static void`	`rs2_reset_logger(PointerPointer error)`
`static void`	`rs2_reset_logger(rs2_error error)`
`static void`	`rs2_reset_sensor_calibration(rs2_sensor sensor, PointerPointer error)` Reset the sensor DSM parameters This should ideally be done when the stream is NOT running.
`static void`	`rs2_reset_sensor_calibration(rs2_sensor sensor, rs2_error error)`
`static void`	`rs2_reset_to_factory_calibration(rs2_device device, PointerPointer e)` Reset device to factory calibration
`static void`	`rs2_reset_to_factory_calibration(rs2_device device, rs2_error e)`
`static BytePointer`	`rs2_rs400_visual_preset_to_string(int preset)`
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, float[] ratio, float[] angle, rs2_update_progress_callback progress_callback, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, FloatBuffer ratio, FloatBuffer angle, rs2_update_progress_callback progress_callback, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, FloatPointer ratio, FloatPointer angle, rs2_update_progress_callback progress_callback, PointerPointer error)` Run target-based focal length calibration
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, FloatPointer ratio, FloatPointer angle, rs2_update_progress_callback progress_callback, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, float[] ratio, float[] angle, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, FloatBuffer ratio, FloatBuffer angle, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, FloatPointer ratio, FloatPointer angle, rs2_update_progress_callback_ptr callback, Pointer client_data, PointerPointer error)` Run target-based focal length calibration
`static rs2_raw_data_buffer`	`rs2_run_focal_length_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue right_queue, float target_width, float target_height, int adjust_both_sides, FloatPointer ratio, FloatPointer angle, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration_cpp(rs2_device device, Pointer json_content, int content_size, float[] health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration_cpp(rs2_device device, Pointer json_content, int content_size, FloatBuffer health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration_cpp(rs2_device device, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback progress_callback, int timeout_ms, PointerPointer error)` This will improve the depth noise.
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration_cpp(rs2_device device, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration(rs2_device device, Pointer json_content, int content_size, float[] health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration(rs2_device device, Pointer json_content, int content_size, FloatBuffer health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration(rs2_device device, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, PointerPointer error)` This will improve the depth noise.
`static rs2_raw_data_buffer`	`rs2_run_on_chip_calibration(rs2_device device, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration_cpp(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, float[] health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration_cpp(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, FloatBuffer health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration_cpp(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback progress_callback, int timeout_ms, PointerPointer error)` This will adjust camera absolute distance to flat target.
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration_cpp(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback progress_callback, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, float[] health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, FloatBuffer health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, PointerPointer error)` This will adjust camera absolute distance to flat target.
`static rs2_raw_data_buffer`	`rs2_run_tare_calibration(rs2_device dev, float ground_truth_mm, Pointer json_content, int content_size, FloatPointer health, rs2_update_progress_callback_ptr callback, Pointer client_data, int timeout_ms, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, float[] health, int health_size, rs2_update_progress_callback progress_callback, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, FloatBuffer health, int health_size, rs2_update_progress_callback progress_callback, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, FloatPointer health, int health_size, rs2_update_progress_callback progress_callback, PointerPointer error)` Depth-RGB UV-Map calibration.
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration_cpp(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, FloatPointer health, int health_size, rs2_update_progress_callback progress_callback, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, float[] health, int health_size, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, FloatBuffer health, int health_size, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, FloatPointer health, int health_size, rs2_update_progress_callback_ptr callback, Pointer client_data, PointerPointer error)` Depth-RGB UV-Map calibration.
`static rs2_raw_data_buffer`	`rs2_run_uv_map_calibration(rs2_device device, rs2_frame_queue left_queue, rs2_frame_queue color_queue, rs2_frame_queue depth_queue, int py_px_only, FloatPointer health, int health_size, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_raw_data_buffer`	`rs2_send_and_receive_raw_data(rs2_device device, Pointer raw_data_to_send, int size_of_raw_data_to_send, PointerPointer error)` Send raw data to device
`static rs2_raw_data_buffer`	`rs2_send_and_receive_raw_data(rs2_device device, Pointer raw_data_to_send, int size_of_raw_data_to_send, rs2_error error)`
`static int`	`rs2_send_wheel_odometry(rs2_sensor sensor, byte wo_sensor_id, int frame_num, rs2_vector translational_velocity, PointerPointer error)` Send wheel odometry data for each individual sensor (wheel)
`static int`	`rs2_send_wheel_odometry(rs2_sensor sensor, byte wo_sensor_id, int frame_num, rs2_vector translational_velocity, rs2_error error)`
`static BytePointer`	`rs2_sensor_mode_to_string(int preset)`
`static rs2_raw_data_buffer`	`rs2_serialize_json(rs2_device dev, PointerPointer error)`
`static rs2_raw_data_buffer`	`rs2_serialize_json(rs2_device dev, rs2_error error)`
`static void`	`rs2_set_ae_control(rs2_device dev, STAEControl group, PointerPointer error)`
`static void`	`rs2_set_ae_control(rs2_device dev, STAEControl group, rs2_error error)`
`static void`	`rs2_set_amp_factor(rs2_device dev, STAFactor group, PointerPointer error)`
`static void`	`rs2_set_amp_factor(rs2_device dev, STAFactor group, rs2_error error)`
`static void`	`rs2_set_calibration_table(rs2_device device, Pointer calibration, int calibration_size, PointerPointer error)` Set current table to dynamic area.
`static void`	`rs2_set_calibration_table(rs2_device device, Pointer calibration, int calibration_size, rs2_error error)`
`static void`	`rs2_set_census(rs2_device dev, STCensusRadius group, PointerPointer error)`
`static void`	`rs2_set_census(rs2_device dev, STCensusRadius group, rs2_error error)`
`static void`	`rs2_set_color_control(rs2_device dev, STColorControl group, PointerPointer error)`
`static void`	`rs2_set_color_control(rs2_device dev, STColorControl group, rs2_error error)`
`static void`	`rs2_set_color_correction(rs2_device dev, STColorCorrection group, PointerPointer error)`
`static void`	`rs2_set_color_correction(rs2_device dev, STColorCorrection group, rs2_error error)`
`static void`	`rs2_set_depth_control(rs2_device dev, STDepthControlGroup group, PointerPointer error)`
`static void`	`rs2_set_depth_control(rs2_device dev, STDepthControlGroup group, rs2_error error)`
`static void`	`rs2_set_depth_table(rs2_device dev, STDepthTableControl group, PointerPointer error)`
`static void`	`rs2_set_depth_table(rs2_device dev, STDepthTableControl group, rs2_error error)`
`static void`	`rs2_set_devices_changed_callback_cpp(rs2_context context, rs2_devices_changed_callback callback, PointerPointer error)` set callback to get devices changed events these events will be raised by the context whenever new RealSense device is connected or existing device gets disconnected
`static void`	`rs2_set_devices_changed_callback_cpp(rs2_context context, rs2_devices_changed_callback callback, rs2_error error)`
`static void`	`rs2_set_devices_changed_callback(rs2_context context, rs2_devices_changed_callback_ptr callback, Pointer user, PointerPointer error)` set callback to get devices changed events these events will be raised by the context whenever new RealSense device is connected or existing device gets disconnected
`static void`	`rs2_set_devices_changed_callback(rs2_context context, rs2_devices_changed_callback_ptr callback, Pointer user, rs2_error error)`
`static void`	`rs2_set_extrinsics(rs2_sensor from_sensor, rs2_stream_profile from_profile, rs2_sensor to_sensor, rs2_stream_profile to_profile, rs2_extrinsics extrinsics, PointerPointer error)` Set extrinsics between two sensors
`static void`	`rs2_set_extrinsics(rs2_sensor from_sensor, rs2_stream_profile from_profile, rs2_sensor to_sensor, rs2_stream_profile to_profile, rs2_extrinsics extrinsics, rs2_error error)`
`static void`	`rs2_set_hdad(rs2_device dev, STHdad group, PointerPointer error)`
`static void`	`rs2_set_hdad(rs2_device dev, STHdad group, rs2_error error)`
`static void`	`rs2_set_intrinsics(rs2_sensor sensor, rs2_stream_profile profile, rs2_intrinsics intrinsics, PointerPointer error)` Set intrinsics of a given sensor
`static void`	`rs2_set_intrinsics(rs2_sensor sensor, rs2_stream_profile profile, rs2_intrinsics intrinsics, rs2_error error)`
`static void`	`rs2_set_motion_device_intrinsics(rs2_sensor sensor, rs2_stream_profile profile, rs2_motion_device_intrinsic intrinsics, PointerPointer error)` Set motion device intrinsics
`static void`	`rs2_set_motion_device_intrinsics(rs2_sensor sensor, rs2_stream_profile profile, rs2_motion_device_intrinsic intrinsics, rs2_error error)`
`static void`	`rs2_set_notifications_callback_cpp(rs2_sensor sensor, rs2_notifications_callback callback, PointerPointer error)` set callback to get notifications from specified device
`static void`	`rs2_set_notifications_callback_cpp(rs2_sensor sensor, rs2_notifications_callback callback, rs2_error error)`
`static void`	`rs2_set_notifications_callback(rs2_sensor sensor, rs2_notification_callback_ptr on_notification, Pointer user, PointerPointer error)` set callback to get notifications from specified sensor
`static void`	`rs2_set_notifications_callback(rs2_sensor sensor, rs2_notification_callback_ptr on_notification, Pointer user, rs2_error error)`
`static void`	`rs2_set_option(rs2_options options, int option, float value, PointerPointer error)` write new value to sensor option
`static void`	`rs2_set_option(rs2_options options, int option, float value, rs2_error error)`
`static void`	`rs2_set_rau_support_vector_control(rs2_device dev, STRauSupportVectorControl group, PointerPointer error)`
`static void`	`rs2_set_rau_support_vector_control(rs2_device dev, STRauSupportVectorControl group, rs2_error error)`
`static void`	`rs2_set_rau_thresholds_control(rs2_device dev, STRauColorThresholdsControl group, PointerPointer error)`
`static void`	`rs2_set_rau_thresholds_control(rs2_device dev, STRauColorThresholdsControl group, rs2_error error)`
`static void`	`rs2_set_region_of_interest(rs2_sensor sensor, int min_x, int min_y, int max_x, int max_y, PointerPointer error)` \brief sets the active region of interest to be used by auto-exposure algorithm
`static void`	`rs2_set_region_of_interest(rs2_sensor sensor, int min_x, int min_y, int max_x, int max_y, rs2_error error)`
`static void`	`rs2_set_rsm(rs2_device dev, STRsm group, PointerPointer error)`
`static void`	`rs2_set_rsm(rs2_device dev, STRsm group, rs2_error error)`
`static void`	`rs2_set_slo_color_thresholds_control(rs2_device dev, STSloColorThresholdsControl group, PointerPointer error)`
`static void`	`rs2_set_slo_color_thresholds_control(rs2_device dev, STSloColorThresholdsControl group, rs2_error error)`
`static void`	`rs2_set_slo_penalty_control(rs2_device dev, STSloPenaltyControl group, PointerPointer error)`
`static void`	`rs2_set_slo_penalty_control(rs2_device dev, STSloPenaltyControl group, rs2_error error)`
`static int`	`rs2_set_static_node(rs2_sensor sensor, BytePointer guid, rs2_vector pos, rs2_quaternion orient, PointerPointer error)` Create a named location tag
`static int`	`rs2_set_static_node(rs2_sensor sensor, BytePointer guid, rs2_vector pos, rs2_quaternion orient, rs2_error error)`
`static int`	`rs2_set_static_node(rs2_sensor sensor, String guid, rs2_vector pos, rs2_quaternion orient, rs2_error error)`
`static void`	`rs2_set_stream_profile_data(rs2_stream_profile mode, int stream, int index, int format, PointerPointer error)` Override some of the parameters of the stream profile
`static void`	`rs2_set_stream_profile_data(rs2_stream_profile mode, int stream, int index, int format, rs2_error error)`
`static BytePointer`	`rs2_sr300_visual_preset_to_string(int preset)`
`static void`	`rs2_start_cpp(rs2_sensor sensor, rs2_frame_callback callback, PointerPointer error)` start streaming from specified configured sensor
`static void`	`rs2_start_cpp(rs2_sensor sensor, rs2_frame_callback callback, rs2_error error)`
`static void`	`rs2_start_processing_fptr(rs2_processing_block block, rs2_frame_callback_ptr on_frame, Pointer user, PointerPointer error)` This method is used to direct the output from the processing block to some callback or sink object
`static void`	`rs2_start_processing_fptr(rs2_processing_block block, rs2_frame_callback_ptr on_frame, Pointer user, rs2_error error)`
`static void`	`rs2_start_processing_queue(rs2_processing_block block, rs2_frame_queue queue, PointerPointer error)` This method is used to direct the output from the processing block to a dedicated queue object
`static void`	`rs2_start_processing_queue(rs2_processing_block block, rs2_frame_queue queue, rs2_error error)`
`static void`	`rs2_start_processing(rs2_processing_block block, rs2_frame_callback on_frame, PointerPointer error)` This method is used to direct the output from the processing block to some callback or sink object
`static void`	`rs2_start_processing(rs2_processing_block block, rs2_frame_callback on_frame, rs2_error error)`
`static void`	`rs2_start_queue(rs2_sensor sensor, rs2_frame_queue queue, PointerPointer error)` start streaming from specified configured sensor of specific stream to frame queue
`static void`	`rs2_start_queue(rs2_sensor sensor, rs2_frame_queue queue, rs2_error error)`
`static void`	`rs2_start(rs2_sensor sensor, rs2_frame_callback_ptr on_frame, Pointer user, PointerPointer error)` start streaming from specified configured sensor
`static void`	`rs2_start(rs2_sensor sensor, rs2_frame_callback_ptr on_frame, Pointer user, rs2_error error)`
`static void`	`rs2_stop(rs2_sensor sensor, PointerPointer error)` stops streaming from specified configured device
`static void`	`rs2_stop(rs2_sensor sensor, rs2_error error)`
`static int`	`rs2_stream_profile_is(rs2_stream_profile mode, int type, PointerPointer error)` Try to extend stream profile to an extension type
`static int`	`rs2_stream_profile_is(rs2_stream_profile mode, int type, rs2_error error)`
`static BytePointer`	`rs2_stream_to_string(int stream)`
`static int`	`rs2_supports_device_info(rs2_device device, int info, PointerPointer error)` Check if a camera supports a specific camera info type.
`static int`	`rs2_supports_device_info(rs2_device device, int info, rs2_error error)`
`static int`	`rs2_supports_frame_metadata(rs2_frame frame, int frame_metadata, PointerPointer error)` determine device metadata
`static int`	`rs2_supports_frame_metadata(rs2_frame frame, int frame_metadata, rs2_error error)`
`static int`	`rs2_supports_option(rs2_options options, int option, PointerPointer error)` check if particular option is supported by a subdevice
`static int`	`rs2_supports_option(rs2_options options, int option, rs2_error error)`
`static int`	`rs2_supports_processing_block_info(rs2_processing_block block, int info, PointerPointer error)` Check if a processing block supports a specific info type.
`static int`	`rs2_supports_processing_block_info(rs2_processing_block block, int info, rs2_error error)`
`static int`	`rs2_supports_sensor_info(rs2_sensor sensor, int info, PointerPointer error)` check if specific sensor info is supported
`static int`	`rs2_supports_sensor_info(rs2_sensor sensor, int info, rs2_error error)`
`static void`	`rs2_synthetic_frame_ready(rs2_source source, rs2_frame frame, PointerPointer error)` This method will dispatch frame callback on a frame
`static void`	`rs2_synthetic_frame_ready(rs2_source source, rs2_frame frame, rs2_error error)`
`static BytePointer`	`rs2_timestamp_domain_to_string(int info)`
`static void`	`rs2_toggle_advanced_mode(rs2_device dev, int enable, PointerPointer error)`
`static void`	`rs2_toggle_advanced_mode(rs2_device dev, int enable, rs2_error error)`
`static void`	`rs2_transform_point_to_point(float[] to_point, rs2_extrinsics extrin, float[] from_point)`
`static void`	`rs2_transform_point_to_point(FloatBuffer to_point, rs2_extrinsics extrin, FloatBuffer from_point)`
`static void`	`rs2_transform_point_to_point(FloatPointer to_point, rs2_extrinsics extrin, FloatPointer from_point)`
`static void`	`rs2_trigger_device_calibration(rs2_device dev, int type, PointerPointer error)` Triggers calibration of the given type
`static void`	`rs2_trigger_device_calibration(rs2_device dev, int type, rs2_error error)`
`static int`	`rs2_try_wait_for_frame(rs2_frame_queue queue, int timeout_ms, PointerPointer output_frame, PointerPointer error)` wait until new frame becomes available in the queue and dequeue it
`static int`	`rs2_try_wait_for_frame(rs2_frame_queue queue, int timeout_ms, rs2_frame output_frame, rs2_error error)`
`static void`	`rs2_update_firmware_cpp(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback callback, PointerPointer error)` Update device to the provided firmware, the device must be extendable to RS2_EXTENSION_UPDATABLE.
`static void`	`rs2_update_firmware_cpp(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback callback, rs2_error error)`
`static void`	`rs2_update_firmware_unsigned_cpp(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback callback, int update_mode, PointerPointer error)` Update device to the provided firmware by writing raw data directly to the flash, this command can be executed only on unlocked camera.
`static void`	`rs2_update_firmware_unsigned_cpp(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback callback, int update_mode, rs2_error error)`
`static void`	`rs2_update_firmware_unsigned(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback_ptr callback, Pointer client_data, int update_mode, PointerPointer error)` Update device to the provided firmware by writing raw data directly to the flash, this command can be executed only on unlocked camera.
`static void`	`rs2_update_firmware_unsigned(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback_ptr callback, Pointer client_data, int update_mode, rs2_error error)`
`static void`	`rs2_update_firmware(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback_ptr callback, Pointer client_data, PointerPointer error)` Update device to the provided firmware, the device must be extendable to RS2_EXTENSION_UPDATABLE.
`static void`	`rs2_update_firmware(rs2_device device, Pointer fw_image, int fw_image_size, rs2_update_progress_callback_ptr callback, Pointer client_data, rs2_error error)`
`static rs2_frame`	`rs2_wait_for_frame(rs2_frame_queue queue, int timeout_ms, PointerPointer error)` wait until new frame becomes available in the queue and dequeue it
`static rs2_frame`	`rs2_wait_for_frame(rs2_frame_queue queue, int timeout_ms, rs2_error error)`
`static void`	`rs2_write_calibration(rs2_device device, PointerPointer e)` Write calibration to device's EEPROM
`static void`	`rs2_write_calibration(rs2_device device, rs2_error e)`

Methods inherited from class org.bytedeco.librealsense2.presets.realsense2
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- RS2_NOTIFICATION_CATEGORY_FRAMES_TIMEOUT
```
public static final int RS2_NOTIFICATION_CATEGORY_FRAMES_TIMEOUT
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_NOTIFICATION_CATEGORY_FRAME_CORRUPTED
```
public static final int RS2_NOTIFICATION_CATEGORY_FRAME_CORRUPTED
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_NOTIFICATION_CATEGORY_HARDWARE_ERROR
```
public static final int RS2_NOTIFICATION_CATEGORY_HARDWARE_ERROR
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_NOTIFICATION_CATEGORY_HARDWARE_EVENT
```
public static final int RS2_NOTIFICATION_CATEGORY_HARDWARE_EVENT
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_NOTIFICATION_CATEGORY_UNKNOWN_ERROR
```
public static final int RS2_NOTIFICATION_CATEGORY_UNKNOWN_ERROR
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_NOTIFICATION_CATEGORY_FIRMWARE_UPDATE_RECOMMENDED
```
public static final int RS2_NOTIFICATION_CATEGORY_FIRMWARE_UPDATE_RECOMMENDED
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_NOTIFICATION_CATEGORY_POSE_RELOCALIZATION
```
public static final int RS2_NOTIFICATION_CATEGORY_POSE_RELOCALIZATION
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_NOTIFICATION_CATEGORY_COUNT
```
public static final int RS2_NOTIFICATION_CATEGORY_COUNT
```
  enum rs2_notification_category
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_UNKNOWN
```
public static final int RS2_EXCEPTION_TYPE_UNKNOWN
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_CAMERA_DISCONNECTED
```
public static final int RS2_EXCEPTION_TYPE_CAMERA_DISCONNECTED
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_BACKEND
```
public static final int RS2_EXCEPTION_TYPE_BACKEND
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_INVALID_VALUE
```
public static final int RS2_EXCEPTION_TYPE_INVALID_VALUE
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_WRONG_API_CALL_SEQUENCE
```
public static final int RS2_EXCEPTION_TYPE_WRONG_API_CALL_SEQUENCE
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_NOT_IMPLEMENTED
```
public static final int RS2_EXCEPTION_TYPE_NOT_IMPLEMENTED
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_DEVICE_IN_RECOVERY_MODE
```
public static final int RS2_EXCEPTION_TYPE_DEVICE_IN_RECOVERY_MODE
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_IO
```
public static final int RS2_EXCEPTION_TYPE_IO
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_EXCEPTION_TYPE_COUNT
```
public static final int RS2_EXCEPTION_TYPE_COUNT
```
  enum rs2_exception_type
  
  See Also:
  
  Constant Field Values
- RS2_DISTORTION_NONE
```
public static final int RS2_DISTORTION_NONE
```
  enum rs2_distortion
  
  See Also:
  
  Constant Field Values
- RS2_DISTORTION_MODIFIED_BROWN_CONRADY
```
public static final int RS2_DISTORTION_MODIFIED_BROWN_CONRADY
```
  enum rs2_distortion
  
  See Also:
  
  Constant Field Values
- RS2_DISTORTION_INVERSE_BROWN_CONRADY
```
public static final int RS2_DISTORTION_INVERSE_BROWN_CONRADY
```
  enum rs2_distortion
  
  See Also:
  
  Constant Field Values
- RS2_DISTORTION_FTHETA
```
public static final int RS2_DISTORTION_FTHETA
```
  enum rs2_distortion
  
  See Also:
  
  Constant Field Values
- RS2_DISTORTION_BROWN_CONRADY
```
public static final int RS2_DISTORTION_BROWN_CONRADY
```
  enum rs2_distortion
  
  See Also:
  
  Constant Field Values
- RS2_DISTORTION_KANNALA_BRANDT4
```
public static final int RS2_DISTORTION_KANNALA_BRANDT4
```
  enum rs2_distortion
  
  See Also:
  
  Constant Field Values
- RS2_DISTORTION_COUNT
```
public static final int RS2_DISTORTION_COUNT
```
  enum rs2_distortion
  
  See Also:
  
  Constant Field Values
- RS2_DSM_CORRECTION_NONE
```
public static final int RS2_DSM_CORRECTION_NONE
```
  enum rs2_dsm_correction_model
  
  See Also:
  
  Constant Field Values
- RS2_DSM_CORRECTION_AOT
```
public static final int RS2_DSM_CORRECTION_AOT
```
  enum rs2_dsm_correction_model
  
  See Also:
  
  Constant Field Values
- RS2_DSM_CORRECTION_TOA
```
public static final int RS2_DSM_CORRECTION_TOA
```
  enum rs2_dsm_correction_model
  
  See Also:
  
  Constant Field Values
- RS2_DSM_CORRECTION_COUNT
```
public static final int RS2_DSM_CORRECTION_COUNT
```
  enum rs2_dsm_correction_model
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_DEBUG
```
public static final int RS2_LOG_SEVERITY_DEBUG
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_INFO
```
public static final int RS2_LOG_SEVERITY_INFO
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_WARN
```
public static final int RS2_LOG_SEVERITY_WARN
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_ERROR
```
public static final int RS2_LOG_SEVERITY_ERROR
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_FATAL
```
public static final int RS2_LOG_SEVERITY_FATAL
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_NONE
```
public static final int RS2_LOG_SEVERITY_NONE
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_COUNT
```
public static final int RS2_LOG_SEVERITY_COUNT
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_LOG_SEVERITY_ALL
```
public static final int RS2_LOG_SEVERITY_ALL
```
  enum rs2_log_severity
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_UNKNOWN
```
public static final int RS2_EXTENSION_UNKNOWN
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DEBUG
```
public static final int RS2_EXTENSION_DEBUG
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_INFO
```
public static final int RS2_EXTENSION_INFO
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_MOTION
```
public static final int RS2_EXTENSION_MOTION
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_OPTIONS
```
public static final int RS2_EXTENSION_OPTIONS
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_VIDEO
```
public static final int RS2_EXTENSION_VIDEO
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_ROI
```
public static final int RS2_EXTENSION_ROI
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DEPTH_SENSOR
```
public static final int RS2_EXTENSION_DEPTH_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_VIDEO_FRAME
```
public static final int RS2_EXTENSION_VIDEO_FRAME
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_MOTION_FRAME
```
public static final int RS2_EXTENSION_MOTION_FRAME
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_COMPOSITE_FRAME
```
public static final int RS2_EXTENSION_COMPOSITE_FRAME
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_POINTS
```
public static final int RS2_EXTENSION_POINTS
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DEPTH_FRAME
```
public static final int RS2_EXTENSION_DEPTH_FRAME
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_ADVANCED_MODE
```
public static final int RS2_EXTENSION_ADVANCED_MODE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_RECORD
```
public static final int RS2_EXTENSION_RECORD
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_VIDEO_PROFILE
```
public static final int RS2_EXTENSION_VIDEO_PROFILE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_PLAYBACK
```
public static final int RS2_EXTENSION_PLAYBACK
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DEPTH_STEREO_SENSOR
```
public static final int RS2_EXTENSION_DEPTH_STEREO_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DISPARITY_FRAME
```
public static final int RS2_EXTENSION_DISPARITY_FRAME
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_MOTION_PROFILE
```
public static final int RS2_EXTENSION_MOTION_PROFILE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_POSE_FRAME
```
public static final int RS2_EXTENSION_POSE_FRAME
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_POSE_PROFILE
```
public static final int RS2_EXTENSION_POSE_PROFILE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_TM2
```
public static final int RS2_EXTENSION_TM2
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_SOFTWARE_DEVICE
```
public static final int RS2_EXTENSION_SOFTWARE_DEVICE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_SOFTWARE_SENSOR
```
public static final int RS2_EXTENSION_SOFTWARE_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DECIMATION_FILTER
```
public static final int RS2_EXTENSION_DECIMATION_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_THRESHOLD_FILTER
```
public static final int RS2_EXTENSION_THRESHOLD_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DISPARITY_FILTER
```
public static final int RS2_EXTENSION_DISPARITY_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_SPATIAL_FILTER
```
public static final int RS2_EXTENSION_SPATIAL_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_TEMPORAL_FILTER
```
public static final int RS2_EXTENSION_TEMPORAL_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_HOLE_FILLING_FILTER
```
public static final int RS2_EXTENSION_HOLE_FILLING_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_ZERO_ORDER_FILTER
```
public static final int RS2_EXTENSION_ZERO_ORDER_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_RECOMMENDED_FILTERS
```
public static final int RS2_EXTENSION_RECOMMENDED_FILTERS
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_POSE
```
public static final int RS2_EXTENSION_POSE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_POSE_SENSOR
```
public static final int RS2_EXTENSION_POSE_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_WHEEL_ODOMETER
```
public static final int RS2_EXTENSION_WHEEL_ODOMETER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_GLOBAL_TIMER
```
public static final int RS2_EXTENSION_GLOBAL_TIMER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_UPDATABLE
```
public static final int RS2_EXTENSION_UPDATABLE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_UPDATE_DEVICE
```
public static final int RS2_EXTENSION_UPDATE_DEVICE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_L500_DEPTH_SENSOR
```
public static final int RS2_EXTENSION_L500_DEPTH_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_TM2_SENSOR
```
public static final int RS2_EXTENSION_TM2_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_AUTO_CALIBRATED_DEVICE
```
public static final int RS2_EXTENSION_AUTO_CALIBRATED_DEVICE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_COLOR_SENSOR
```
public static final int RS2_EXTENSION_COLOR_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_MOTION_SENSOR
```
public static final int RS2_EXTENSION_MOTION_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_FISHEYE_SENSOR
```
public static final int RS2_EXTENSION_FISHEYE_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DEPTH_HUFFMAN_DECODER
```
public static final int RS2_EXTENSION_DEPTH_HUFFMAN_DECODER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_SERIALIZABLE
```
public static final int RS2_EXTENSION_SERIALIZABLE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_FW_LOGGER
```
public static final int RS2_EXTENSION_FW_LOGGER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_AUTO_CALIBRATION_FILTER
```
public static final int RS2_EXTENSION_AUTO_CALIBRATION_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DEVICE_CALIBRATION
```
public static final int RS2_EXTENSION_DEVICE_CALIBRATION
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_CALIBRATED_SENSOR
```
public static final int RS2_EXTENSION_CALIBRATED_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_HDR_MERGE
```
public static final int RS2_EXTENSION_HDR_MERGE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_SEQUENCE_ID_FILTER
```
public static final int RS2_EXTENSION_SEQUENCE_ID_FILTER
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_MAX_USABLE_RANGE_SENSOR
```
public static final int RS2_EXTENSION_MAX_USABLE_RANGE_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_DEBUG_STREAM_SENSOR
```
public static final int RS2_EXTENSION_DEBUG_STREAM_SENSOR
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_CALIBRATION_CHANGE_DEVICE
```
public static final int RS2_EXTENSION_CALIBRATION_CHANGE_DEVICE
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_EXTENSION_COUNT
```
public static final int RS2_EXTENSION_COUNT
```
  enum rs2_extension
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_DI
```
public static final int RS2_MATCHER_DI
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_DI_C
```
public static final int RS2_MATCHER_DI_C
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_DLR_C
```
public static final int RS2_MATCHER_DLR_C
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_DLR
```
public static final int RS2_MATCHER_DLR
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_DIC
```
public static final int RS2_MATCHER_DIC
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_DIC_C
```
public static final int RS2_MATCHER_DIC_C
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_DEFAULT
```
public static final int RS2_MATCHER_DEFAULT
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_MATCHER_COUNT
```
public static final int RS2_MATCHER_COUNT
```
  enum rs2_matchers
  
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_ANY
```
public static final int RS2_PRODUCT_LINE_ANY
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_ANY_INTEL
```
public static final int RS2_PRODUCT_LINE_ANY_INTEL
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_NON_INTEL
```
public static final int RS2_PRODUCT_LINE_NON_INTEL
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_D400
```
public static final int RS2_PRODUCT_LINE_D400
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_SR300
```
public static final int RS2_PRODUCT_LINE_SR300
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_L500
```
public static final int RS2_PRODUCT_LINE_L500
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_T200
```
public static final int RS2_PRODUCT_LINE_T200
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_DEPTH
```
public static final int RS2_PRODUCT_LINE_DEPTH
```
  See Also:
  
  Constant Field Values
- RS2_PRODUCT_LINE_TRACKING
```
public static final int RS2_PRODUCT_LINE_TRACKING
```
  See Also:
  
  Constant Field Values
- RS2_UNSIGNED_UPDATE_MODE_UPDATE
```
public static final int RS2_UNSIGNED_UPDATE_MODE_UPDATE
```
  See Also:
  
  Constant Field Values
- RS2_UNSIGNED_UPDATE_MODE_READ_ONLY
```
public static final int RS2_UNSIGNED_UPDATE_MODE_READ_ONLY
```
  See Also:
  
  Constant Field Values
- RS2_UNSIGNED_UPDATE_MODE_FULL
```
public static final int RS2_UNSIGNED_UPDATE_MODE_FULL
```
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_AUTO_DEPTH_TO_RGB
```
public static final int RS2_CALIBRATION_AUTO_DEPTH_TO_RGB
```
  enum rs2_calibration_type
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_MANUAL_DEPTH_TO_RGB
```
public static final int RS2_CALIBRATION_MANUAL_DEPTH_TO_RGB
```
  enum rs2_calibration_type
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_THERMAL
```
public static final int RS2_CALIBRATION_THERMAL
```
  enum rs2_calibration_type
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_TYPE_COUNT
```
public static final int RS2_CALIBRATION_TYPE_COUNT
```
  enum rs2_calibration_type
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_TRIGGERED
```
public static final int RS2_CALIBRATION_TRIGGERED
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_SPECIAL_FRAME
```
public static final int RS2_CALIBRATION_SPECIAL_FRAME
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_STARTED
```
public static final int RS2_CALIBRATION_STARTED
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_NOT_NEEDED
```
public static final int RS2_CALIBRATION_NOT_NEEDED
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_SUCCESSFUL
```
public static final int RS2_CALIBRATION_SUCCESSFUL
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_RETRY
```
public static final int RS2_CALIBRATION_RETRY
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_FAILED
```
public static final int RS2_CALIBRATION_FAILED
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_SCENE_INVALID
```
public static final int RS2_CALIBRATION_SCENE_INVALID
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_BAD_RESULT
```
public static final int RS2_CALIBRATION_BAD_RESULT
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_BAD_CONDITIONS
```
public static final int RS2_CALIBRATION_BAD_CONDITIONS
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_STATUS_FIRST
```
public static final int RS2_CALIBRATION_STATUS_FIRST
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_STATUS_LAST
```
public static final int RS2_CALIBRATION_STATUS_LAST
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_CALIBRATION_STATUS_COUNT
```
public static final int RS2_CALIBRATION_STATUS_COUNT
```
  enum rs2_calibration_status
  
  See Also:
  
  Constant Field Values
- RS2_TIMESTAMP_DOMAIN_HARDWARE_CLOCK
```
public static final int RS2_TIMESTAMP_DOMAIN_HARDWARE_CLOCK
```
  enum rs2_timestamp_domain
  
  See Also:
  
  Constant Field Values
- RS2_TIMESTAMP_DOMAIN_SYSTEM_TIME
```
public static final int RS2_TIMESTAMP_DOMAIN_SYSTEM_TIME
```
  enum rs2_timestamp_domain
  
  See Also:
  
  Constant Field Values
- RS2_TIMESTAMP_DOMAIN_GLOBAL_TIME
```
public static final int RS2_TIMESTAMP_DOMAIN_GLOBAL_TIME
```
  enum rs2_timestamp_domain
  
  See Also:
  
  Constant Field Values
- RS2_TIMESTAMP_DOMAIN_COUNT
```
public static final int RS2_TIMESTAMP_DOMAIN_COUNT
```
  enum rs2_timestamp_domain
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_FRAME_COUNTER
```
public static final int RS2_FRAME_METADATA_FRAME_COUNTER
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_FRAME_TIMESTAMP
```
public static final int RS2_FRAME_METADATA_FRAME_TIMESTAMP
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_SENSOR_TIMESTAMP
```
public static final int RS2_FRAME_METADATA_SENSOR_TIMESTAMP
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_ACTUAL_EXPOSURE
```
public static final int RS2_FRAME_METADATA_ACTUAL_EXPOSURE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_GAIN_LEVEL
```
public static final int RS2_FRAME_METADATA_GAIN_LEVEL
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_AUTO_EXPOSURE
```
public static final int RS2_FRAME_METADATA_AUTO_EXPOSURE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_WHITE_BALANCE
```
public static final int RS2_FRAME_METADATA_WHITE_BALANCE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_TIME_OF_ARRIVAL
```
public static final int RS2_FRAME_METADATA_TIME_OF_ARRIVAL
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_TEMPERATURE
```
public static final int RS2_FRAME_METADATA_TEMPERATURE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_BACKEND_TIMESTAMP
```
public static final int RS2_FRAME_METADATA_BACKEND_TIMESTAMP
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_ACTUAL_FPS
```
public static final int RS2_FRAME_METADATA_ACTUAL_FPS
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_FRAME_LASER_POWER
```
public static final int RS2_FRAME_METADATA_FRAME_LASER_POWER
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_FRAME_LASER_POWER_MODE
```
public static final int RS2_FRAME_METADATA_FRAME_LASER_POWER_MODE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_EXPOSURE_PRIORITY
```
public static final int RS2_FRAME_METADATA_EXPOSURE_PRIORITY
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_EXPOSURE_ROI_LEFT
```
public static final int RS2_FRAME_METADATA_EXPOSURE_ROI_LEFT
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_EXPOSURE_ROI_RIGHT
```
public static final int RS2_FRAME_METADATA_EXPOSURE_ROI_RIGHT
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_EXPOSURE_ROI_TOP
```
public static final int RS2_FRAME_METADATA_EXPOSURE_ROI_TOP
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_EXPOSURE_ROI_BOTTOM
```
public static final int RS2_FRAME_METADATA_EXPOSURE_ROI_BOTTOM
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_BRIGHTNESS
```
public static final int RS2_FRAME_METADATA_BRIGHTNESS
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_CONTRAST
```
public static final int RS2_FRAME_METADATA_CONTRAST
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_SATURATION
```
public static final int RS2_FRAME_METADATA_SATURATION
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_SHARPNESS
```
public static final int RS2_FRAME_METADATA_SHARPNESS
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_AUTO_WHITE_BALANCE_TEMPERATURE
```
public static final int RS2_FRAME_METADATA_AUTO_WHITE_BALANCE_TEMPERATURE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_BACKLIGHT_COMPENSATION
```
public static final int RS2_FRAME_METADATA_BACKLIGHT_COMPENSATION
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_HUE
```
public static final int RS2_FRAME_METADATA_HUE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_GAMMA
```
public static final int RS2_FRAME_METADATA_GAMMA
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_MANUAL_WHITE_BALANCE
```
public static final int RS2_FRAME_METADATA_MANUAL_WHITE_BALANCE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_POWER_LINE_FREQUENCY
```
public static final int RS2_FRAME_METADATA_POWER_LINE_FREQUENCY
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_LOW_LIGHT_COMPENSATION
```
public static final int RS2_FRAME_METADATA_LOW_LIGHT_COMPENSATION
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_FRAME_EMITTER_MODE
```
public static final int RS2_FRAME_METADATA_FRAME_EMITTER_MODE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_FRAME_LED_POWER
```
public static final int RS2_FRAME_METADATA_FRAME_LED_POWER
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_RAW_FRAME_SIZE
```
public static final int RS2_FRAME_METADATA_RAW_FRAME_SIZE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_GPIO_INPUT_DATA
```
public static final int RS2_FRAME_METADATA_GPIO_INPUT_DATA
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_SEQUENCE_NAME
```
public static final int RS2_FRAME_METADATA_SEQUENCE_NAME
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_SEQUENCE_ID
```
public static final int RS2_FRAME_METADATA_SEQUENCE_ID
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_SEQUENCE_SIZE
```
public static final int RS2_FRAME_METADATA_SEQUENCE_SIZE
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_TRIGGER
```
public static final int RS2_FRAME_METADATA_TRIGGER
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_PRESET
```
public static final int RS2_FRAME_METADATA_PRESET
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_INPUT_WIDTH
```
public static final int RS2_FRAME_METADATA_INPUT_WIDTH
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_INPUT_HEIGHT
```
public static final int RS2_FRAME_METADATA_INPUT_HEIGHT
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_SUB_PRESET_INFO
```
public static final int RS2_FRAME_METADATA_SUB_PRESET_INFO
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_CALIB_INFO
```
public static final int RS2_FRAME_METADATA_CALIB_INFO
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_CRC
```
public static final int RS2_FRAME_METADATA_CRC
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_FRAME_METADATA_COUNT
```
public static final int RS2_FRAME_METADATA_COUNT
```
  enum rs2_frame_metadata_value
  
  See Also:
  
  Constant Field Values
- RS2_CALIB_TARGET_RECT_GAUSSIAN_DOT_VERTICES
```
public static final int RS2_CALIB_TARGET_RECT_GAUSSIAN_DOT_VERTICES
```
  enum rs2_calib_target_type
  
  See Also:
  
  Constant Field Values
- RS2_CALIB_TARGET_ROI_RECT_GAUSSIAN_DOT_VERTICES
```
public static final int RS2_CALIB_TARGET_ROI_RECT_GAUSSIAN_DOT_VERTICES
```
  enum rs2_calib_target_type
  
  See Also:
  
  Constant Field Values
- RS2_CALIB_TARGET_POS_GAUSSIAN_DOT_VERTICES
```
public static final int RS2_CALIB_TARGET_POS_GAUSSIAN_DOT_VERTICES
```
  enum rs2_calib_target_type
  
  See Also:
  
  Constant Field Values
- RS2_CALIB_TARGET_COUNT
```
public static final int RS2_CALIB_TARGET_COUNT
```
  enum rs2_calib_target_type
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_BACKLIGHT_COMPENSATION
```
public static final int RS2_OPTION_BACKLIGHT_COMPENSATION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_BRIGHTNESS
```
public static final int RS2_OPTION_BRIGHTNESS
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_CONTRAST
```
public static final int RS2_OPTION_CONTRAST
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_EXPOSURE
```
public static final int RS2_OPTION_EXPOSURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_GAIN
```
public static final int RS2_OPTION_GAIN
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_GAMMA
```
public static final int RS2_OPTION_GAMMA
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_HUE
```
public static final int RS2_OPTION_HUE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_SATURATION
```
public static final int RS2_OPTION_SATURATION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_SHARPNESS
```
public static final int RS2_OPTION_SHARPNESS
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_WHITE_BALANCE
```
public static final int RS2_OPTION_WHITE_BALANCE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_AUTO_EXPOSURE
```
public static final int RS2_OPTION_ENABLE_AUTO_EXPOSURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_AUTO_WHITE_BALANCE
```
public static final int RS2_OPTION_ENABLE_AUTO_WHITE_BALANCE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_VISUAL_PRESET
```
public static final int RS2_OPTION_VISUAL_PRESET
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_LASER_POWER
```
public static final int RS2_OPTION_LASER_POWER
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ACCURACY
```
public static final int RS2_OPTION_ACCURACY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_MOTION_RANGE
```
public static final int RS2_OPTION_MOTION_RANGE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_FILTER_OPTION
```
public static final int RS2_OPTION_FILTER_OPTION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_CONFIDENCE_THRESHOLD
```
public static final int RS2_OPTION_CONFIDENCE_THRESHOLD
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_EMITTER_ENABLED
```
public static final int RS2_OPTION_EMITTER_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_FRAMES_QUEUE_SIZE
```
public static final int RS2_OPTION_FRAMES_QUEUE_SIZE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_TOTAL_FRAME_DROPS
```
public static final int RS2_OPTION_TOTAL_FRAME_DROPS
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_EXPOSURE_MODE
```
public static final int RS2_OPTION_AUTO_EXPOSURE_MODE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_POWER_LINE_FREQUENCY
```
public static final int RS2_OPTION_POWER_LINE_FREQUENCY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ASIC_TEMPERATURE
```
public static final int RS2_OPTION_ASIC_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ERROR_POLLING_ENABLED
```
public static final int RS2_OPTION_ERROR_POLLING_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_PROJECTOR_TEMPERATURE
```
public static final int RS2_OPTION_PROJECTOR_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_OUTPUT_TRIGGER_ENABLED
```
public static final int RS2_OPTION_OUTPUT_TRIGGER_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_MOTION_MODULE_TEMPERATURE
```
public static final int RS2_OPTION_MOTION_MODULE_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_DEPTH_UNITS
```
public static final int RS2_OPTION_DEPTH_UNITS
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_MOTION_CORRECTION
```
public static final int RS2_OPTION_ENABLE_MOTION_CORRECTION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_EXPOSURE_PRIORITY
```
public static final int RS2_OPTION_AUTO_EXPOSURE_PRIORITY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_COLOR_SCHEME
```
public static final int RS2_OPTION_COLOR_SCHEME
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_HISTOGRAM_EQUALIZATION_ENABLED
```
public static final int RS2_OPTION_HISTOGRAM_EQUALIZATION_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_MIN_DISTANCE
```
public static final int RS2_OPTION_MIN_DISTANCE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_MAX_DISTANCE
```
public static final int RS2_OPTION_MAX_DISTANCE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_TEXTURE_SOURCE
```
public static final int RS2_OPTION_TEXTURE_SOURCE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_FILTER_MAGNITUDE
```
public static final int RS2_OPTION_FILTER_MAGNITUDE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_FILTER_SMOOTH_ALPHA
```
public static final int RS2_OPTION_FILTER_SMOOTH_ALPHA
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_FILTER_SMOOTH_DELTA
```
public static final int RS2_OPTION_FILTER_SMOOTH_DELTA
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_HOLES_FILL
```
public static final int RS2_OPTION_HOLES_FILL
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_STEREO_BASELINE
```
public static final int RS2_OPTION_STEREO_BASELINE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_EXPOSURE_CONVERGE_STEP
```
public static final int RS2_OPTION_AUTO_EXPOSURE_CONVERGE_STEP
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_INTER_CAM_SYNC_MODE
```
public static final int RS2_OPTION_INTER_CAM_SYNC_MODE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_STREAM_FILTER
```
public static final int RS2_OPTION_STREAM_FILTER
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_STREAM_FORMAT_FILTER
```
public static final int RS2_OPTION_STREAM_FORMAT_FILTER
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_STREAM_INDEX_FILTER
```
public static final int RS2_OPTION_STREAM_INDEX_FILTER
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_EMITTER_ON_OFF
```
public static final int RS2_OPTION_EMITTER_ON_OFF
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ZERO_ORDER_POINT_X
```
public static final int RS2_OPTION_ZERO_ORDER_POINT_X
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ZERO_ORDER_POINT_Y
```
public static final int RS2_OPTION_ZERO_ORDER_POINT_Y
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_LLD_TEMPERATURE
```
public static final int RS2_OPTION_LLD_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_MC_TEMPERATURE
```
public static final int RS2_OPTION_MC_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_MA_TEMPERATURE
```
public static final int RS2_OPTION_MA_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_HARDWARE_PRESET
```
public static final int RS2_OPTION_HARDWARE_PRESET
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_GLOBAL_TIME_ENABLED
```
public static final int RS2_OPTION_GLOBAL_TIME_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_APD_TEMPERATURE
```
public static final int RS2_OPTION_APD_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_MAPPING
```
public static final int RS2_OPTION_ENABLE_MAPPING
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_RELOCALIZATION
```
public static final int RS2_OPTION_ENABLE_RELOCALIZATION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_POSE_JUMPING
```
public static final int RS2_OPTION_ENABLE_POSE_JUMPING
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_DYNAMIC_CALIBRATION
```
public static final int RS2_OPTION_ENABLE_DYNAMIC_CALIBRATION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_DEPTH_OFFSET
```
public static final int RS2_OPTION_DEPTH_OFFSET
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_LED_POWER
```
public static final int RS2_OPTION_LED_POWER
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ZERO_ORDER_ENABLED
```
public static final int RS2_OPTION_ZERO_ORDER_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_MAP_PRESERVATION
```
public static final int RS2_OPTION_ENABLE_MAP_PRESERVATION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_FREEFALL_DETECTION_ENABLED
```
public static final int RS2_OPTION_FREEFALL_DETECTION_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AVALANCHE_PHOTO_DIODE
```
public static final int RS2_OPTION_AVALANCHE_PHOTO_DIODE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_POST_PROCESSING_SHARPENING
```
public static final int RS2_OPTION_POST_PROCESSING_SHARPENING
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_PRE_PROCESSING_SHARPENING
```
public static final int RS2_OPTION_PRE_PROCESSING_SHARPENING
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_NOISE_FILTERING
```
public static final int RS2_OPTION_NOISE_FILTERING
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_INVALIDATION_BYPASS
```
public static final int RS2_OPTION_INVALIDATION_BYPASS
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AMBIENT_LIGHT
```
public static final int RS2_OPTION_AMBIENT_LIGHT
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_DIGITAL_GAIN
```
public static final int RS2_OPTION_DIGITAL_GAIN
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_SENSOR_MODE
```
public static final int RS2_OPTION_SENSOR_MODE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_EMITTER_ALWAYS_ON
```
public static final int RS2_OPTION_EMITTER_ALWAYS_ON
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_THERMAL_COMPENSATION
```
public static final int RS2_OPTION_THERMAL_COMPENSATION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_TRIGGER_CAMERA_ACCURACY_HEALTH
```
public static final int RS2_OPTION_TRIGGER_CAMERA_ACCURACY_HEALTH
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_RESET_CAMERA_ACCURACY_HEALTH
```
public static final int RS2_OPTION_RESET_CAMERA_ACCURACY_HEALTH
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_HOST_PERFORMANCE
```
public static final int RS2_OPTION_HOST_PERFORMANCE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_HDR_ENABLED
```
public static final int RS2_OPTION_HDR_ENABLED
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_SEQUENCE_NAME
```
public static final int RS2_OPTION_SEQUENCE_NAME
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_SEQUENCE_SIZE
```
public static final int RS2_OPTION_SEQUENCE_SIZE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_SEQUENCE_ID
```
public static final int RS2_OPTION_SEQUENCE_ID
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_HUMIDITY_TEMPERATURE
```
public static final int RS2_OPTION_HUMIDITY_TEMPERATURE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_MAX_USABLE_RANGE
```
public static final int RS2_OPTION_ENABLE_MAX_USABLE_RANGE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ALTERNATE_IR
```
public static final int RS2_OPTION_ALTERNATE_IR
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_NOISE_ESTIMATION
```
public static final int RS2_OPTION_NOISE_ESTIMATION
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_ENABLE_IR_REFLECTIVITY
```
public static final int RS2_OPTION_ENABLE_IR_REFLECTIVITY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_EXPOSURE_LIMIT
```
public static final int RS2_OPTION_AUTO_EXPOSURE_LIMIT
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_GAIN_LIMIT
```
public static final int RS2_OPTION_AUTO_GAIN_LIMIT
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_RX_SENSITIVITY
```
public static final int RS2_OPTION_AUTO_RX_SENSITIVITY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_TRANSMITTER_FREQUENCY
```
public static final int RS2_OPTION_TRANSMITTER_FREQUENCY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_VERTICAL_BINNING
```
public static final int RS2_OPTION_VERTICAL_BINNING
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_RECEIVER_SENSITIVITY
```
public static final int RS2_OPTION_RECEIVER_SENSITIVITY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_EXPOSURE_LIMIT_TOGGLE
```
public static final int RS2_OPTION_AUTO_EXPOSURE_LIMIT_TOGGLE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_AUTO_GAIN_LIMIT_TOGGLE
```
public static final int RS2_OPTION_AUTO_GAIN_LIMIT_TOGGLE
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_EMITTER_FREQUENCY
```
public static final int RS2_OPTION_EMITTER_FREQUENCY
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_OPTION_COUNT
```
public static final int RS2_OPTION_COUNT
```
  enum rs2_option
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_SHORT_RANGE
```
public static final int RS2_SR300_VISUAL_PRESET_SHORT_RANGE
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_LONG_RANGE
```
public static final int RS2_SR300_VISUAL_PRESET_LONG_RANGE
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_BACKGROUND_SEGMENTATION
```
public static final int RS2_SR300_VISUAL_PRESET_BACKGROUND_SEGMENTATION
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_GESTURE_RECOGNITION
```
public static final int RS2_SR300_VISUAL_PRESET_GESTURE_RECOGNITION
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_OBJECT_SCANNING
```
public static final int RS2_SR300_VISUAL_PRESET_OBJECT_SCANNING
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_FACE_ANALYTICS
```
public static final int RS2_SR300_VISUAL_PRESET_FACE_ANALYTICS
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_FACE_LOGIN
```
public static final int RS2_SR300_VISUAL_PRESET_FACE_LOGIN
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_GR_CURSOR
```
public static final int RS2_SR300_VISUAL_PRESET_GR_CURSOR
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_DEFAULT
```
public static final int RS2_SR300_VISUAL_PRESET_DEFAULT
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_MID_RANGE
```
public static final int RS2_SR300_VISUAL_PRESET_MID_RANGE
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_IR_ONLY
```
public static final int RS2_SR300_VISUAL_PRESET_IR_ONLY
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SR300_VISUAL_PRESET_COUNT
```
public static final int RS2_SR300_VISUAL_PRESET_COUNT
```
  enum rs2_sr300_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_CUSTOM
```
public static final int RS2_RS400_VISUAL_PRESET_CUSTOM
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_DEFAULT
```
public static final int RS2_RS400_VISUAL_PRESET_DEFAULT
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_HAND
```
public static final int RS2_RS400_VISUAL_PRESET_HAND
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_HIGH_ACCURACY
```
public static final int RS2_RS400_VISUAL_PRESET_HIGH_ACCURACY
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_HIGH_DENSITY
```
public static final int RS2_RS400_VISUAL_PRESET_HIGH_DENSITY
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_MEDIUM_DENSITY
```
public static final int RS2_RS400_VISUAL_PRESET_MEDIUM_DENSITY
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_REMOVE_IR_PATTERN
```
public static final int RS2_RS400_VISUAL_PRESET_REMOVE_IR_PATTERN
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_RS400_VISUAL_PRESET_COUNT
```
public static final int RS2_RS400_VISUAL_PRESET_COUNT
```
  enum rs2_rs400_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_CUSTOM
```
public static final int RS2_L500_VISUAL_PRESET_CUSTOM
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_DEFAULT
```
public static final int RS2_L500_VISUAL_PRESET_DEFAULT
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_NO_AMBIENT
```
public static final int RS2_L500_VISUAL_PRESET_NO_AMBIENT
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_LOW_AMBIENT
```
public static final int RS2_L500_VISUAL_PRESET_LOW_AMBIENT
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_MAX_RANGE
```
public static final int RS2_L500_VISUAL_PRESET_MAX_RANGE
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_SHORT_RANGE
```
public static final int RS2_L500_VISUAL_PRESET_SHORT_RANGE
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_AUTOMATIC
```
public static final int RS2_L500_VISUAL_PRESET_AUTOMATIC
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_L500_VISUAL_PRESET_COUNT
```
public static final int RS2_L500_VISUAL_PRESET_COUNT
```
  enum rs2_l500_visual_preset
  
  See Also:
  
  Constant Field Values
- RS2_SENSOR_MODE_VGA
```
public static final int RS2_SENSOR_MODE_VGA
```
  enum rs2_sensor_mode
  
  See Also:
  
  Constant Field Values
- RS2_SENSOR_MODE_XGA
```
public static final int RS2_SENSOR_MODE_XGA
```
  enum rs2_sensor_mode
  
  See Also:
  
  Constant Field Values
- RS2_SENSOR_MODE_QVGA
```
public static final int RS2_SENSOR_MODE_QVGA
```
  enum rs2_sensor_mode
  
  See Also:
  
  Constant Field Values
- RS2_SENSOR_MODE_COUNT
```
public static final int RS2_SENSOR_MODE_COUNT
```
  enum rs2_sensor_mode
  
  See Also:
  
  Constant Field Values
- RS2_AMBIENT_LIGHT_NO_AMBIENT
```
public static final int RS2_AMBIENT_LIGHT_NO_AMBIENT
```
  enum rs2_ambient_light
  
  See Also:
  
  Constant Field Values
- RS2_AMBIENT_LIGHT_LOW_AMBIENT
```
public static final int RS2_AMBIENT_LIGHT_LOW_AMBIENT
```
  enum rs2_ambient_light
  
  See Also:
  
  Constant Field Values
- RS2_DIGITAL_GAIN_AUTO
```
public static final int RS2_DIGITAL_GAIN_AUTO
```
  enum rs2_digital_gain
  
  See Also:
  
  Constant Field Values
- RS2_DIGITAL_GAIN_HIGH
```
public static final int RS2_DIGITAL_GAIN_HIGH
```
  enum rs2_digital_gain
  
  See Also:
  
  Constant Field Values
- RS2_DIGITAL_GAIN_LOW
```
public static final int RS2_DIGITAL_GAIN_LOW
```
  enum rs2_digital_gain
  
  See Also:
  
  Constant Field Values
- RS2_HOST_PERF_DEFAULT
```
public static final int RS2_HOST_PERF_DEFAULT
```
  enum rs2_host_perf_mode
  
  See Also:
  
  Constant Field Values
- RS2_HOST_PERF_LOW
```
public static final int RS2_HOST_PERF_LOW
```
  enum rs2_host_perf_mode
  
  See Also:
  
  Constant Field Values
- RS2_HOST_PERF_HIGH
```
public static final int RS2_HOST_PERF_HIGH
```
  enum rs2_host_perf_mode
  
  See Also:
  
  Constant Field Values
- RS2_HOST_PERF_COUNT
```
public static final int RS2_HOST_PERF_COUNT
```
  enum rs2_host_perf_mode
  
  See Also:
  
  Constant Field Values
- RS2_EMITTER_FREQUENCY_57_KHZ
```
public static final int RS2_EMITTER_FREQUENCY_57_KHZ
```
  enum rs2_emitter_frequency_mode
  
  See Also:
  
  Constant Field Values
- RS2_EMITTER_FREQUENCY_91_KHZ
```
public static final int RS2_EMITTER_FREQUENCY_91_KHZ
```
  enum rs2_emitter_frequency_mode
  
  See Also:
  
  Constant Field Values
- RS2_EMITTER_FREQUENCY_COUNT
```
public static final int RS2_EMITTER_FREQUENCY_COUNT
```
  enum rs2_emitter_frequency_mode
  
  See Also:
  
  Constant Field Values
- RS2_PLAYBACK_STATUS_UNKNOWN
```
public static final int RS2_PLAYBACK_STATUS_UNKNOWN
```
  enum rs2_playback_status
  
  See Also:
  
  Constant Field Values
- RS2_PLAYBACK_STATUS_PLAYING
```
public static final int RS2_PLAYBACK_STATUS_PLAYING
```
  enum rs2_playback_status
  
  See Also:
  
  Constant Field Values
- RS2_PLAYBACK_STATUS_PAUSED
```
public static final int RS2_PLAYBACK_STATUS_PAUSED
```
  enum rs2_playback_status
  
  See Also:
  
  Constant Field Values
- RS2_PLAYBACK_STATUS_STOPPED
```
public static final int RS2_PLAYBACK_STATUS_STOPPED
```
  enum rs2_playback_status
  
  See Also:
  
  Constant Field Values
- RS2_PLAYBACK_STATUS_COUNT
```
public static final int RS2_PLAYBACK_STATUS_COUNT
```
  enum rs2_playback_status
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_NAME
```
public static final int RS2_CAMERA_INFO_NAME
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_SERIAL_NUMBER
```
public static final int RS2_CAMERA_INFO_SERIAL_NUMBER
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_FIRMWARE_VERSION
```
public static final int RS2_CAMERA_INFO_FIRMWARE_VERSION
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_RECOMMENDED_FIRMWARE_VERSION
```
public static final int RS2_CAMERA_INFO_RECOMMENDED_FIRMWARE_VERSION
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_PHYSICAL_PORT
```
public static final int RS2_CAMERA_INFO_PHYSICAL_PORT
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_DEBUG_OP_CODE
```
public static final int RS2_CAMERA_INFO_DEBUG_OP_CODE
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_ADVANCED_MODE
```
public static final int RS2_CAMERA_INFO_ADVANCED_MODE
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_PRODUCT_ID
```
public static final int RS2_CAMERA_INFO_PRODUCT_ID
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_CAMERA_LOCKED
```
public static final int RS2_CAMERA_INFO_CAMERA_LOCKED
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_USB_TYPE_DESCRIPTOR
```
public static final int RS2_CAMERA_INFO_USB_TYPE_DESCRIPTOR
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_PRODUCT_LINE
```
public static final int RS2_CAMERA_INFO_PRODUCT_LINE
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_ASIC_SERIAL_NUMBER
```
public static final int RS2_CAMERA_INFO_ASIC_SERIAL_NUMBER
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_FIRMWARE_UPDATE_ID
```
public static final int RS2_CAMERA_INFO_FIRMWARE_UPDATE_ID
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_IP_ADDRESS
```
public static final int RS2_CAMERA_INFO_IP_ADDRESS
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_CAMERA_INFO_COUNT
```
public static final int RS2_CAMERA_INFO_COUNT
```
  enum rs2_camera_info
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_ANY
```
public static final int RS2_STREAM_ANY
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_DEPTH
```
public static final int RS2_STREAM_DEPTH
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_COLOR
```
public static final int RS2_STREAM_COLOR
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_INFRARED
```
public static final int RS2_STREAM_INFRARED
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_FISHEYE
```
public static final int RS2_STREAM_FISHEYE
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_GYRO
```
public static final int RS2_STREAM_GYRO
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_ACCEL
```
public static final int RS2_STREAM_ACCEL
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_GPIO
```
public static final int RS2_STREAM_GPIO
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_POSE
```
public static final int RS2_STREAM_POSE
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_CONFIDENCE
```
public static final int RS2_STREAM_CONFIDENCE
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_STREAM_COUNT
```
public static final int RS2_STREAM_COUNT
```
  enum rs2_stream
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_ANY
```
public static final int RS2_FORMAT_ANY
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Z16
```
public static final int RS2_FORMAT_Z16
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_DISPARITY16
```
public static final int RS2_FORMAT_DISPARITY16
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_XYZ32F
```
public static final int RS2_FORMAT_XYZ32F
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_YUYV
```
public static final int RS2_FORMAT_YUYV
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_RGB8
```
public static final int RS2_FORMAT_RGB8
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_BGR8
```
public static final int RS2_FORMAT_BGR8
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_RGBA8
```
public static final int RS2_FORMAT_RGBA8
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_BGRA8
```
public static final int RS2_FORMAT_BGRA8
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Y8
```
public static final int RS2_FORMAT_Y8
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Y16
```
public static final int RS2_FORMAT_Y16
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_RAW10
```
public static final int RS2_FORMAT_RAW10
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_RAW16
```
public static final int RS2_FORMAT_RAW16
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_RAW8
```
public static final int RS2_FORMAT_RAW8
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_UYVY
```
public static final int RS2_FORMAT_UYVY
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_MOTION_RAW
```
public static final int RS2_FORMAT_MOTION_RAW
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_MOTION_XYZ32F
```
public static final int RS2_FORMAT_MOTION_XYZ32F
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_GPIO_RAW
```
public static final int RS2_FORMAT_GPIO_RAW
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_6DOF
```
public static final int RS2_FORMAT_6DOF
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_DISPARITY32
```
public static final int RS2_FORMAT_DISPARITY32
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Y10BPACK
```
public static final int RS2_FORMAT_Y10BPACK
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_DISTANCE
```
public static final int RS2_FORMAT_DISTANCE
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_MJPEG
```
public static final int RS2_FORMAT_MJPEG
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Y8I
```
public static final int RS2_FORMAT_Y8I
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Y12I
```
public static final int RS2_FORMAT_Y12I
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_INZI
```
public static final int RS2_FORMAT_INZI
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_INVI
```
public static final int RS2_FORMAT_INVI
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_W10
```
public static final int RS2_FORMAT_W10
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Z16H
```
public static final int RS2_FORMAT_Z16H
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_FG
```
public static final int RS2_FORMAT_FG
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Y411
```
public static final int RS2_FORMAT_Y411
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_Y16I
```
public static final int RS2_FORMAT_Y16I
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_FORMAT_COUNT
```
public static final int RS2_FORMAT_COUNT
```
  enum rs2_format
  
  See Also:
  
  Constant Field Values
- RS2_DEFAULT_TIMEOUT
```
public static final int RS2_DEFAULT_TIMEOUT
```
  \file rs_pipeline.h \brief Exposes RealSense processing-block functionality for C compilers
  
  See Also:
  
  Constant Field Values
- RS2_API_MAJOR_VERSION
```
public static final int RS2_API_MAJOR_VERSION
```
  \file rs.h \brief Exposes librealsense functionality for C compilers
  
  See Also:
  
  Constant Field Values
- RS2_API_MINOR_VERSION
```
public static final int RS2_API_MINOR_VERSION
```
  See Also:
  
  Constant Field Values
- RS2_API_PATCH_VERSION
```
public static final int RS2_API_PATCH_VERSION
```
  See Also:
  
  Constant Field Values
- RS2_API_BUILD_VERSION
```
public static final int RS2_API_BUILD_VERSION
```
  See Also:
  
  Constant Field Values
- RS2_API_VERSION
```
public static final int RS2_API_VERSION
```
  See Also:
  
  Constant Field Values
- RS2_API_VERSION_STR
```
public static final String RS2_API_VERSION_STR
```
- RS2_API_FULL_VERSION_STR
```
public static final String RS2_API_FULL_VERSION_STR
```

Constructor Detail
- realsense2
```
public realsense2()
```

Method Detail

rs2_notification_category_to_string

@Cast(value="const char*")
public static BytePointer rs2_notification_category_to_string(@Cast(value="rs2_notification_category")
                                                                                          int category)

rs2_exception_type_to_string

@Cast(value="const char*")
public static BytePointer rs2_exception_type_to_string(@Cast(value="rs2_exception_type")
                                                                                   int type)

rs2_distortion_to_string

@Cast(value="const char*")
public static BytePointer rs2_distortion_to_string(@Cast(value="rs2_distortion")
                                                                               int distortion)

rs2_log_severity_to_string

@Cast(value="const char*")
public static BytePointer rs2_log_severity_to_string(@Cast(value="rs2_log_severity")
                                                                                 int info)

rs2_extension_type_to_string

@Cast(value="const char*")
public static BytePointer rs2_extension_type_to_string(@Cast(value="rs2_extension")
                                                                                   int type)

rs2_extension_to_string

@Cast(value="const char*")
public static BytePointer rs2_extension_to_string(@Cast(value="rs2_extension")
                                                                              int type)

rs2_matchers_to_string

@Cast(value="const char*")
public static BytePointer rs2_matchers_to_string(@Cast(value="rs2_matchers")
                                                                             int stream)

rs2_create_error

public static rs2_error rs2_create_error(@Cast(value="const char*")
                                         BytePointer what,
                                         @Cast(value="const char*")
                                         BytePointer name,
                                         @Cast(value="const char*")
                                         BytePointer args,
                                         @Cast(value="rs2_exception_type")
                                         int type)

Metadata attribute type is defined as 64 bit signed integer

rs2_create_error

public static rs2_error rs2_create_error(String what,
                                         String name,
                                         String args,
                                         @Cast(value="rs2_exception_type")
                                         int type)

rs2_get_librealsense_exception_type

@Cast(value="rs2_exception_type")
public static int rs2_get_librealsense_exception_type(@Const
                                                                                         rs2_error error)

rs2_get_failed_function

@Cast(value="const char*")
public static BytePointer rs2_get_failed_function(@Const
                                                                              rs2_error error)

rs2_get_failed_args

@Cast(value="const char*")
public static BytePointer rs2_get_failed_args(@Const
                                                                          rs2_error error)

rs2_get_error_message

@Cast(value="const char*")
public static BytePointer rs2_get_error_message(@Const
                                                                            rs2_error error)

rs2_free_error

public static void rs2_free_error(rs2_error error)

rs2_create_context
```
public static rs2_context rs2_create_context(int api_version,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)
```
\brief Creates RealSense context that is required for the rest of the API.

Parameters:

api_version - [in] Users are expected to pass their version of \c RS2_API_VERSION to make sure they are running the correct librealsense version.

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored.

Returns:

Context object

rs2_create_context

public static rs2_context rs2_create_context(int api_version,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_delete_context
```
public static void rs2_delete_context(rs2_context context)
```
\brief Frees the relevant context object.

Parameters:

context - [in] Object that is no longer needed

rs2_set_devices_changed_callback_cpp

public static void rs2_set_devices_changed_callback_cpp(rs2_context context,
                                                        rs2_devices_changed_callback callback,
                                                        @Cast(value="rs2_error**")
                                                        PointerPointer error)

set callback to get devices changed events these events will be raised by the context whenever new RealSense device is connected or existing device gets disconnected

Parameters:: context - Object representing librealsense session; callback - [in] callback object created from c++ application. ownership over the callback object is moved into the context; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_devices_changed_callback_cpp

public static void rs2_set_devices_changed_callback_cpp(rs2_context context,
                                                        rs2_devices_changed_callback callback,
                                                        @ByPtrPtr
                                                        rs2_error error)

rs2_set_devices_changed_callback

public static void rs2_set_devices_changed_callback(@Const
                                                    rs2_context context,
                                                    rs2_devices_changed_callback_ptr callback,
                                                    Pointer user,
                                                    @Cast(value="rs2_error**")
                                                    PointerPointer error)

set callback to get devices changed events these events will be raised by the context whenever new RealSense device is connected or existing device gets disconnected

Parameters:: context - Object representing librealsense session; callback - [in] function pointer to register as per-notifications callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_devices_changed_callback

public static void rs2_set_devices_changed_callback(@Const
                                                    rs2_context context,
                                                    rs2_devices_changed_callback_ptr callback,
                                                    Pointer user,
                                                    @ByPtrPtr
                                                    rs2_error error)

rs2_context_add_device

public static rs2_device rs2_context_add_device(rs2_context ctx,
                                                @Cast(value="const char*")
                                                BytePointer file,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

Create a new device and add it to the context

Parameters:: ctx - The context to which the new device will be added; file - The file from which the device should be created; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: A pointer to a device that plays data from the file, or null in case of failure

rs2_context_add_device

public static rs2_device rs2_context_add_device(rs2_context ctx,
                                                @Cast(value="const char*")
                                                BytePointer file,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_context_add_device

public static rs2_device rs2_context_add_device(rs2_context ctx,
                                                String file,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_context_add_software_device

public static void rs2_context_add_software_device(rs2_context ctx,
                                                   rs2_device dev,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

Add an instance of software device to the context

Parameters:: ctx - The context to which the new device will be added; dev - Instance of software device to register into the context; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_context_add_software_device

public static void rs2_context_add_software_device(rs2_context ctx,
                                                   rs2_device dev,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_context_remove_device

public static void rs2_context_remove_device(rs2_context ctx,
                                             @Cast(value="const char*")
                                             BytePointer file,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

Removes a playback device from the context, if exists

Parameters:: ctx - [in] The context from which the device should be removed; file - [in] The file name that was used to add the device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_context_remove_device

public static void rs2_context_remove_device(rs2_context ctx,
                                             @Cast(value="const char*")
                                             BytePointer file,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_context_remove_device

public static void rs2_context_remove_device(rs2_context ctx,
                                             String file,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_context_unload_tracking_module
```
public static void rs2_context_unload_tracking_module(rs2_context ctx,
                                                      @Cast(value="rs2_error**")
                                                      PointerPointer error)
```
Removes tracking module. function query_devices() locks the tracking module in the tm_context object. If the tracking module device is not used it should be removed using this function, so that other applications could find it. This function can be used both before the call to query_device() to prevent enabling tracking modules or afterwards to release them.

rs2_context_unload_tracking_module

public static void rs2_context_unload_tracking_module(rs2_context ctx,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_query_devices

public static rs2_device_list rs2_query_devices(@Const
                                                rs2_context context,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

create a static snapshot of all connected devices at the time of the call

Parameters:: context - Object representing librealsense session; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the list of devices, should be released by rs2_delete_device_list

rs2_query_devices

public static rs2_device_list rs2_query_devices(@Const
                                                rs2_context context,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_query_devices_ex

public static rs2_device_list rs2_query_devices_ex(@Const
                                                   rs2_context context,
                                                   int product_mask,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

create a static snapshot of all connected devices at the time of the call

Parameters:: context - Object representing librealsense session; product_mask - Controls what kind of devices will be returned; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the list of devices, should be released by rs2_delete_device_list

rs2_query_devices_ex

public static rs2_device_list rs2_query_devices_ex(@Const
                                                   rs2_context context,
                                                   int product_mask,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_create_device_hub

public static rs2_device_hub rs2_create_device_hub(@Const
                                                   rs2_context context,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

\brief Creates RealSense device_hub .

Parameters:: context - [in] The context for the device hub; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored.
Returns:: Device hub object

rs2_create_device_hub

public static rs2_device_hub rs2_create_device_hub(@Const
                                                   rs2_context context,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_delete_device_hub

public static void rs2_delete_device_hub(@Const
                                         rs2_device_hub hub)

\brief Frees the relevant device hub object.

Parameters:: hub - [in] Object that is no longer needed

rs2_device_hub_wait_for_device

public static rs2_device rs2_device_hub_wait_for_device(@Const
                                                        rs2_device_hub hub,
                                                        @Cast(value="rs2_error**")
                                                        PointerPointer error)

If any device is connected return it, otherwise wait until next RealSense device connects. Calling this method multiple times will cycle through connected devices

Parameters:: ctx - [in] The context to creat the device; hub - [in] The device hub object; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored.
Returns:: device object

rs2_device_hub_wait_for_device

public static rs2_device rs2_device_hub_wait_for_device(@Const
                                                        rs2_device_hub hub,
                                                        @ByPtrPtr
                                                        rs2_error error)

rs2_device_hub_is_device_connected

public static int rs2_device_hub_is_device_connected(@Const
                                                     rs2_device_hub hub,
                                                     @Const
                                                     rs2_device device,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)

Checks if device is still connected

Parameters:: hub - [in] The device hub object; device - [in] The device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored.
Returns:: 1 if the device is connected, 0 otherwise

rs2_device_hub_is_device_connected

public static int rs2_device_hub_is_device_connected(@Const
                                                     rs2_device_hub hub,
                                                     @Const
                                                     rs2_device device,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_get_device_count

public static int rs2_get_device_count(@Const
                                       rs2_device_list info_list,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

Determines number of devices in a list.

Parameters:: info_list - [in] The list of connected devices captured using rs2_query_devices; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Device count

rs2_get_device_count

public static int rs2_get_device_count(@Const
                                       rs2_device_list info_list,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_delete_device_list
```
public static void rs2_delete_device_list(rs2_device_list info_list)
```
Deletes device list, any devices created using this list will remain unaffected.

Parameters:

info_list - [in] List to delete

rs2_device_list_contains

public static int rs2_device_list_contains(@Const
                                           rs2_device_list info_list,
                                           @Const
                                           rs2_device device,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Checks if a specific device is contained inside a device list.

Parameters:: info_list - [in] The list of devices to check in; device - [in] RealSense device to check for; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: True if the device is in the list and false otherwise

rs2_device_list_contains

public static int rs2_device_list_contains(@Const
                                           rs2_device_list info_list,
                                           @Const
                                           rs2_device device,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_create_device

public static rs2_device rs2_create_device(@Const
                                           rs2_device_list info_list,
                                           int index,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Creates a device by index. The device object represents a physical camera and provides the means to manipulate it.

Parameters:: info_list - [in] the list containing the device to retrieve; index - [in] The zero based index of device to retrieve; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: The requested device, should be released by rs2_delete_device

rs2_create_device

public static rs2_device rs2_create_device(@Const
                                           rs2_device_list info_list,
                                           int index,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_delete_device
```
public static void rs2_delete_device(rs2_device device)
```
Delete RealSense device

Parameters:

device - [in] Realsense device to delete

rs2_get_device_info

@Cast(value="const char*")
public static BytePointer rs2_get_device_info(@Const
                                                                          rs2_device device,
                                                                          @Cast(value="rs2_camera_info")
                                                                          int info,
                                                                          @Cast(value="rs2_error**")
                                                                          PointerPointer error)

Retrieve camera specific information, like versions of various internal components.

Parameters:: device - [in] The RealSense device; info - [in] Camera info type to retrieve; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: The requested camera info string, in a format specific to the device model

rs2_get_device_info

@Cast(value="const char*")
public static BytePointer rs2_get_device_info(@Const
                                                                          rs2_device device,
                                                                          @Cast(value="rs2_camera_info")
                                                                          int info,
                                                                          @ByPtrPtr
                                                                          rs2_error error)

rs2_supports_device_info

public static int rs2_supports_device_info(@Const
                                           rs2_device device,
                                           @Cast(value="rs2_camera_info")
                                           int info,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Check if a camera supports a specific camera info type.

Parameters:: device - [in] The RealSense device to check; info - [in] The parameter to check for support; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: True if the parameter both exist and well-defined for the specific device

rs2_supports_device_info

public static int rs2_supports_device_info(@Const
                                           rs2_device device,
                                           @Cast(value="rs2_camera_info")
                                           int info,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_hardware_reset

public static void rs2_hardware_reset(@Const
                                      rs2_device device,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

Send hardware reset request to the device. The actual reset is asynchronous. Note: Invalidates all handles to this device.

Parameters:: device - [in] The RealSense device to reset; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_hardware_reset

public static void rs2_hardware_reset(@Const
                                      rs2_device device,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_build_debug_protocol_command

@Const
public static rs2_raw_data_buffer rs2_build_debug_protocol_command(rs2_device device,
                                                                           @Cast(value="unsigned")
                                                                           int opcode,
                                                                           @Cast(value="unsigned")
                                                                           int param1,
                                                                           @Cast(value="unsigned")
                                                                           int param2,
                                                                           @Cast(value="unsigned")
                                                                           int param3,
                                                                           @Cast(value="unsigned")
                                                                           int param4,
                                                                           Pointer data,
                                                                           @Cast(value="unsigned")
                                                                           int size_of_data,
                                                                           @Cast(value="rs2_error**")
                                                                           PointerPointer error)

Build debug_protocol raw data command from opcode, parameters and data. The result can be used as raw_data_to_send parameter in send_and_receive_raw_data

Parameters:: device - [in] RealSense device to send data to; opcode - [in] Commad opcode; param - [in] 1 First input parameter; param - [in] 2 Second parameter; param - [in] 3 Third parameter; param - [in] 4 Fourth parameter; data - [in] Input Data (up to 1024 bytes); size_of_data - [in] Size of input data in bytes; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: rs2_raw_data_buffer which includes raw command

rs2_build_debug_protocol_command

@Const
public static rs2_raw_data_buffer rs2_build_debug_protocol_command(rs2_device device,
                                                                           @Cast(value="unsigned")
                                                                           int opcode,
                                                                           @Cast(value="unsigned")
                                                                           int param1,
                                                                           @Cast(value="unsigned")
                                                                           int param2,
                                                                           @Cast(value="unsigned")
                                                                           int param3,
                                                                           @Cast(value="unsigned")
                                                                           int param4,
                                                                           Pointer data,
                                                                           @Cast(value="unsigned")
                                                                           int size_of_data,
                                                                           @ByPtrPtr
                                                                           rs2_error error)

rs2_send_and_receive_raw_data

@Const
public static rs2_raw_data_buffer rs2_send_and_receive_raw_data(rs2_device device,
                                                                        Pointer raw_data_to_send,
                                                                        @Cast(value="unsigned")
                                                                        int size_of_raw_data_to_send,
                                                                        @Cast(value="rs2_error**")
                                                                        PointerPointer error)

Send raw data to device

Parameters:: device - [in] RealSense device to send data to; raw_data_to_send - [in] Raw data to be sent to device; size_of_raw_data_to_send - [in] Size of raw_data_to_send in bytes; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Device's response in a rs2_raw_data_buffer, which should be released by rs2_delete_raw_data

rs2_send_and_receive_raw_data

@Const
public static rs2_raw_data_buffer rs2_send_and_receive_raw_data(rs2_device device,
                                                                        Pointer raw_data_to_send,
                                                                        @Cast(value="unsigned")
                                                                        int size_of_raw_data_to_send,
                                                                        @ByPtrPtr
                                                                        rs2_error error)

rs2_is_device_extendable_to

public static int rs2_is_device_extendable_to(@Const
                                              rs2_device device,
                                              @Cast(value="rs2_extension")
                                              int extension,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

Test if the given device can be extended to the requested extension.

Parameters:: device - [in] Realsense device; extension - [in] The extension to which the device should be tested if it is extendable; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Non-zero value iff the device can be extended to the given extension

rs2_is_device_extendable_to

public static int rs2_is_device_extendable_to(@Const
                                              rs2_device device,
                                              @Cast(value="rs2_extension")
                                              int extension,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_query_sensors

public static rs2_sensor_list rs2_query_sensors(@Const
                                                rs2_device device,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

Create a static snapshot of all connected sensors within a specific device.

Parameters:: device - [in] Specific RealSense device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: The list of sensors, should be released by rs2_delete_sensor_list

rs2_query_sensors

public static rs2_sensor_list rs2_query_sensors(@Const
                                                rs2_device device,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_loopback_enable

public static void rs2_loopback_enable(@Const
                                       rs2_device device,
                                       @Cast(value="const char*")
                                       BytePointer from_file,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

Enter the given device into loopback operation mode that uses the given file as input for raw data

Parameters:: device - [in] Device to enter into loopback operation mode; from_file - [in] Path to bag file with raw data for loopback; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_loopback_enable

public static void rs2_loopback_enable(@Const
                                       rs2_device device,
                                       @Cast(value="const char*")
                                       BytePointer from_file,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_loopback_enable

public static void rs2_loopback_enable(@Const
                                       rs2_device device,
                                       String from_file,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_loopback_disable

public static void rs2_loopback_disable(@Const
                                        rs2_device device,
                                        @Cast(value="rs2_error**")
                                        PointerPointer error)

Restores the given device into normal operation mode

Parameters:: device - [in] Device to restore to normal operation mode; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_loopback_disable

public static void rs2_loopback_disable(@Const
                                        rs2_device device,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_loopback_is_enabled

public static int rs2_loopback_is_enabled(@Const
                                          rs2_device device,
                                          @Cast(value="rs2_error**")
                                          PointerPointer error)

Checks if the device is in loopback mode or not

Parameters:: device - [in] Device to check for operation mode; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if the device is in loopback operation mode

rs2_loopback_is_enabled

public static int rs2_loopback_is_enabled(@Const
                                          rs2_device device,
                                          @ByPtrPtr
                                          rs2_error error)

rs2_connect_tm2_controller

public static void rs2_connect_tm2_controller(@Const
                                              rs2_device device,
                                              @Cast(value="const unsigned char*")
                                              BytePointer mac_addr,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

Connects to a given tm2 controller

Parameters:: device - [in] Device to connect to the controller; mac_addr - [in] The MAC address of the desired controller; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_connect_tm2_controller

public static void rs2_connect_tm2_controller(@Const
                                              rs2_device device,
                                              @Cast(value="const unsigned char*")
                                              BytePointer mac_addr,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_connect_tm2_controller

public static void rs2_connect_tm2_controller(@Const
                                              rs2_device device,
                                              @Cast(value="const unsigned char*")
                                              ByteBuffer mac_addr,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_connect_tm2_controller

public static void rs2_connect_tm2_controller(@Const
                                              rs2_device device,
                                              @Cast(value="const unsigned char*")
                                              byte[] mac_addr,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_disconnect_tm2_controller

public static void rs2_disconnect_tm2_controller(@Const
                                                 rs2_device device,
                                                 int id,
                                                 @Cast(value="rs2_error**")
                                                 PointerPointer error)

Disconnects a given tm2 controller

Parameters:: device - [in] Device to disconnect the controller from; id - [in] The ID of the desired controller; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_disconnect_tm2_controller

public static void rs2_disconnect_tm2_controller(@Const
                                                 rs2_device device,
                                                 int id,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_reset_to_factory_calibration

public static void rs2_reset_to_factory_calibration(@Const
                                                    rs2_device device,
                                                    @Cast(value="rs2_error**")
                                                    PointerPointer e)

Reset device to factory calibration

Parameters:: device - [in] The RealSense device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_reset_to_factory_calibration

public static void rs2_reset_to_factory_calibration(@Const
                                                    rs2_device device,
                                                    @ByPtrPtr
                                                    rs2_error e)

rs2_write_calibration

public static void rs2_write_calibration(@Const
                                         rs2_device device,
                                         @Cast(value="rs2_error**")
                                         PointerPointer e)

Write calibration to device's EEPROM

Parameters:: device - [in] The RealSense device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_write_calibration

public static void rs2_write_calibration(@Const
                                         rs2_device device,
                                         @ByPtrPtr
                                         rs2_error e)

rs2_update_firmware_cpp

public static void rs2_update_firmware_cpp(@Const
                                           rs2_device device,
                                           @Const
                                           Pointer fw_image,
                                           int fw_image_size,
                                           rs2_update_progress_callback callback,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Update device to the provided firmware, the device must be extendable to RS2_EXTENSION_UPDATABLE. This call is executed on the caller's thread and it supports progress notifications via the optional callback.

Parameters:: device - [in] Device to update; fw_image - [in] Firmware image buffer; fw_image_size - [in] Firmware image buffer size; callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_update_firmware_cpp

public static void rs2_update_firmware_cpp(@Const
                                           rs2_device device,
                                           @Const
                                           Pointer fw_image,
                                           int fw_image_size,
                                           rs2_update_progress_callback callback,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_update_firmware

public static void rs2_update_firmware(@Const
                                       rs2_device device,
                                       @Const
                                       Pointer fw_image,
                                       int fw_image_size,
                                       rs2_update_progress_callback_ptr callback,
                                       Pointer client_data,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

Parameters:: device - [in] Device to update; fw_image - [in] Firmware image buffer; fw_image_size - [in] Firmware image buffer size; callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1; client_data - [in] Optional client data for the callback; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_update_firmware

public static void rs2_update_firmware(@Const
                                       rs2_device device,
                                       @Const
                                       Pointer fw_image,
                                       int fw_image_size,
                                       rs2_update_progress_callback_ptr callback,
                                       Pointer client_data,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_create_flash_backup_cpp

@Const
public static rs2_raw_data_buffer rs2_create_flash_backup_cpp(@Const
                                                                      rs2_device device,
                                                                      rs2_update_progress_callback callback,
                                                                      @Cast(value="rs2_error**")
                                                                      PointerPointer error)

Create backup of camera flash memory. Such backup does not constitute valid firmware image, and cannot be loaded back to the device, but it does contain all calibration and device information.

Parameters:: device - [in] Device to update; callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_flash_backup_cpp

@Const
public static rs2_raw_data_buffer rs2_create_flash_backup_cpp(@Const
                                                                      rs2_device device,
                                                                      rs2_update_progress_callback callback,
                                                                      @ByPtrPtr
                                                                      rs2_error error)

rs2_create_flash_backup

@Const
public static rs2_raw_data_buffer rs2_create_flash_backup(@Const
                                                                  rs2_device device,
                                                                  rs2_update_progress_callback_ptr callback,
                                                                  Pointer client_data,
                                                                  @Cast(value="rs2_error**")
                                                                  PointerPointer error)

Create backup of camera flash memory. Such backup does not constitute valid firmware image, and cannot be loaded back to the device, but it does contain all calibration and device information.

Parameters:: device - [in] Device to update; callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1; client_data - [in] Optional client data for the callback; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_flash_backup

@Const
public static rs2_raw_data_buffer rs2_create_flash_backup(@Const
                                                                  rs2_device device,
                                                                  rs2_update_progress_callback_ptr callback,
                                                                  Pointer client_data,
                                                                  @ByPtrPtr
                                                                  rs2_error error)

rs2_update_firmware_unsigned_cpp

public static void rs2_update_firmware_unsigned_cpp(@Const
                                                    rs2_device device,
                                                    @Const
                                                    Pointer fw_image,
                                                    int fw_image_size,
                                                    rs2_update_progress_callback callback,
                                                    int update_mode,
                                                    @Cast(value="rs2_error**")
                                                    PointerPointer error)

Update device to the provided firmware by writing raw data directly to the flash, this command can be executed only on unlocked camera. The device must be extendable to RS2_EXTENSION_UPDATABLE. This call is executed on the caller's thread and it supports progress notifications via the optional callback.

Parameters:: device - [in] Device to update; fw_image - [in] Firmware image buffer; fw_image_size - [in] Firmware image buffer size; callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1; update_mode - [in] Select one of RS2_UNSIGNED_UPDATE_MODE, WARNING!!! setting to any option other than RS2_UNSIGNED_UPDATE_MODE_UPDATE will make this call unsafe and might damage the camera; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_update_firmware_unsigned_cpp

public static void rs2_update_firmware_unsigned_cpp(@Const
                                                    rs2_device device,
                                                    @Const
                                                    Pointer fw_image,
                                                    int fw_image_size,
                                                    rs2_update_progress_callback callback,
                                                    int update_mode,
                                                    @ByPtrPtr
                                                    rs2_error error)

rs2_check_firmware_compatibility

public static int rs2_check_firmware_compatibility(@Const
                                                   rs2_device device,
                                                   @Const
                                                   Pointer fw_image,
                                                   int fw_image_size,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

Checks if the device and the provided firmware image are compatible

Parameters:: device - [in] Device to update; fw_image - [in] Firmware image buffer; fw_image_size - [in] Firmware image buffer size in bytes; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Non-zero if the firmware is compatible with the device and 0 otherwise

rs2_check_firmware_compatibility

public static int rs2_check_firmware_compatibility(@Const
                                                   rs2_device device,
                                                   @Const
                                                   Pointer fw_image,
                                                   int fw_image_size,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_update_firmware_unsigned

public static void rs2_update_firmware_unsigned(@Const
                                                rs2_device device,
                                                @Const
                                                Pointer fw_image,
                                                int fw_image_size,
                                                rs2_update_progress_callback_ptr callback,
                                                Pointer client_data,
                                                int update_mode,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

Parameters:: device - [in] Device to update; fw_image - [in] Firmware image buffer; fw_image_size - [in] Firmware image buffer size; callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1; client_data - [in] Optional client data for the callback; update_mode - [in] Select one of RS2_UNSIGNED_UPDATE_MODE, WARNING!!! setting to any option other than RS2_UNSIGNED_UPDATE_MODE_UPDATE will make this call unsafe and might damage the camera; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_update_firmware_unsigned

public static void rs2_update_firmware_unsigned(@Const
                                                rs2_device device,
                                                @Const
                                                Pointer fw_image,
                                                int fw_image_size,
                                                rs2_update_progress_callback_ptr callback,
                                                Pointer client_data,
                                                int update_mode,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_enter_update_state

public static void rs2_enter_update_state(@Const
                                          rs2_device device,
                                          @Cast(value="rs2_error**")
                                          PointerPointer error)

Enter the device to update state, this will cause the updatable device to disconnect and reconnect as update device.

Parameters:: device - [in] Device to update; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_enter_update_state

public static void rs2_enter_update_state(@Const
                                          rs2_device device,
                                          @ByPtrPtr
                                          rs2_error error)

rs2_run_on_chip_calibration_cpp
```
@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration_cpp(rs2_device device,
                                                                          @Const
                                                                          Pointer json_content,
                                                                          int content_size,
                                                                          FloatPointer health,
                                                                          rs2_update_progress_callback progress_callback,
                                                                          int timeout_ms,
                                                                          @Cast(value="rs2_error**")
                                                                          PointerPointer error)
```
This will improve the depth noise.

Parameters:

json_content - [in] Json string to configure regular speed on chip calibration parameters: { "calib type" : 0, "speed": 3, "scan parameter": 0, "adjust both sides": 0, "white wall mode": 0, "host assistance": 0 } calib_type - calibraton type: 0 = regular, 1 = focal length, 2 = both regular and focal length in order, speed - for regular calibration. value can be one of: Very fast = 0, Fast = 1, Medium = 2, Slow = 3, White wall = 4, default is Slow for type 0 and Fast for type 2 scan_parameter - for regular calibration. value can be one of: Py scan (default) = 0, Rx scan = 1 adjust_both_sides - for focal length calibration. value can be one of: 0 = adjust right only, 1 = adjust both sides host_assistance: 0 for no assistance, 1 for starting with assistance, 2 for first part feeding host data to firmware, 3 for second part of feeding host data to firmware (calib_type 2 only) white_wall_mode - white wall mode: 0 for normal mode and 1 for white wall mode if json is nullptr it will be ignored and calibration will use the default parameters

health - [out] The absolute value of regular calibration Health-Check captures how far camera calibration is from the optimal one [0, 0.25) - Good [0.25, 0.75) - Can be Improved [0.75, ) - Requires Calibration The absolute value of focal length calibration Health-Check captures how far camera calibration is from the optimal one [0, 0.15) - Good [0.15, 0.75) - Can be Improved [0.75, ) - Requires Calibration The two health numbers are encoded in one integer as follows for calib_type 2: Regular health number times 1000 are bits 0 to 11 Regular health number is negative if bit 24 is 1 Focal length health number times 1000 are bits 12 to 23 Focal length health number is negative if bit 25 is 1

callback - [in] Optional callback to get progress notifications

timeout_ms - [in] Timeout in ms (use 5000 msec unless instructed otherwise)

Returns:

New calibration table

rs2_run_on_chip_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration_cpp(rs2_device device,
                                                                          @Const
                                                                          Pointer json_content,
                                                                          int content_size,
                                                                          FloatPointer health,
                                                                          rs2_update_progress_callback progress_callback,
                                                                          int timeout_ms,
                                                                          @ByPtrPtr
                                                                          rs2_error error)

rs2_run_on_chip_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration_cpp(rs2_device device,
                                                                          @Const
                                                                          Pointer json_content,
                                                                          int content_size,
                                                                          FloatBuffer health,
                                                                          rs2_update_progress_callback progress_callback,
                                                                          int timeout_ms,
                                                                          @ByPtrPtr
                                                                          rs2_error error)

rs2_run_on_chip_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration_cpp(rs2_device device,
                                                                          @Const
                                                                          Pointer json_content,
                                                                          int content_size,
                                                                          float[] health,
                                                                          rs2_update_progress_callback progress_callback,
                                                                          int timeout_ms,
                                                                          @ByPtrPtr
                                                                          rs2_error error)

rs2_run_on_chip_calibration
```
@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration(rs2_device device,
                                                                      @Const
                                                                      Pointer json_content,
                                                                      int content_size,
                                                                      FloatPointer health,
                                                                      rs2_update_progress_callback_ptr callback,
                                                                      Pointer client_data,
                                                                      int timeout_ms,
                                                                      @Cast(value="rs2_error**")
                                                                      PointerPointer error)
```
This will improve the depth noise.

Parameters:

json_content - [in] Json string to configure regular speed on chip calibration parameters: { "calib type" : 0, "speed": 3, "scan parameter": 0, "adjust both sides": 0, "white wall mode": 0, "host assistance": 0 } calib_type - calibraton type: 0 = regular, 1 = focal length, 2 = both regular and focal length in order 30 = regular for version 3, 31 = focal length for version 3, 32 = both regular and focal length in order for version 3, 33 = regular for second part of version 3 speed - for regular calibration, value can be one of: Very fast = 0, Fast = 1, Medium = 2, Slow = 3, White wall = 4, default is Slow for type 0 and Fast for type 2 scan_parameter - for regular calibration. value can be one of: Py scan (default) = 0, Rx scan = 1 adjust_both_sides - for focal length calibration. value can be one of: 0 = adjust right only, 1 = adjust both sides white_wall_mode - white wall mode: 0 for normal mode and 1 for white wall mode host_assistance: 0 for no assistance, 1 for starting with assistance, 2 for first part feeding host data to firmware, 3 for second part of feeding host data to firmware (calib_type 2 only) if json is nullptr it will be ignored and calibration will use the default parameters

health - [out] The absolute value of regular calibration Health-Check captures how far camera calibration is from the optimal one [0, 0.25) - Good [0.25, 0.75) - Can be Improved [0.75, ) - Requires Calibration The absolute value of focal length calibration Health-Check captures how far camera calibration is from the optimal one [0, 0.15) - Good [0.15, 0.75) - Can be Improved [0.75, ) - Requires Calibration The two health numbers are encoded in one integer as follows for calib_type 2: Regular health number times 1000 are bits 0 to 11 Regular health number is negative if bit 24 is 1 Focal length health number times 1000 are bits 12 to 23 Focal length health number is negative if bit 25 is 1

callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1

client_data - [in] Optional client data for the callback

timeout_ms - [in] Timeout in ms (use 5000 msec unless instructed otherwise)

Returns:

New calibration table

rs2_run_on_chip_calibration

@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration(rs2_device device,
                                                                      @Const
                                                                      Pointer json_content,
                                                                      int content_size,
                                                                      FloatPointer health,
                                                                      rs2_update_progress_callback_ptr callback,
                                                                      Pointer client_data,
                                                                      int timeout_ms,
                                                                      @ByPtrPtr
                                                                      rs2_error error)

rs2_run_on_chip_calibration

@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration(rs2_device device,
                                                                      @Const
                                                                      Pointer json_content,
                                                                      int content_size,
                                                                      FloatBuffer health,
                                                                      rs2_update_progress_callback_ptr callback,
                                                                      Pointer client_data,
                                                                      int timeout_ms,
                                                                      @ByPtrPtr
                                                                      rs2_error error)

rs2_run_on_chip_calibration

@Const
public static rs2_raw_data_buffer rs2_run_on_chip_calibration(rs2_device device,
                                                                      @Const
                                                                      Pointer json_content,
                                                                      int content_size,
                                                                      float[] health,
                                                                      rs2_update_progress_callback_ptr callback,
                                                                      Pointer client_data,
                                                                      int timeout_ms,
                                                                      @ByPtrPtr
                                                                      rs2_error error)

rs2_run_tare_calibration_cpp
```
@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration_cpp(rs2_device dev,
                                                                       float ground_truth_mm,
                                                                       @Const
                                                                       Pointer json_content,
                                                                       int content_size,
                                                                       FloatPointer health,
                                                                       rs2_update_progress_callback progress_callback,
                                                                       int timeout_ms,
                                                                       @Cast(value="rs2_error**")
                                                                       PointerPointer error)
```
This will adjust camera absolute distance to flat target. User needs to enter the known ground truth.

Parameters:

ground_truth_mm - [in] Ground truth in mm must be between 60 and 10000

json_content - [in] Json string to configure tare calibration parameters: { "average step count": 20, "step count": 20, "accuracy": 2, "scan parameter": 0, "data sampling": 0, "host assistance": 0, "depth" : 0 } average step count - number of frames to average, must be between 1 - 30, default = 20 step count - max iteration steps, must be between 5 - 30, default = 10 accuracy - Subpixel accuracy level, value can be one of: Very high = 0 (0.025%), High = 1 (0.05%), Medium = 2 (0.1%), Low = 3 (0.2%), Default = Very high (0.025%), default is Medium scan_parameter - value can be one of: Py scan (default) = 0, Rx scan = 1 data_sampling - value can be one of:polling data sampling = 0, interrupt data sampling = 1 host_assistance: 0 for no assistance, 1 for starting with assistance, 2 for feeding host data to firmware depth: 0 for not relating to depth, > 0 for feeding depth from host to firmware, -1 for ending to feed depth from host to firmware if json is nullptr it will be ignored and calibration will use the default parameters

content_size - [in] Json string size if its 0 the json will be ignored and calibration will use the default parameters

health - [out] The absolute value of regular calibration Health-Check captures how far camera calibration is from the optimal one [0, 0.25) - Good [0.25, 0.75) - Can be Improved [0.75, ) - Requires Calibration

callback - [in] Optional callback to get progress notifications

timeout_ms - [in] Timeout in ms (use 5000 msec unless instructed otherwise)

health - [out] The health check numbers before and after calibration

Returns:

New calibration table

rs2_run_tare_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration_cpp(rs2_device dev,
                                                                       float ground_truth_mm,
                                                                       @Const
                                                                       Pointer json_content,
                                                                       int content_size,
                                                                       FloatPointer health,
                                                                       rs2_update_progress_callback progress_callback,
                                                                       int timeout_ms,
                                                                       @ByPtrPtr
                                                                       rs2_error error)

rs2_run_tare_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration_cpp(rs2_device dev,
                                                                       float ground_truth_mm,
                                                                       @Const
                                                                       Pointer json_content,
                                                                       int content_size,
                                                                       FloatBuffer health,
                                                                       rs2_update_progress_callback progress_callback,
                                                                       int timeout_ms,
                                                                       @ByPtrPtr
                                                                       rs2_error error)

rs2_run_tare_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration_cpp(rs2_device dev,
                                                                       float ground_truth_mm,
                                                                       @Const
                                                                       Pointer json_content,
                                                                       int content_size,
                                                                       float[] health,
                                                                       rs2_update_progress_callback progress_callback,
                                                                       int timeout_ms,
                                                                       @ByPtrPtr
                                                                       rs2_error error)

rs2_process_calibration_frame

@Const
public static rs2_raw_data_buffer rs2_process_calibration_frame(rs2_device dev,
                                                                        @Const
                                                                        rs2_frame f,
                                                                        FloatPointer health,
                                                                        rs2_update_progress_callback progress_callback,
                                                                        int timeout_ms,
                                                                        @Cast(value="rs2_error**")
                                                                        PointerPointer error)

During host assisted calibration (Tare or on-chip), this is used to pump new depth frames until calibration is done.

Parameters:: f - [in] The next frame.; timeout_ms - [in] Timeout in ms (use 5000 msec unless instructed otherwise); health - [out] The health check numbers before and after calibration
Returns:: New calibration table

rs2_process_calibration_frame

@Const
public static rs2_raw_data_buffer rs2_process_calibration_frame(rs2_device dev,
                                                                        @Const
                                                                        rs2_frame f,
                                                                        FloatPointer health,
                                                                        rs2_update_progress_callback progress_callback,
                                                                        int timeout_ms,
                                                                        @ByPtrPtr
                                                                        rs2_error error)

rs2_process_calibration_frame

@Const
public static rs2_raw_data_buffer rs2_process_calibration_frame(rs2_device dev,
                                                                        @Const
                                                                        rs2_frame f,
                                                                        FloatBuffer health,
                                                                        rs2_update_progress_callback progress_callback,
                                                                        int timeout_ms,
                                                                        @ByPtrPtr
                                                                        rs2_error error)

rs2_process_calibration_frame

@Const
public static rs2_raw_data_buffer rs2_process_calibration_frame(rs2_device dev,
                                                                        @Const
                                                                        rs2_frame f,
                                                                        float[] health,
                                                                        rs2_update_progress_callback progress_callback,
                                                                        int timeout_ms,
                                                                        @ByPtrPtr
                                                                        rs2_error error)

rs2_calibration_type_to_string

@Cast(value="const char*")
public static BytePointer rs2_calibration_type_to_string(@Cast(value="rs2_calibration_type")
                                                                                     int arg0)

rs2_calibration_status_to_string

@Cast(value="const char*")
public static BytePointer rs2_calibration_status_to_string(@Cast(value="rs2_calibration_status")
                                                                                       int arg0)

rs2_register_calibration_change_callback

public static void rs2_register_calibration_change_callback(rs2_device dev,
                                                            rs2_calibration_change_callback_ptr callback,
                                                            Pointer user,
                                                            @Cast(value="rs2_error**")
                                                            PointerPointer error)

Adds a callback for a sensor that gets called when calibration (intrinsics) changes, e.g. due to auto-calibration

Parameters:: sensor - [in] the sensor; callback - [in] the C callback function that gets called; user - [in] user argument that gets passed to the callback function; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_register_calibration_change_callback

public static void rs2_register_calibration_change_callback(rs2_device dev,
                                                            rs2_calibration_change_callback_ptr callback,
                                                            Pointer user,
                                                            @ByPtrPtr
                                                            rs2_error error)

rs2_register_calibration_change_callback_cpp

public static void rs2_register_calibration_change_callback_cpp(rs2_device dev,
                                                                rs2_calibration_change_callback callback,
                                                                @Cast(value="rs2_error**")
                                                                PointerPointer error)

Adds a callback for a sensor that gets called when calibration (intrinsics) changes, e.g. due to auto-calibration

Parameters:: sensor - [in] the sensor; callback - [in] the C++ callback interface that gets called; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_register_calibration_change_callback_cpp

public static void rs2_register_calibration_change_callback_cpp(rs2_device dev,
                                                                rs2_calibration_change_callback callback,
                                                                @ByPtrPtr
                                                                rs2_error error)

rs2_trigger_device_calibration

public static void rs2_trigger_device_calibration(rs2_device dev,
                                                  @Cast(value="rs2_calibration_type")
                                                  int type,
                                                  @Cast(value="rs2_error**")
                                                  PointerPointer error)

Triggers calibration of the given type

Parameters:: dev - [in] the device; type - [in] the type of calibration requested; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_trigger_device_calibration

public static void rs2_trigger_device_calibration(rs2_device dev,
                                                  @Cast(value="rs2_calibration_type")
                                                  int type,
                                                  @ByPtrPtr
                                                  rs2_error error)

rs2_run_tare_calibration
```
@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration(rs2_device dev,
                                                                   float ground_truth_mm,
                                                                   @Const
                                                                   Pointer json_content,
                                                                   int content_size,
                                                                   FloatPointer health,
                                                                   rs2_update_progress_callback_ptr callback,
                                                                   Pointer client_data,
                                                                   int timeout_ms,
                                                                   @Cast(value="rs2_error**")
                                                                   PointerPointer error)
```
This will adjust camera absolute distance to flat target. User needs to enter the known ground truth.

Parameters:

ground_truth_mm - [in] Ground truth in mm must be between 60 and 10000

json_content - [in] Json string to configure tare calibration parameters: { "average_step_count": 20, "step count": 20, "accuracy": 2, "scan parameter": 0, "data sampling": 0, "host assistance": 0, "depth": 0 } average step count - number of frames to average, must be between 1 - 30, default = 20 step count - max iteration steps, must be between 5 - 30, default = 10 accuracy - Subpixel accuracy level, value can be one of: Very high = 0 (0.025%), High = 1 (0.05%), Medium = 2 (0.1%), Low = 3 (0.2%), Default = Very high (0.025%), default is Medium scan_parameter - value can be one of: Py scan (default) = 0, Rx scan = 1 data_sampling - value can be one of:polling data sampling = 0, interrupt data sampling = 1 host_assistance: 0 for no assistance, 1 for starting with assistance, 2 for feeding host data to firmware depth: 0 for not relating to depth, > 0 for feeding depth from host to firmware, -1 for ending to feed depth from host to firmware if json is nullptr it will be ignored and calibration will use the default parameters

content_size - [in] Json string size if its 0 the json will be ignored and calibration will use the default parameters

callback - [in] Optional callback for update progress notifications, the progress value is normailzed to 1

client_data - [in] Optional client data for the callback

timeout_ms - [in] Timeout in ms (use 5000 msec unless instructed otherwise)

health - [out] The health check numbers before and after calibration

Returns:

New calibration table

rs2_run_tare_calibration

@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration(rs2_device dev,
                                                                   float ground_truth_mm,
                                                                   @Const
                                                                   Pointer json_content,
                                                                   int content_size,
                                                                   FloatPointer health,
                                                                   rs2_update_progress_callback_ptr callback,
                                                                   Pointer client_data,
                                                                   int timeout_ms,
                                                                   @ByPtrPtr
                                                                   rs2_error error)

rs2_run_tare_calibration

@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration(rs2_device dev,
                                                                   float ground_truth_mm,
                                                                   @Const
                                                                   Pointer json_content,
                                                                   int content_size,
                                                                   FloatBuffer health,
                                                                   rs2_update_progress_callback_ptr callback,
                                                                   Pointer client_data,
                                                                   int timeout_ms,
                                                                   @ByPtrPtr
                                                                   rs2_error error)

rs2_run_tare_calibration

@Const
public static rs2_raw_data_buffer rs2_run_tare_calibration(rs2_device dev,
                                                                   float ground_truth_mm,
                                                                   @Const
                                                                   Pointer json_content,
                                                                   int content_size,
                                                                   float[] health,
                                                                   rs2_update_progress_callback_ptr callback,
                                                                   Pointer client_data,
                                                                   int timeout_ms,
                                                                   @ByPtrPtr
                                                                   rs2_error error)

rs2_get_calibration_table

@Const
public static rs2_raw_data_buffer rs2_get_calibration_table(@Const
                                                                    rs2_device dev,
                                                                    @Cast(value="rs2_error**")
                                                                    PointerPointer error)

Read current calibration table from flash.

Returns:: Calibration table

rs2_get_calibration_table

@Const
public static rs2_raw_data_buffer rs2_get_calibration_table(@Const
                                                                    rs2_device dev,
                                                                    @ByPtrPtr
                                                                    rs2_error error)

rs2_set_calibration_table

public static void rs2_set_calibration_table(@Const
                                             rs2_device device,
                                             @Const
                                             Pointer calibration,
                                             int calibration_size,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

Set current table to dynamic area.

Parameters:: Calibration - [in] table

rs2_set_calibration_table

public static void rs2_set_calibration_table(@Const
                                             rs2_device device,
                                             @Const
                                             Pointer calibration,
                                             int calibration_size,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_serialize_json

public static rs2_raw_data_buffer rs2_serialize_json(rs2_device dev,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)

rs2_serialize_json

public static rs2_raw_data_buffer rs2_serialize_json(rs2_device dev,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_load_json

public static void rs2_load_json(rs2_device dev,
                                 @Const
                                 Pointer json_content,
                                 @Cast(value="unsigned")
                                 int content_size,
                                 @Cast(value="rs2_error**")
                                 PointerPointer error)

rs2_load_json

public static void rs2_load_json(rs2_device dev,
                                 @Const
                                 Pointer json_content,
                                 @Cast(value="unsigned")
                                 int content_size,
                                 @ByPtrPtr
                                 rs2_error error)

rs2_run_focal_length_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration_cpp(rs2_device device,
                                                                               rs2_frame_queue left_queue,
                                                                               rs2_frame_queue right_queue,
                                                                               float target_width,
                                                                               float target_height,
                                                                               int adjust_both_sides,
                                                                               FloatPointer ratio,
                                                                               FloatPointer angle,
                                                                               rs2_update_progress_callback progress_callback,
                                                                               @Cast(value="rs2_error**")
                                                                               PointerPointer error)

Run target-based focal length calibration

Parameters:: device - [in] : device to calibrate; left_queue - [in] : container for left IR frames with resoluton of 1280x720 and the target in the center of 320x240 pixels ROI.; right_queue - [in] : container for right IR frames with resoluton of 1280x720 and the target in the center of 320x240 pixels ROI; target_width - [in] : the rectangle width in mm on the target; target_height - [in] : the rectangle height in mm on the target; adjust_both_sides - [in] : 1 for adjusting both left and right camera calibration tables, and 0 for adjusting right camera calibraion table only; ratio - [out] : the corrected ratio from the calibration; angle - [out] : the target's tilt angle; callback - [in] : Optional callback for update progress notifications, the progress value is normailzed to 1
Returns:: New calibration table

rs2_run_focal_length_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration_cpp(rs2_device device,
                                                                               rs2_frame_queue left_queue,
                                                                               rs2_frame_queue right_queue,
                                                                               float target_width,
                                                                               float target_height,
                                                                               int adjust_both_sides,
                                                                               FloatPointer ratio,
                                                                               FloatPointer angle,
                                                                               rs2_update_progress_callback progress_callback,
                                                                               @ByPtrPtr
                                                                               rs2_error error)

rs2_run_focal_length_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration_cpp(rs2_device device,
                                                                               rs2_frame_queue left_queue,
                                                                               rs2_frame_queue right_queue,
                                                                               float target_width,
                                                                               float target_height,
                                                                               int adjust_both_sides,
                                                                               FloatBuffer ratio,
                                                                               FloatBuffer angle,
                                                                               rs2_update_progress_callback progress_callback,
                                                                               @ByPtrPtr
                                                                               rs2_error error)

rs2_run_focal_length_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration_cpp(rs2_device device,
                                                                               rs2_frame_queue left_queue,
                                                                               rs2_frame_queue right_queue,
                                                                               float target_width,
                                                                               float target_height,
                                                                               int adjust_both_sides,
                                                                               float[] ratio,
                                                                               float[] angle,
                                                                               rs2_update_progress_callback progress_callback,
                                                                               @ByPtrPtr
                                                                               rs2_error error)

rs2_run_focal_length_calibration

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration(rs2_device device,
                                                                           rs2_frame_queue left_queue,
                                                                           rs2_frame_queue right_queue,
                                                                           float target_width,
                                                                           float target_height,
                                                                           int adjust_both_sides,
                                                                           FloatPointer ratio,
                                                                           FloatPointer angle,
                                                                           rs2_update_progress_callback_ptr callback,
                                                                           Pointer client_data,
                                                                           @Cast(value="rs2_error**")
                                                                           PointerPointer error)

Run target-based focal length calibration

Parameters:: device - [in] : device to calibrate; left_queue - [in] : container for left IR frames with resoluton of 1280x720 and the target in the center of 320x240 pixels ROI.; right_queue - [in] : container for right IR frames with resoluton of 1280x720 and the target in the center of 320x240 pixels ROI; target_width - [in] : the rectangle width in mm on the target; target_height - [in] : the rectangle height in mm on the target; adjust_both_sides - [in] : 1 for adjusting both left and right camera calibration tables, and 0 for adjusting right camera calibraion table only; ratio - [out] : the corrected ratio from the calibration; angle - [out] : the target's tilt angle; callback - [in] : Optional callback for update progress notifications, the progress value is normailzed to 1; client_data - [in] : Optional client data for the callback
Returns:: New calibration table

rs2_run_focal_length_calibration

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration(rs2_device device,
                                                                           rs2_frame_queue left_queue,
                                                                           rs2_frame_queue right_queue,
                                                                           float target_width,
                                                                           float target_height,
                                                                           int adjust_both_sides,
                                                                           FloatPointer ratio,
                                                                           FloatPointer angle,
                                                                           rs2_update_progress_callback_ptr callback,
                                                                           Pointer client_data,
                                                                           @ByPtrPtr
                                                                           rs2_error error)

rs2_run_focal_length_calibration

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration(rs2_device device,
                                                                           rs2_frame_queue left_queue,
                                                                           rs2_frame_queue right_queue,
                                                                           float target_width,
                                                                           float target_height,
                                                                           int adjust_both_sides,
                                                                           FloatBuffer ratio,
                                                                           FloatBuffer angle,
                                                                           rs2_update_progress_callback_ptr callback,
                                                                           Pointer client_data,
                                                                           @ByPtrPtr
                                                                           rs2_error error)

rs2_run_focal_length_calibration

@Const
public static rs2_raw_data_buffer rs2_run_focal_length_calibration(rs2_device device,
                                                                           rs2_frame_queue left_queue,
                                                                           rs2_frame_queue right_queue,
                                                                           float target_width,
                                                                           float target_height,
                                                                           int adjust_both_sides,
                                                                           float[] ratio,
                                                                           float[] angle,
                                                                           rs2_update_progress_callback_ptr callback,
                                                                           Pointer client_data,
                                                                           @ByPtrPtr
                                                                           rs2_error error)

rs2_run_uv_map_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration_cpp(rs2_device device,
                                                                         rs2_frame_queue left_queue,
                                                                         rs2_frame_queue color_queue,
                                                                         rs2_frame_queue depth_queue,
                                                                         int py_px_only,
                                                                         FloatPointer health,
                                                                         int health_size,
                                                                         rs2_update_progress_callback progress_callback,
                                                                         @Cast(value="rs2_error**")
                                                                         PointerPointer error)

Depth-RGB UV-Map calibration. Applicable for D400 cameras

Parameters:: device - [in] : device to calibrate; left_queue - [in] : the frame queue for left IR frames with resoluton of 1280x720 and the target captured in the center of 320x240 pixels ROI.; color_queue - [in] : the frame queue for RGB frames with resoluton of 1280x720 and the target in the center of 320x240 pixels ROI; depth_queue - [in] : the frame queue for Depth frames with resoluton of 1280x720; py_px_only - [in] : 1 for calibrating color camera py and px only, 1 for calibrating color camera py, px, fy, and fx.; health - [out] : The four health check numbers in order of px, py, fx, fy for the calibration; health_size - [in] : number of health check numbers, which is 4 by default; callback - [in] : Optional callback for update progress notifications, the progress value is normailzed to 1
Returns:: New calibration table

rs2_run_uv_map_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration_cpp(rs2_device device,
                                                                         rs2_frame_queue left_queue,
                                                                         rs2_frame_queue color_queue,
                                                                         rs2_frame_queue depth_queue,
                                                                         int py_px_only,
                                                                         FloatPointer health,
                                                                         int health_size,
                                                                         rs2_update_progress_callback progress_callback,
                                                                         @ByPtrPtr
                                                                         rs2_error error)

rs2_run_uv_map_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration_cpp(rs2_device device,
                                                                         rs2_frame_queue left_queue,
                                                                         rs2_frame_queue color_queue,
                                                                         rs2_frame_queue depth_queue,
                                                                         int py_px_only,
                                                                         FloatBuffer health,
                                                                         int health_size,
                                                                         rs2_update_progress_callback progress_callback,
                                                                         @ByPtrPtr
                                                                         rs2_error error)

rs2_run_uv_map_calibration_cpp

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration_cpp(rs2_device device,
                                                                         rs2_frame_queue left_queue,
                                                                         rs2_frame_queue color_queue,
                                                                         rs2_frame_queue depth_queue,
                                                                         int py_px_only,
                                                                         float[] health,
                                                                         int health_size,
                                                                         rs2_update_progress_callback progress_callback,
                                                                         @ByPtrPtr
                                                                         rs2_error error)

rs2_run_uv_map_calibration

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration(rs2_device device,
                                                                     rs2_frame_queue left_queue,
                                                                     rs2_frame_queue color_queue,
                                                                     rs2_frame_queue depth_queue,
                                                                     int py_px_only,
                                                                     FloatPointer health,
                                                                     int health_size,
                                                                     rs2_update_progress_callback_ptr callback,
                                                                     Pointer client_data,
                                                                     @Cast(value="rs2_error**")
                                                                     PointerPointer error)

Depth-RGB UV-Map calibration. Applicable for D400 cameras

Parameters:: device - [in] : device to calibrate; left_queue - [in] : the frame queue for left IR frames with resoluton of 1280x720 and the target captured in the center of 320x240 pixels ROI.; color_queue - [in] : the frame queue for RGB frames with resoluton of 1280x720 and the target in the center of 320x240 pixels ROI; depth_queue - [in] : the frame queue for Depth frames with resoluton of 1280x720; py_px_only - [in] : 1 for calibrating color camera py and px only, 1 for calibrating color camera py, px, fy, and fx.; health - [out] : The four health check numbers in order of px, py, fx, fy for the calibration; health_size - [in] : number of health check numbers, which is 4 by default; callback - [in] : Optional callback for update progress notifications, the progress value is normailzed to 1; client_data - [in] : Optional client data for the callback
Returns:: New calibration table

rs2_run_uv_map_calibration

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration(rs2_device device,
                                                                     rs2_frame_queue left_queue,
                                                                     rs2_frame_queue color_queue,
                                                                     rs2_frame_queue depth_queue,
                                                                     int py_px_only,
                                                                     FloatPointer health,
                                                                     int health_size,
                                                                     rs2_update_progress_callback_ptr callback,
                                                                     Pointer client_data,
                                                                     @ByPtrPtr
                                                                     rs2_error error)

rs2_run_uv_map_calibration

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration(rs2_device device,
                                                                     rs2_frame_queue left_queue,
                                                                     rs2_frame_queue color_queue,
                                                                     rs2_frame_queue depth_queue,
                                                                     int py_px_only,
                                                                     FloatBuffer health,
                                                                     int health_size,
                                                                     rs2_update_progress_callback_ptr callback,
                                                                     Pointer client_data,
                                                                     @ByPtrPtr
                                                                     rs2_error error)

rs2_run_uv_map_calibration

@Const
public static rs2_raw_data_buffer rs2_run_uv_map_calibration(rs2_device device,
                                                                     rs2_frame_queue left_queue,
                                                                     rs2_frame_queue color_queue,
                                                                     rs2_frame_queue depth_queue,
                                                                     int py_px_only,
                                                                     float[] health,
                                                                     int health_size,
                                                                     rs2_update_progress_callback_ptr callback,
                                                                     Pointer client_data,
                                                                     @ByPtrPtr
                                                                     rs2_error error)

rs2_calculate_target_z_cpp

public static float rs2_calculate_target_z_cpp(rs2_device device,
                                               rs2_frame_queue queue1,
                                               rs2_frame_queue queue2,
                                               rs2_frame_queue queue3,
                                               float target_width,
                                               float target_height,
                                               rs2_update_progress_callback callback,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)

Calculate Z for calibration target - distance to the target's plane

Parameters:: queue - [in] 1-3: A frame queue of raw images used to calculate and extract the distance to a predefined target pattern. For D400 the indexes 1-3 correspond to Left IR, Right IR and Depth with only the Left IR being used; target_width - [in] : Expected target's horizontal dimension in mm; target_height - [in] : Expected target's vertical dimension in mm; callback - [in] : Optional callback for reporting progress status
Returns:: Calculated distance (Z) to target in millimeter, or negative number if failed

rs2_calculate_target_z_cpp

public static float rs2_calculate_target_z_cpp(rs2_device device,
                                               rs2_frame_queue queue1,
                                               rs2_frame_queue queue2,
                                               rs2_frame_queue queue3,
                                               float target_width,
                                               float target_height,
                                               rs2_update_progress_callback callback,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_calculate_target_z

public static float rs2_calculate_target_z(rs2_device device,
                                           rs2_frame_queue queue1,
                                           rs2_frame_queue queue2,
                                           rs2_frame_queue queue3,
                                           float target_width,
                                           float target_height,
                                           rs2_update_progress_callback_ptr progress_callback,
                                           Pointer client_data,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Calculate Z for calibration target - distance to the target's plane

Parameters:: queue - [in] 1-3: A frame queue of raw images used to calculate and extract the distance to a predefined target pattern. For D400 the indexes 1-3 correspond to Left IR, Right IR and Depth with only the Left IR being used; target_width - [in] : Expected target's horizontal dimension in mm; target_height - [in] : Expected target's vertical dimension in mm; callback - [in] : Optional callback for reporting progress status; client_data - [in] : Optional client data for the callback
Returns:: Calculated distance (Z) to target in millimeter, or negative number if failed

rs2_calculate_target_z

public static float rs2_calculate_target_z(rs2_device device,
                                           rs2_frame_queue queue1,
                                           rs2_frame_queue queue2,
                                           rs2_frame_queue queue3,
                                           float target_width,
                                           float target_height,
                                           rs2_update_progress_callback_ptr progress_callback,
                                           Pointer client_data,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_timestamp_domain_to_string

@Cast(value="const char*")
public static BytePointer rs2_timestamp_domain_to_string(@Cast(value="rs2_timestamp_domain")
                                                                                     int info)

rs2_frame_metadata_to_string

@Cast(value="const char*")
public static BytePointer rs2_frame_metadata_to_string(@Cast(value="rs2_frame_metadata_value")
                                                                                   int metadata)

rs2_frame_metadata_value_to_string

@Cast(value="const char*")
public static BytePointer rs2_frame_metadata_value_to_string(@Cast(value="rs2_frame_metadata_value")
                                                                                         int metadata)

rs2_calib_target_type_to_string

@Cast(value="const char*")
public static BytePointer rs2_calib_target_type_to_string(@Cast(value="rs2_calib_target_type")
                                                                                      int type)

rs2_get_frame_metadata

@Cast(value="rs2_metadata_type")
public static long rs2_get_frame_metadata(@Const
                                                                            rs2_frame frame,
                                                                            @Cast(value="rs2_frame_metadata_value")
                                                                            int frame_metadata,
                                                                            @Cast(value="rs2_error**")
                                                                            PointerPointer error)

retrieve metadata from frame handle

Parameters:: frame - [in] handle returned from a callback; frame_metadata - [in] the rs2_frame_metadata whose latest frame we are interested in; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the metadata value

rs2_get_frame_metadata

@Cast(value="rs2_metadata_type")
public static long rs2_get_frame_metadata(@Const
                                                                            rs2_frame frame,
                                                                            @Cast(value="rs2_frame_metadata_value")
                                                                            int frame_metadata,
                                                                            @ByPtrPtr
                                                                            rs2_error error)

rs2_supports_frame_metadata

public static int rs2_supports_frame_metadata(@Const
                                              rs2_frame frame,
                                              @Cast(value="rs2_frame_metadata_value")
                                              int frame_metadata,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

determine device metadata

Parameters:: frame - [in] handle returned from a callback; frame_metadata - [in] the metadata to check for support; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if device has this metadata

rs2_supports_frame_metadata

public static int rs2_supports_frame_metadata(@Const
                                              rs2_frame frame,
                                              @Cast(value="rs2_frame_metadata_value")
                                              int frame_metadata,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_get_frame_timestamp_domain

@Cast(value="rs2_timestamp_domain")
public static int rs2_get_frame_timestamp_domain(@Const
                                                                                      rs2_frame frameset,
                                                                                      @Cast(value="rs2_error**")
                                                                                      PointerPointer error)

retrieve timestamp domain from frame handle. timestamps can only be comparable if they are in common domain (for example, depth timestamp might come from system time while color timestamp might come from the device) this method is used to check if two timestamp values are comparable (generated from the same clock)

Parameters:: frameset - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the timestamp domain of the frame (camera / microcontroller / system time)

rs2_get_frame_timestamp_domain

@Cast(value="rs2_timestamp_domain")
public static int rs2_get_frame_timestamp_domain(@Const
                                                                                      rs2_frame frameset,
                                                                                      @ByPtrPtr
                                                                                      rs2_error error)

rs2_get_frame_timestamp

@Cast(value="rs2_time_t")
public static double rs2_get_frame_timestamp(@Const
                                                                        rs2_frame frame,
                                                                        @Cast(value="rs2_error**")
                                                                        PointerPointer error)

retrieve timestamp from frame handle in milliseconds

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the timestamp of the frame in milliseconds

rs2_get_frame_timestamp

@Cast(value="rs2_time_t")
public static double rs2_get_frame_timestamp(@Const
                                                                        rs2_frame frame,
                                                                        @ByPtrPtr
                                                                        rs2_error error)

rs2_get_frame_sensor

public static rs2_sensor rs2_get_frame_sensor(@Const
                                              rs2_frame frame,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

retrieve frame parent sensor from frame handle

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the parent sensor of the frame

rs2_get_frame_sensor

public static rs2_sensor rs2_get_frame_sensor(@Const
                                              rs2_frame frame,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_get_frame_number

@Cast(value="unsigned long long")
public static long rs2_get_frame_number(@Const
                                                                           rs2_frame frame,
                                                                           @Cast(value="rs2_error**")
                                                                           PointerPointer error)

retrieve frame number from frame handle

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the frame nubmer of the frame, in milliseconds since the device was started

rs2_get_frame_number

@Cast(value="unsigned long long")
public static long rs2_get_frame_number(@Const
                                                                           rs2_frame frame,
                                                                           @ByPtrPtr
                                                                           rs2_error error)

rs2_get_frame_data_size

public static int rs2_get_frame_data_size(@Const
                                          rs2_frame frame,
                                          @Cast(value="rs2_error**")
                                          PointerPointer error)

retrieve data size from frame handle

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the size of the frame data

rs2_get_frame_data_size

public static int rs2_get_frame_data_size(@Const
                                          rs2_frame frame,
                                          @ByPtrPtr
                                          rs2_error error)

rs2_get_frame_data

@Const
public static Pointer rs2_get_frame_data(@Const
                                                 rs2_frame frame,
                                                 @Cast(value="rs2_error**")
                                                 PointerPointer error)

retrieve data from frame handle

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the pointer to the start of the frame data

rs2_get_frame_data

@Const
public static Pointer rs2_get_frame_data(@Const
                                                 rs2_frame frame,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_get_frame_data_address

@Cast(value="const void*")
 @Name(value="rs2_get_frame_data")
public static long rs2_get_frame_data_address(@Const
                                                                                                              rs2_frame frame,
                                                                                                              @Cast(value="rs2_error**")
                                                                                                              PointerPointer error)

rs2_get_frame_data_address

@Cast(value="const void*")
 @Name(value="rs2_get_frame_data")
public static long rs2_get_frame_data_address(@Const
                                                                                                              rs2_frame frame,
                                                                                                              @ByPtrPtr
                                                                                                              rs2_error error)

rs2_get_frame_width

public static int rs2_get_frame_width(@Const
                                      rs2_frame frame,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

retrieve frame width in pixels

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: frame width in pixels

rs2_get_frame_width

public static int rs2_get_frame_width(@Const
                                      rs2_frame frame,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_get_frame_height

public static int rs2_get_frame_height(@Const
                                       rs2_frame frame,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

retrieve frame height in pixels

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: frame height in pixels

rs2_get_frame_height

public static int rs2_get_frame_height(@Const
                                       rs2_frame frame,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_depth_frame_get_units

public static float rs2_depth_frame_get_units(@Const
                                              rs2_frame frame,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

retrieve the scaling factor to use when converting a depth frame's get_data() units to meters

Returns:: float - depth, in meters, per 1 unit stored in the frame data

rs2_depth_frame_get_units

public static float rs2_depth_frame_get_units(@Const
                                              rs2_frame frame,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_get_frame_stride_in_bytes

public static int rs2_get_frame_stride_in_bytes(@Const
                                                rs2_frame frame,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

retrieve frame stride in bytes (number of bytes from start of line N to start of line N+1)

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: stride in bytes

rs2_get_frame_stride_in_bytes

public static int rs2_get_frame_stride_in_bytes(@Const
                                                rs2_frame frame,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_get_frame_bits_per_pixel

public static int rs2_get_frame_bits_per_pixel(@Const
                                               rs2_frame frame,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)

retrieve bits per pixels in the frame image (note that bits per pixel is not necessarily divided by 8, as in 12bpp)

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: bits per pixel

rs2_get_frame_bits_per_pixel

public static int rs2_get_frame_bits_per_pixel(@Const
                                               rs2_frame frame,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_frame_add_ref

public static void rs2_frame_add_ref(rs2_frame frame,
                                     @Cast(value="rs2_error**")
                                     PointerPointer error)

create additional reference to a frame without duplicating frame data

Parameters:: frame - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_frame_add_ref

public static void rs2_frame_add_ref(rs2_frame frame,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_release_frame
```
public static void rs2_release_frame(rs2_frame frame)
```
relases the frame handle

Parameters:

frame - [in] handle returned from a callback

rs2_keep_frame
```
public static void rs2_keep_frame(rs2_frame frame)
```
communicate to the library you intend to keep the frame alive for a while this will remove the frame from the regular count of the frame pool once this function is called, the SDK can no longer guarantee 0-allocations during frame cycling

Parameters:

frame - [in] handle returned from a callback

rs2_get_frame_vertices
```
public static rs2_vertex rs2_get_frame_vertices(@Const
                                                rs2_frame frame,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)
```
When called on Points frame type, this method returns a pointer to an array of 3D vertices of the model The coordinate system is: X right, Y up, Z away from the camera. Units: Meters

Parameters:

frame - [in] Points frame

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

Pointer to an array of vertices, lifetime is managed by the frame

rs2_get_frame_vertices

public static rs2_vertex rs2_get_frame_vertices(@Const
                                                rs2_frame frame,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_export_to_ply

public static void rs2_export_to_ply(@Const
                                     rs2_frame frame,
                                     @Cast(value="const char*")
                                     BytePointer fname,
                                     rs2_frame texture,
                                     @Cast(value="rs2_error**")
                                     PointerPointer error)

When called on Points frame type, this method creates a ply file of the model with the given file name.

Parameters:: frame - [in] Points frame; fname - [in] The name for the ply file; texture - [in] Texture frame; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_export_to_ply

public static void rs2_export_to_ply(@Const
                                     rs2_frame frame,
                                     @Cast(value="const char*")
                                     BytePointer fname,
                                     rs2_frame texture,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_export_to_ply

public static void rs2_export_to_ply(@Const
                                     rs2_frame frame,
                                     String fname,
                                     rs2_frame texture,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_get_frame_texture_coordinates

public static rs2_pixel rs2_get_frame_texture_coordinates(@Const
                                                          rs2_frame frame,
                                                          @Cast(value="rs2_error**")
                                                          PointerPointer error)

When called on Points frame type, this method returns a pointer to an array of texture coordinates per vertex Each coordinate represent a (u,v) pair within [0,1] range, to be mapped to texture image

Parameters:: frame - [in] Points frame; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Pointer to an array of texture coordinates, lifetime is managed by the frame

rs2_get_frame_texture_coordinates

public static rs2_pixel rs2_get_frame_texture_coordinates(@Const
                                                          rs2_frame frame,
                                                          @ByPtrPtr
                                                          rs2_error error)

rs2_get_frame_points_count

public static int rs2_get_frame_points_count(@Const
                                             rs2_frame frame,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

When called on Points frame type, this method returns the number of vertices in the frame

Parameters:: frame - [in] Points frame; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Number of vertices

rs2_get_frame_points_count

public static int rs2_get_frame_points_count(@Const
                                             rs2_frame frame,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_get_frame_stream_profile

@Const
public static rs2_stream_profile rs2_get_frame_stream_profile(@Const
                                                                      rs2_frame frame,
                                                                      @Cast(value="rs2_error**")
                                                                      PointerPointer error)

Returns the stream profile that was used to start the stream of this frame

Parameters:: frame - [in] frame reference, owned by the user; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Pointer to the stream profile object, lifetime is managed elsewhere

rs2_get_frame_stream_profile

@Const
public static rs2_stream_profile rs2_get_frame_stream_profile(@Const
                                                                      rs2_frame frame,
                                                                      @ByPtrPtr
                                                                      rs2_error error)

rs2_is_frame_extendable_to

public static int rs2_is_frame_extendable_to(@Const
                                             rs2_frame frame,
                                             @Cast(value="rs2_extension")
                                             int extension_type,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

Test if the given frame can be extended to the requested extension

Parameters:: frame - [in] Realsense frame; extension_type - [in] The extension to which the frame should be tested if it is extendable; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: non-zero value iff the frame can be extended to the given extension

rs2_is_frame_extendable_to

public static int rs2_is_frame_extendable_to(@Const
                                             rs2_frame frame,
                                             @Cast(value="rs2_extension")
                                             int extension_type,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_allocate_synthetic_video_frame

public static rs2_frame rs2_allocate_synthetic_video_frame(rs2_source source,
                                                           @Const
                                                           rs2_stream_profile new_stream,
                                                           rs2_frame original,
                                                           int new_bpp,
                                                           int new_width,
                                                           int new_height,
                                                           int new_stride,
                                                           @Cast(value="rs2_extension")
                                                           int frame_type,
                                                           @Cast(value="rs2_error**")
                                                           PointerPointer error)

Allocate new video frame using a frame-source provided form a processing block

Parameters:: source - [in] Frame pool to allocate the frame from; new_stream - [in] New stream profile to assign to newly created frame; original - [in] A reference frame that can be used to fill in auxilary information like format, width, height, bpp, stride (if applicable); new_bpp - [in] New value for bits per pixel for the allocated frame; new_width - [in] New value for width for the allocated frame; new_height - [in] New value for height for the allocated frame; new_stride - [in] New value for stride in bytes for the allocated frame; frame_type - [in] New value for frame type for the allocated frame; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: reference to a newly allocated frame, must be released with release_frame memory for the frame is likely to be re-used from previous frame, but in lack of available frames in the pool will be allocated from the free store

rs2_allocate_synthetic_video_frame

public static rs2_frame rs2_allocate_synthetic_video_frame(rs2_source source,
                                                           @Const
                                                           rs2_stream_profile new_stream,
                                                           rs2_frame original,
                                                           int new_bpp,
                                                           int new_width,
                                                           int new_height,
                                                           int new_stride,
                                                           @Cast(value="rs2_extension")
                                                           int frame_type,
                                                           @ByPtrPtr
                                                           rs2_error error)

rs2_allocate_synthetic_motion_frame

public static rs2_frame rs2_allocate_synthetic_motion_frame(rs2_source source,
                                                            @Const
                                                            rs2_stream_profile new_stream,
                                                            rs2_frame original,
                                                            @Cast(value="rs2_extension")
                                                            int frame_type,
                                                            @Cast(value="rs2_error**")
                                                            PointerPointer error)

Allocate new motion frame using a frame-source provided form a processing block

Parameters:: source - [in] Frame pool to allocate the frame from; new_stream - [in] New stream profile to assign to newly created frame; original - [in] A reference frame that can be used to fill in auxilary information like format, width, height, bpp, stride (if applicable); frame_type - [in] New value for frame type for the allocated frame; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: reference to a newly allocated frame, must be released with release_frame memory for the frame is likely to be re-used from previous frame, but in lack of available frames in the pool will be allocated from the free store

rs2_allocate_synthetic_motion_frame

public static rs2_frame rs2_allocate_synthetic_motion_frame(rs2_source source,
                                                            @Const
                                                            rs2_stream_profile new_stream,
                                                            rs2_frame original,
                                                            @Cast(value="rs2_extension")
                                                            int frame_type,
                                                            @ByPtrPtr
                                                            rs2_error error)

rs2_allocate_points
```
public static rs2_frame rs2_allocate_points(rs2_source source,
                                            @Const
                                            rs2_stream_profile new_stream,
                                            rs2_frame original,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)
```
Allocate new points frame using a frame-source provided from a processing block

Parameters:

source - [in] Frame pool to allocate the frame from

new_stream - [in] New stream profile to assign to newly created frame

original - [in] A reference frame that can be used to fill in auxilary information like format, width, height, bpp, stride (if applicable)

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

reference to a newly allocated frame, must be released with release_frame memory for the frame is likely to be re-used from previous frame, but in lack of available frames in the pool will be allocated from the free store

rs2_allocate_points

public static rs2_frame rs2_allocate_points(rs2_source source,
                                            @Const
                                            rs2_stream_profile new_stream,
                                            rs2_frame original,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_allocate_composite_frame

public static rs2_frame rs2_allocate_composite_frame(rs2_source source,
                                                     @Cast(value="rs2_frame**")
                                                     PointerPointer frames,
                                                     int count,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)

Allocate new composite frame, aggregating a set of existing frames

Parameters:: source - [in] Frame pool to allocate the frame from; frames - [in] Array of existing frames; count - [in] Number of input frames; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: reference to a newly allocated frame, must be released with release_frame when composite frame gets released it will automatically release all of the input frames

rs2_allocate_composite_frame

public static rs2_frame rs2_allocate_composite_frame(rs2_source source,
                                                     @ByPtrPtr
                                                     rs2_frame frames,
                                                     int count,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_extract_frame
```
public static rs2_frame rs2_extract_frame(rs2_frame composite,
                                          int index,
                                          @Cast(value="rs2_error**")
                                          PointerPointer error)
```
Extract frame from within a composite frame

Parameters:

composite - [in] Composite frame

index - [in] Index of the frame to extract within the composite frame

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

returns reference to a frame existing within the composite frame If you wish to keep this frame after the composite is released, you need to call acquire_ref Otherwise the resulting frame lifetime is bound by owning composite frame

rs2_extract_frame

public static rs2_frame rs2_extract_frame(rs2_frame composite,
                                          int index,
                                          @ByPtrPtr
                                          rs2_error error)

rs2_embedded_frames_count

public static int rs2_embedded_frames_count(rs2_frame composite,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

Get number of frames embedded within a composite frame

Parameters:: composite - [in] Composite input frame; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Number of embedded frames

rs2_embedded_frames_count

public static int rs2_embedded_frames_count(rs2_frame composite,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_synthetic_frame_ready

public static void rs2_synthetic_frame_ready(rs2_source source,
                                             rs2_frame frame,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

This method will dispatch frame callback on a frame

Parameters:: source - [in] Frame pool provided by the processing block; frame - [in] Frame to dispatch, frame ownership is passed to this function, so you don't have to call release_frame after it; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_synthetic_frame_ready

public static void rs2_synthetic_frame_ready(rs2_source source,
                                             rs2_frame frame,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_pose_frame_get_pose_data

public static void rs2_pose_frame_get_pose_data(@Const
                                                rs2_frame frame,
                                                rs2_pose pose,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

When called on Pose frame type, this method returns the transformation represented by the pose data

Parameters:: frame - [in] Pose frame; pose - [out] Pointer to a user allocated struct, which contains the pose info after a successful return; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_pose_frame_get_pose_data

public static void rs2_pose_frame_get_pose_data(@Const
                                                rs2_frame frame,
                                                rs2_pose pose,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_extract_target_dimensions

public static void rs2_extract_target_dimensions(@Const
                                                 rs2_frame frame,
                                                 @Cast(value="rs2_calib_target_type")
                                                 int calib_type,
                                                 FloatPointer target_dims,
                                                 @Cast(value="unsigned int")
                                                 int target_dims_size,
                                                 @Cast(value="rs2_error**")
                                                 PointerPointer error)

Extract the target dimensions on the specific target

Parameters:: frame - [in] Left or right camera frame of specified size based on the target type; calib_type - [in] Calibration target type; target_dims_size - [in] Target dimension array size. 4 for RS2_CALIB_TARGET_RECT_GAUSSIAN_DOT_VERTICES and 8 for RS2_CALIB_TARGET_POS_GAUSSIAN_DOT_VERTICES.; target_dims - [out] The array to hold the result target dimensions calculated. For type RS2_CALIB_TARGET_RECT_GAUSSIAN_DOT_VERTICES, the four rectangle side sizes in pixels with the order of top, bottom, left, and right For type RS2_CALIB_TARGET_POS_GAUSSIAN_DOT_VERTICES, the four vertices coordinates in pixels with the order of top, bottom, left, and right; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_extract_target_dimensions

public static void rs2_extract_target_dimensions(@Const
                                                 rs2_frame frame,
                                                 @Cast(value="rs2_calib_target_type")
                                                 int calib_type,
                                                 FloatPointer target_dims,
                                                 @Cast(value="unsigned int")
                                                 int target_dims_size,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_extract_target_dimensions

public static void rs2_extract_target_dimensions(@Const
                                                 rs2_frame frame,
                                                 @Cast(value="rs2_calib_target_type")
                                                 int calib_type,
                                                 FloatBuffer target_dims,
                                                 @Cast(value="unsigned int")
                                                 int target_dims_size,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_extract_target_dimensions

public static void rs2_extract_target_dimensions(@Const
                                                 rs2_frame frame,
                                                 @Cast(value="rs2_calib_target_type")
                                                 int calib_type,
                                                 float[] target_dims,
                                                 @Cast(value="unsigned int")
                                                 int target_dims_size,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_option_to_string

@Cast(value="const char*")
public static BytePointer rs2_option_to_string(@Cast(value="rs2_option")
                                                                           int option)

rs2_sr300_visual_preset_to_string

@Cast(value="const char*")
public static BytePointer rs2_sr300_visual_preset_to_string(@Cast(value="rs2_sr300_visual_preset")
                                                                                        int preset)

rs2_rs400_visual_preset_to_string

@Cast(value="const char*")
public static BytePointer rs2_rs400_visual_preset_to_string(@Cast(value="rs2_rs400_visual_preset")
                                                                                        int preset)

rs2_l500_visual_preset_to_string

@Cast(value="const char*")
public static BytePointer rs2_l500_visual_preset_to_string(@Cast(value="rs2_l500_visual_preset")
                                                                                       int preset)

rs2_sensor_mode_to_string

@Cast(value="const char*")
public static BytePointer rs2_sensor_mode_to_string(@Cast(value="rs2_sensor_mode")
                                                                                int preset)

rs2_host_perf_mode_to_string

@Cast(value="const char*")
public static BytePointer rs2_host_perf_mode_to_string(@Cast(value="rs2_host_perf_mode")
                                                                                   int perf)

rs2_emitter_frequency_mode_to_string

@Cast(value="const char*")
public static BytePointer rs2_emitter_frequency_mode_to_string(@Cast(value="rs2_emitter_frequency_mode")
                                                                                           int mode)

rs2_is_option_read_only

public static int rs2_is_option_read_only(@Const
                                          rs2_options options,
                                          @Cast(value="rs2_option")
                                          int option,
                                          @Cast(value="rs2_error**")
                                          PointerPointer error)

check if an option is read-only

Parameters:: options - [in] the options container; option - [in] option id to be checked; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if option is read-only

rs2_is_option_read_only

public static int rs2_is_option_read_only(@Const
                                          rs2_options options,
                                          @Cast(value="rs2_option")
                                          int option,
                                          @ByPtrPtr
                                          rs2_error error)

rs2_get_option

public static float rs2_get_option(@Const
                                   rs2_options options,
                                   @Cast(value="rs2_option")
                                   int option,
                                   @Cast(value="rs2_error**")
                                   PointerPointer error)

read option value from the sensor

Parameters:: options - [in] the options container; option - [in] option id to be queried; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: value of the option

rs2_get_option

public static float rs2_get_option(@Const
                                   rs2_options options,
                                   @Cast(value="rs2_option")
                                   int option,
                                   @ByPtrPtr
                                   rs2_error error)

rs2_set_option

public static void rs2_set_option(@Const
                                  rs2_options options,
                                  @Cast(value="rs2_option")
                                  int option,
                                  float value,
                                  @Cast(value="rs2_error**")
                                  PointerPointer error)

write new value to sensor option

Parameters:: options - [in] the options container; option - [in] option id to be queried; value - [in] new value for the option; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_option

public static void rs2_set_option(@Const
                                  rs2_options options,
                                  @Cast(value="rs2_option")
                                  int option,
                                  float value,
                                  @ByPtrPtr
                                  rs2_error error)

rs2_get_options_list

public static rs2_options_list rs2_get_options_list(@Const
                                                    rs2_options options,
                                                    @Cast(value="rs2_error**")
                                                    PointerPointer error)

get the list of supported options of options container

Parameters:: options - [in] the options container; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_options_list

public static rs2_options_list rs2_get_options_list(@Const
                                                    rs2_options options,
                                                    @ByPtrPtr
                                                    rs2_error error)

rs2_get_options_list_size

public static int rs2_get_options_list_size(@Const
                                            rs2_options_list options,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

get the size of options list

Parameters:: options - [in] the option list; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_options_list_size

public static int rs2_get_options_list_size(@Const
                                            rs2_options_list options,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_get_option_name

@Cast(value="const char*")
public static BytePointer rs2_get_option_name(@Const
                                                                          rs2_options options,
                                                                          @Cast(value="rs2_option")
                                                                          int option,
                                                                          @Cast(value="rs2_error**")
                                                                          PointerPointer error)

get option name

Parameters:: options - [in] the options container; option - [in] option id to be checked; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: human-readable option name

rs2_get_option_name

@Cast(value="const char*")
public static BytePointer rs2_get_option_name(@Const
                                                                          rs2_options options,
                                                                          @Cast(value="rs2_option")
                                                                          int option,
                                                                          @ByPtrPtr
                                                                          rs2_error error)

rs2_get_option_from_list

@Cast(value="rs2_option")
public static int rs2_get_option_from_list(@Const
                                                                      rs2_options_list options,
                                                                      int i,
                                                                      @Cast(value="rs2_error**")
                                                                      PointerPointer error)

get the specific option from options list

Parameters:: i - [in] the index of the option; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_option_from_list

@Cast(value="rs2_option")
public static int rs2_get_option_from_list(@Const
                                                                      rs2_options_list options,
                                                                      int i,
                                                                      @ByPtrPtr
                                                                      rs2_error error)

rs2_delete_options_list
```
public static void rs2_delete_options_list(rs2_options_list list)
```
Deletes options list

Parameters:

list - [in] list to delete

rs2_supports_option

public static int rs2_supports_option(@Const
                                      rs2_options options,
                                      @Cast(value="rs2_option")
                                      int option,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

check if particular option is supported by a subdevice

Parameters:: options - [in] the options container; option - [in] option id to be checked; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if option is supported

rs2_supports_option

public static int rs2_supports_option(@Const
                                      rs2_options options,
                                      @Cast(value="rs2_option")
                                      int option,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_get_option_range

public static void rs2_get_option_range(@Const
                                        rs2_options sensor,
                                        @Cast(value="rs2_option")
                                        int option,
                                        FloatPointer min,
                                        FloatPointer max,
                                        FloatPointer step,
                                        FloatPointer def,
                                        @Cast(value="rs2_error**")
                                        PointerPointer error)

retrieve the available range of values of a supported option

Parameters:: sensor - [in] the RealSense device; option - [in] the option whose range should be queried; min - [out] the minimum value which will be accepted for this option; max - [out] the maximum value which will be accepted for this option; step - [out] the granularity of options which accept discrete values, or zero if the option accepts continuous values; def - [out] the default value of the option; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_option_range

public static void rs2_get_option_range(@Const
                                        rs2_options sensor,
                                        @Cast(value="rs2_option")
                                        int option,
                                        FloatPointer min,
                                        FloatPointer max,
                                        FloatPointer step,
                                        FloatPointer def,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_get_option_range

public static void rs2_get_option_range(@Const
                                        rs2_options sensor,
                                        @Cast(value="rs2_option")
                                        int option,
                                        FloatBuffer min,
                                        FloatBuffer max,
                                        FloatBuffer step,
                                        FloatBuffer def,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_get_option_range

public static void rs2_get_option_range(@Const
                                        rs2_options sensor,
                                        @Cast(value="rs2_option")
                                        int option,
                                        float[] min,
                                        float[] max,
                                        float[] step,
                                        float[] def,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_get_option_description

@Cast(value="const char*")
public static BytePointer rs2_get_option_description(@Const
                                                                                 rs2_options options,
                                                                                 @Cast(value="rs2_option")
                                                                                 int option,
                                                                                 @Cast(value="rs2_error**")
                                                                                 PointerPointer error)

get option description

Parameters:: options - [in] the options container; option - [in] option id to be checked; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: human-readable option description

rs2_get_option_description

@Cast(value="const char*")
public static BytePointer rs2_get_option_description(@Const
                                                                                 rs2_options options,
                                                                                 @Cast(value="rs2_option")
                                                                                 int option,
                                                                                 @ByPtrPtr
                                                                                 rs2_error error)

rs2_get_option_value_description

@Cast(value="const char*")
public static BytePointer rs2_get_option_value_description(@Const
                                                                                       rs2_options options,
                                                                                       @Cast(value="rs2_option")
                                                                                       int option,
                                                                                       float value,
                                                                                       @Cast(value="rs2_error**")
                                                                                       PointerPointer error)

get option value description (in case specific option value hold special meaning)

Parameters:: options - [in] the options container; option - [in] option id to be checked; value - [in] value of the option; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: human-readable description of a specific value of an option or null if no special meaning

rs2_get_option_value_description

@Cast(value="const char*")
public static BytePointer rs2_get_option_value_description(@Const
                                                                                       rs2_options options,
                                                                                       @Cast(value="rs2_option")
                                                                                       int option,
                                                                                       float value,
                                                                                       @ByPtrPtr
                                                                                       rs2_error error)

rs2_create_colorizer
```
public static rs2_processing_block rs2_create_colorizer(@Cast(value="rs2_error**")
                                                        PointerPointer error)
```
Creates Depth-Colorizer processing block that can be used to quickly visualize the depth data This block will accept depth frames as input and replace them by depth frames with format RGB8 Non-depth frames are passed through Further customization will be added soon (format, color-map, histogram equalization control)

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_colorizer

public static rs2_processing_block rs2_create_colorizer(@ByPtrPtr
                                                        rs2_error error)

rs2_create_sync_processing_block
```
public static rs2_processing_block rs2_create_sync_processing_block(@Cast(value="rs2_error**")
                                                                    PointerPointer error)
```
Creates Sync processing block. This block accepts arbitrary frames and output composite frames of best matches Some frames may be released within the syncer if they are waiting for match for too long Syncronization is done (mostly) based on timestamps so good hardware timestamps are a pre-condition

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_sync_processing_block

public static rs2_processing_block rs2_create_sync_processing_block(@ByPtrPtr
                                                                    rs2_error error)

rs2_create_pointcloud
```
public static rs2_processing_block rs2_create_pointcloud(@Cast(value="rs2_error**")
                                                         PointerPointer error)
```
Creates Point-Cloud processing block. This block accepts depth frames and outputs Points frames In addition, given non-depth frame, the block will align texture coordinate to the non-depth stream

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_pointcloud

public static rs2_processing_block rs2_create_pointcloud(@ByPtrPtr
                                                         rs2_error error)

rs2_create_yuy_decoder
```
public static rs2_processing_block rs2_create_yuy_decoder(@Cast(value="rs2_error**")
                                                          PointerPointer error)
```
Creates YUY decoder processing block. This block accepts raw YUY frames and outputs frames of other formats. YUY is a common video format used by a variety of web-cams. It benefits from packing pixels into 2 bytes per pixel without signficant quality drop. YUY representation can be converted back to more usable RGB form, but this requires somewhat costly conversion. The SDK will automatically try to use SSE2 and AVX instructions and CUDA where available to get best performance. Other implementations (using GLSL, OpenCL, Neon and NCS) should follow.

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_yuy_decoder

public static rs2_processing_block rs2_create_yuy_decoder(@ByPtrPtr
                                                          rs2_error error)

rs2_create_threshold
```
public static rs2_processing_block rs2_create_threshold(@Cast(value="rs2_error**")
                                                        PointerPointer error)
```
Creates depth thresholding processing block By controlling min and max options on the block, one could filter out depth values that are either too large or too small, as a software post-processing step

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_threshold

public static rs2_processing_block rs2_create_threshold(@ByPtrPtr
                                                        rs2_error error)

rs2_create_units_transform
```
public static rs2_processing_block rs2_create_units_transform(@Cast(value="rs2_error**")
                                                              PointerPointer error)
```
Creates depth units transformation processing block All of the pixels are transformed from depth units into meters.

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_units_transform

public static rs2_processing_block rs2_create_units_transform(@ByPtrPtr
                                                              rs2_error error)

rs2_create_processing_block
```
public static rs2_processing_block rs2_create_processing_block(rs2_frame_processor_callback proc,
                                                               @Cast(value="rs2_error**")
                                                               PointerPointer error)
```
This method creates new custom processing block. This lets the users pass frames between module boundaries for processing This is an infrastructure function aimed at middleware developers, and also used by provided blocks such as sync, colorizer, etc..

Parameters:

proc - Processing function to be applied to every frame entering the block

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

new processing block, to be released by rs2_delete_processing_block

rs2_create_processing_block

public static rs2_processing_block rs2_create_processing_block(rs2_frame_processor_callback proc,
                                                               @ByPtrPtr
                                                               rs2_error error)

rs2_create_processing_block_fptr
```
public static rs2_processing_block rs2_create_processing_block_fptr(rs2_frame_processor_callback_ptr proc,
                                                                    Pointer context,
                                                                    @Cast(value="rs2_error**")
                                                                    PointerPointer error)
```
This method creates new custom processing block from function pointer. This lets the users pass frames between module boundaries for processing This is an infrastructure function aimed at middleware developers, and also used by provided blocks such as sync, colorizer, etc..

Parameters:

proc - Processing function pointer to be applied to every frame entering the block

context - User context (can be anything or null) to be passed later as ctx param of the callback

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

new processing block, to be released by rs2_delete_processing_block

rs2_create_processing_block_fptr

public static rs2_processing_block rs2_create_processing_block_fptr(rs2_frame_processor_callback_ptr proc,
                                                                    Pointer context,
                                                                    @ByPtrPtr
                                                                    rs2_error error)

rs2_processing_block_register_simple_option
```
public static int rs2_processing_block_register_simple_option(rs2_processing_block block,
                                                              @Cast(value="rs2_option")
                                                              int option_id,
                                                              float min,
                                                              float max,
                                                              float step,
                                                              float def,
                                                              @Cast(value="rs2_error**")
                                                              PointerPointer error)
```
This method adds a custom option to a custom processing block. This is a simple float that can be accessed via rs2_set_option and rs2_get_option This is an infrastructure function aimed at middleware developers, and also used by provided blocks such as save_to_ply, etc..

Parameters:

block - [in] Processing block

option_id - [in] an int ID for referencing the option

min - [in] the minimum value which will be accepted for this option

max - [in] the maximum value which will be accepted for this option

step - [in] the granularity of options which accept discrete values, or zero if the option accepts continuous values

def - [in] the default value of the option. This will be the initial value.

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

true if adding the option succeeds. false if it fails e.g. an option with this id is already registered

rs2_processing_block_register_simple_option

public static int rs2_processing_block_register_simple_option(rs2_processing_block block,
                                                              @Cast(value="rs2_option")
                                                              int option_id,
                                                              float min,
                                                              float max,
                                                              float step,
                                                              float def,
                                                              @ByPtrPtr
                                                              rs2_error error)

rs2_start_processing

public static void rs2_start_processing(rs2_processing_block block,
                                        rs2_frame_callback on_frame,
                                        @Cast(value="rs2_error**")
                                        PointerPointer error)

This method is used to direct the output from the processing block to some callback or sink object

Parameters:: block - [in] Processing block; on_frame - [in] Callback to be invoked every time the processing block calls frame_ready; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_start_processing

public static void rs2_start_processing(rs2_processing_block block,
                                        rs2_frame_callback on_frame,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_start_processing_fptr

public static void rs2_start_processing_fptr(rs2_processing_block block,
                                             rs2_frame_callback_ptr on_frame,
                                             Pointer user,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

This method is used to direct the output from the processing block to some callback or sink object

Parameters:: block - [in] Processing block; on_frame - [in] Callback function to be invoked every time the processing block calls frame_ready; user - [in] User context for the callback (can be anything or null); error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_start_processing_fptr

public static void rs2_start_processing_fptr(rs2_processing_block block,
                                             rs2_frame_callback_ptr on_frame,
                                             Pointer user,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_start_processing_queue

public static void rs2_start_processing_queue(rs2_processing_block block,
                                              rs2_frame_queue queue,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

This method is used to direct the output from the processing block to a dedicated queue object

Parameters:: block - [in] Processing block; queue - [in] Queue to place the processed frames to; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_start_processing_queue

public static void rs2_start_processing_queue(rs2_processing_block block,
                                              rs2_frame_queue queue,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_process_frame

public static void rs2_process_frame(rs2_processing_block block,
                                     rs2_frame frame,
                                     @Cast(value="rs2_error**")
                                     PointerPointer error)

This method is used to pass frame into a processing block

Parameters:: block - [in] Processing block; frame - [in] Frame to process, ownership is moved to the block object; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_process_frame

public static void rs2_process_frame(rs2_processing_block block,
                                     rs2_frame frame,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_delete_processing_block
```
public static void rs2_delete_processing_block(rs2_processing_block block)
```
Deletes the processing block

Parameters:

block - [in] Processing block

rs2_create_frame_queue
```
public static rs2_frame_queue rs2_create_frame_queue(int _capacity,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)
```
create frame queue. frame queues are the simplest x-platform synchronization primitive provided by librealsense to help developers who are not using async APIs

Parameters:

capacity - [in] max number of frames to allow to be stored in the queue before older frames will start to get dropped

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

handle to the frame queue, must be released using rs2_delete_frame_queue

rs2_create_frame_queue

public static rs2_frame_queue rs2_create_frame_queue(int _capacity,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_delete_frame_queue
```
public static void rs2_delete_frame_queue(rs2_frame_queue queue)
```
deletes frame queue and releases all frames inside it

Parameters:

queue - [in] queue to delete

rs2_frame_queue_size

public static int rs2_frame_queue_size(rs2_frame_queue queue,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

queries the number of frames

Parameters:: queue - [in] to delete
Returns:: the number of frames currently stored in queue

rs2_frame_queue_size

public static int rs2_frame_queue_size(rs2_frame_queue queue,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_wait_for_frame

public static rs2_frame rs2_wait_for_frame(rs2_frame_queue queue,
                                           @Cast(value="unsigned int")
                                           int timeout_ms,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

wait until new frame becomes available in the queue and dequeue it

Parameters:: queue - [in] the frame queue data structure; timeout_ms - [in] max time in milliseconds to wait until an exception will be thrown; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: frame handle to be released using rs2_release_frame

rs2_wait_for_frame

public static rs2_frame rs2_wait_for_frame(rs2_frame_queue queue,
                                           @Cast(value="unsigned int")
                                           int timeout_ms,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_poll_for_frame

public static int rs2_poll_for_frame(rs2_frame_queue queue,
                                     @Cast(value="rs2_frame**")
                                     PointerPointer output_frame,
                                     @Cast(value="rs2_error**")
                                     PointerPointer error)

poll if a new frame is available and dequeue if it is

Parameters:: queue - [in] the frame queue data structure; output_frame - [out] frame handle to be released using rs2_release_frame; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if new frame was stored to output_frame

rs2_poll_for_frame

public static int rs2_poll_for_frame(rs2_frame_queue queue,
                                     @ByPtrPtr
                                     rs2_frame output_frame,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_try_wait_for_frame

public static int rs2_try_wait_for_frame(rs2_frame_queue queue,
                                         @Cast(value="unsigned int")
                                         int timeout_ms,
                                         @Cast(value="rs2_frame**")
                                         PointerPointer output_frame,
                                         @Cast(value="rs2_error**")
                                         PointerPointer error)

wait until new frame becomes available in the queue and dequeue it

Parameters:: queue - [in] the frame queue data structure; timeout_ms - [in] max time in milliseconds to wait until a frame becomes available; output_frame - [out] frame handle to be released using rs2_release_frame; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if new frame was stored to output_frame

rs2_try_wait_for_frame

public static int rs2_try_wait_for_frame(rs2_frame_queue queue,
                                         @Cast(value="unsigned int")
                                         int timeout_ms,
                                         @ByPtrPtr
                                         rs2_frame output_frame,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_enqueue_frame
```
public static void rs2_enqueue_frame(rs2_frame frame,
                                     Pointer queue)
```
enqueue new frame into a queue

Parameters:

frame - [in] frame handle to enqueue (this operation passed ownership to the queue)

queue - [in] the frame queue data structure

rs2_create_align

public static rs2_processing_block rs2_create_align(@Cast(value="rs2_stream")
                                                    int align_to,
                                                    @Cast(value="rs2_error**")
                                                    PointerPointer error)

Creates Align processing block.

Parameters:: align_to - [in] stream type to be used as the target of frameset alignment; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_align

public static rs2_processing_block rs2_create_align(@Cast(value="rs2_stream")
                                                    int align_to,
                                                    @ByPtrPtr
                                                    rs2_error error)

rs2_create_decimation_filter_block
```
public static rs2_processing_block rs2_create_decimation_filter_block(@Cast(value="rs2_error**")
                                                                      PointerPointer error)
```
Creates Depth post-processing filter block. This block accepts depth frames, applies decimation filter and plots modified prames Note that due to the modifiedframe size, the decimated frame repaces the original one

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_decimation_filter_block

public static rs2_processing_block rs2_create_decimation_filter_block(@ByPtrPtr
                                                                      rs2_error error)

rs2_create_temporal_filter_block

public static rs2_processing_block rs2_create_temporal_filter_block(@Cast(value="rs2_error**")
                                                                    PointerPointer error)

Creates Depth post-processing filter block. This block accepts depth frames, applies temporal filter

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_temporal_filter_block

public static rs2_processing_block rs2_create_temporal_filter_block(@ByPtrPtr
                                                                    rs2_error error)

rs2_create_spatial_filter_block
```
public static rs2_processing_block rs2_create_spatial_filter_block(@Cast(value="rs2_error**")
                                                                   PointerPointer error)
```
Creates Depth post-processing spatial filter block. This block accepts depth frames, applies spatial filters and plots modified prames

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_spatial_filter_block

public static rs2_processing_block rs2_create_spatial_filter_block(@ByPtrPtr
                                                                   rs2_error error)

rs2_create_disparity_transform_block

public static rs2_processing_block rs2_create_disparity_transform_block(@Cast(value="unsigned char")
                                                                        byte transform_to_disparity,
                                                                        @Cast(value="rs2_error**")
                                                                        PointerPointer error)

Creates a post processing block that provides for depth<->disparity domain transformation for stereo-based depth modules

Parameters:: transform_to_disparity - [in] flag select the transform direction: true = depth->disparity, and vice versa; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_disparity_transform_block

public static rs2_processing_block rs2_create_disparity_transform_block(@Cast(value="unsigned char")
                                                                        byte transform_to_disparity,
                                                                        @ByPtrPtr
                                                                        rs2_error error)

rs2_create_hole_filling_filter_block
```
public static rs2_processing_block rs2_create_hole_filling_filter_block(@Cast(value="rs2_error**")
                                                                        PointerPointer error)
```
Creates Depth post-processing hole filling block. The filter replaces empty pixels with data from adjacent pixels based on the method selected

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_hole_filling_filter_block

public static rs2_processing_block rs2_create_hole_filling_filter_block(@ByPtrPtr
                                                                        rs2_error error)

rs2_create_rates_printer_block
```
public static rs2_processing_block rs2_create_rates_printer_block(@Cast(value="rs2_error**")
                                                                  PointerPointer error)
```
Creates a rates printer block. The printer prints the actual FPS of the invoked frame stream. The block ignores reapiting frames and calculats the FPS only if the frame number of the relevant frame was changed.

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_rates_printer_block

public static rs2_processing_block rs2_create_rates_printer_block(@ByPtrPtr
                                                                  rs2_error error)

rs2_create_zero_order_invalidation_block
```
public static rs2_processing_block rs2_create_zero_order_invalidation_block(@Cast(value="rs2_error**")
                                                                            PointerPointer error)
```
Creates Depth post-processing zero order fix block. The filter invalidates pixels that has a wrong value due to zero order effect

Parameters:

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

zero order fix processing block

rs2_create_zero_order_invalidation_block

public static rs2_processing_block rs2_create_zero_order_invalidation_block(@ByPtrPtr
                                                                            rs2_error error)

rs2_create_huffman_depth_decompress_block
```
public static rs2_processing_block rs2_create_huffman_depth_decompress_block(@Cast(value="rs2_error**")
                                                                             PointerPointer error)
```
Creates Depth frame decompression module. Decoded frames compressed and transmitted with Z16H variable-lenght Huffman code to standartized Z16 Depth data format. Using the compression allows to reduce the Depth frames bandwidth by more than 50 percent

Parameters:

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

Huffman-code decompression processing block

rs2_create_huffman_depth_decompress_block

public static rs2_processing_block rs2_create_huffman_depth_decompress_block(@ByPtrPtr
                                                                             rs2_error error)

rs2_create_hdr_merge_processing_block

public static rs2_processing_block rs2_create_hdr_merge_processing_block(@Cast(value="rs2_error**")
                                                                         PointerPointer error)

Creates a hdr_merge processing block. The block merges between two depth frames with different exposure values

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_hdr_merge_processing_block

public static rs2_processing_block rs2_create_hdr_merge_processing_block(@ByPtrPtr
                                                                         rs2_error error)

rs2_create_sequence_id_filter
```
public static rs2_processing_block rs2_create_sequence_id_filter(@Cast(value="rs2_error**")
                                                                 PointerPointer error)
```
Creates a sequence_id_filter processing block. The block lets frames with the selected sequence id pass and blocks frames with other values

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_sequence_id_filter

public static rs2_processing_block rs2_create_sequence_id_filter(@ByPtrPtr
                                                                 rs2_error error)

rs2_get_processing_block_info

@Cast(value="const char*")
public static BytePointer rs2_get_processing_block_info(@Const
                                                                                    rs2_processing_block block,
                                                                                    @Cast(value="rs2_camera_info")
                                                                                    int info,
                                                                                    @Cast(value="rs2_error**")
                                                                                    PointerPointer error)

Retrieve processing block specific information, like name.

Parameters:: block - [in] The processing block; info - [in] processing block info type to retrieve; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: The requested processing block info string, in a format specific to the device model

rs2_get_processing_block_info

@Cast(value="const char*")
public static BytePointer rs2_get_processing_block_info(@Const
                                                                                    rs2_processing_block block,
                                                                                    @Cast(value="rs2_camera_info")
                                                                                    int info,
                                                                                    @ByPtrPtr
                                                                                    rs2_error error)

rs2_supports_processing_block_info

public static int rs2_supports_processing_block_info(@Const
                                                     rs2_processing_block block,
                                                     @Cast(value="rs2_camera_info")
                                                     int info,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)

Check if a processing block supports a specific info type.

Parameters:: block - [in] The processing block to check; info - [in] The parameter to check for support; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: True if the parameter both exist and well-defined for the specific device

rs2_supports_processing_block_info

public static int rs2_supports_processing_block_info(@Const
                                                     rs2_processing_block block,
                                                     @Cast(value="rs2_camera_info")
                                                     int info,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_is_processing_block_extendable_to

public static int rs2_is_processing_block_extendable_to(@Const
                                                        rs2_processing_block block,
                                                        @Cast(value="rs2_extension")
                                                        int extension_type,
                                                        @Cast(value="rs2_error**")
                                                        PointerPointer error)

Test if the given processing block can be extended to the requested extension

Parameters:: block - [in] processing block; extension - [in] The extension to which the sensor should be tested if it is extendable; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: non-zero value iff the processing block can be extended to the given extension

rs2_is_processing_block_extendable_to

public static int rs2_is_processing_block_extendable_to(@Const
                                                        rs2_processing_block block,
                                                        @Cast(value="rs2_extension")
                                                        int extension_type,
                                                        @ByPtrPtr
                                                        rs2_error error)

rs2_playback_status_to_string

@Cast(value="const char*")
public static BytePointer rs2_playback_status_to_string(@Cast(value="rs2_playback_status")
                                                                                    int status)

rs2_create_record_device

public static rs2_device rs2_create_record_device(@Const
                                                  rs2_device device,
                                                  @Cast(value="const char*")
                                                  BytePointer file,
                                                  @Cast(value="rs2_error**")
                                                  PointerPointer error)

Creates a recording device to record the given device and save it to the given file

Parameters:: device - [in] The device to record; file - [in] The desired path to which the recorder should save the data; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: A pointer to a device that records its data to file, or null in case of failure

rs2_create_record_device

public static rs2_device rs2_create_record_device(@Const
                                                  rs2_device device,
                                                  @Cast(value="const char*")
                                                  BytePointer file,
                                                  @ByPtrPtr
                                                  rs2_error error)

rs2_create_record_device

public static rs2_device rs2_create_record_device(@Const
                                                  rs2_device device,
                                                  String file,
                                                  @ByPtrPtr
                                                  rs2_error error)

rs2_create_record_device_ex

public static rs2_device rs2_create_record_device_ex(@Const
                                                     rs2_device device,
                                                     @Cast(value="const char*")
                                                     BytePointer file,
                                                     int compression_enabled,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)

Creates a recording device to record the given device and save it to the given file

Parameters:: device - [in] The device to record; file - [in] The desired path to which the recorder should save the data; compression_enabled - [in] Indicates if compression is enabled, 0 means false, otherwise true; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: A pointer to a device that records its data to file, or null in case of failure

rs2_create_record_device_ex

public static rs2_device rs2_create_record_device_ex(@Const
                                                     rs2_device device,
                                                     @Cast(value="const char*")
                                                     BytePointer file,
                                                     int compression_enabled,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_create_record_device_ex

public static rs2_device rs2_create_record_device_ex(@Const
                                                     rs2_device device,
                                                     String file,
                                                     int compression_enabled,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_record_device_pause

public static void rs2_record_device_pause(@Const
                                           rs2_device device,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Pause the recording device without stopping the actual device from streaming. Pausing will cause the device to stop writing new data to the file, in particular, frames and changes to extensions

Parameters:: device - [in] A recording device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_record_device_pause

public static void rs2_record_device_pause(@Const
                                           rs2_device device,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_record_device_resume

public static void rs2_record_device_resume(@Const
                                            rs2_device device,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

Unpause the recording device. Resume will cause the device to continue writing new data to the file, in particular, frames and changes to extensions

Parameters:: device - [in] A recording device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_record_device_resume

public static void rs2_record_device_resume(@Const
                                            rs2_device device,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_record_device_filename

@Cast(value="const char*")
public static BytePointer rs2_record_device_filename(@Const
                                                                                 rs2_device device,
                                                                                 @Cast(value="rs2_error**")
                                                                                 PointerPointer error)

Gets the name of the file to which the recorder is writing

Parameters:: device - [in] A recording device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: The name of the file to which the recorder is writing

rs2_record_device_filename

@Cast(value="const char*")
public static BytePointer rs2_record_device_filename(@Const
                                                                                 rs2_device device,
                                                                                 @ByPtrPtr
                                                                                 rs2_error error)

rs2_playback_device_get_file_path

@Cast(value="const char*")
public static BytePointer rs2_playback_device_get_file_path(@Const
                                                                                        rs2_device device,
                                                                                        @Cast(value="rs2_error**")
                                                                                        PointerPointer error)

Gets the path of the file used by the playback device

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Path to the file used by the playback device

rs2_playback_device_get_file_path

@Cast(value="const char*")
public static BytePointer rs2_playback_device_get_file_path(@Const
                                                                                        rs2_device device,
                                                                                        @ByPtrPtr
                                                                                        rs2_error error)

rs2_playback_get_duration

@Cast(value="unsigned long long int")
public static long rs2_playback_get_duration(@Const
                                                                                    rs2_device device,
                                                                                    @Cast(value="rs2_error**")
                                                                                    PointerPointer error)

Gets the total duration of the file in units of nanoseconds

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Total duration of the file in units of nanoseconds

rs2_playback_get_duration

@Cast(value="unsigned long long int")
public static long rs2_playback_get_duration(@Const
                                                                                    rs2_device device,
                                                                                    @ByPtrPtr
                                                                                    rs2_error error)

rs2_playback_seek

public static void rs2_playback_seek(@Const
                                     rs2_device device,
                                     long time,
                                     @Cast(value="rs2_error**")
                                     PointerPointer error)

Set the playback to a specified time point of the played data

Parameters:: device - [in] A playback device.; time - [in] The time point to which playback should seek, expressed in units of nanoseconds (zero value = start); error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_playback_seek

public static void rs2_playback_seek(@Const
                                     rs2_device device,
                                     long time,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_playback_get_position

@Cast(value="unsigned long long int")
public static long rs2_playback_get_position(@Const
                                                                                    rs2_device device,
                                                                                    @Cast(value="rs2_error**")
                                                                                    PointerPointer error)

Gets the current position of the playback in the file in terms of time. Units are expressed in nanoseconds

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Current position of the playback in the file in terms of time. Units are expressed in nanoseconds

rs2_playback_get_position

@Cast(value="unsigned long long int")
public static long rs2_playback_get_position(@Const
                                                                                    rs2_device device,
                                                                                    @ByPtrPtr
                                                                                    rs2_error error)

rs2_playback_device_resume

public static void rs2_playback_device_resume(@Const
                                              rs2_device device,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

Pauses the playback Calling pause() in "Paused" status does nothing If pause() is called while playback status is "Playing" or "Stopped", the playback will not play until resume() is called

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_playback_device_resume

public static void rs2_playback_device_resume(@Const
                                              rs2_device device,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_playback_device_pause

public static void rs2_playback_device_pause(@Const
                                             rs2_device device,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

Un-pauses the playback Calling resume() while playback status is "Playing" or "Stopped" does nothing

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_playback_device_pause

public static void rs2_playback_device_pause(@Const
                                             rs2_device device,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_playback_device_set_real_time
```
public static void rs2_playback_device_set_real_time(@Const
                                                     rs2_device device,
                                                     int real_time,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)
```
Set the playback to work in real time or non real time In real time mode, playback will play the same way the file was recorded. In real time mode if the application takes too long to handle the callback, frames may be dropped. In non real time mode, playback will wait for each callback to finish handling the data before reading the next frame. In this mode no frames will be dropped, and the application controls the frame rate of the playback (according to the callback handler duration).

Parameters:

device - [in] A playback device

real_time - [in] Indicates if real time is requested, 0 means false, otherwise true

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_playback_device_set_real_time

public static void rs2_playback_device_set_real_time(@Const
                                                     rs2_device device,
                                                     int real_time,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_playback_device_is_real_time

public static int rs2_playback_device_is_real_time(@Const
                                                   rs2_device device,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

Indicates if playback is in real time mode or non real time

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: True iff playback is in real time mode. 0 means false, otherwise true

rs2_playback_device_is_real_time

public static int rs2_playback_device_is_real_time(@Const
                                                   rs2_device device,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_playback_device_set_status_changed_callback

public static void rs2_playback_device_set_status_changed_callback(@Const
                                                                   rs2_device device,
                                                                   rs2_playback_status_changed_callback callback,
                                                                   @Cast(value="rs2_error**")
                                                                   PointerPointer error)

Register to receive callback from playback device upon its status changes Callbacks are invoked from the reading thread, any heavy processing in the callback handler will affect the reading thread and may cause frame drops\ high latency

Parameters:: device - [in] A playback device; callback - [in] A callback handler that will be invoked when the playback status changes; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_playback_device_set_status_changed_callback

public static void rs2_playback_device_set_status_changed_callback(@Const
                                                                   rs2_device device,
                                                                   rs2_playback_status_changed_callback callback,
                                                                   @ByPtrPtr
                                                                   rs2_error error)

rs2_playback_device_get_current_status

@Cast(value="rs2_playback_status")
public static int rs2_playback_device_get_current_status(@Const
                                                                                             rs2_device device,
                                                                                             @Cast(value="rs2_error**")
                                                                                             PointerPointer error)

Returns the current state of the playback device

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Current state of the playback

rs2_playback_device_get_current_status

@Cast(value="rs2_playback_status")
public static int rs2_playback_device_get_current_status(@Const
                                                                                             rs2_device device,
                                                                                             @ByPtrPtr
                                                                                             rs2_error error)

rs2_playback_device_set_playback_speed

public static void rs2_playback_device_set_playback_speed(@Const
                                                          rs2_device device,
                                                          float speed,
                                                          @Cast(value="rs2_error**")
                                                          PointerPointer error)

Set the playing speed

Parameters:: device - [in] A playback device; speed - [in] Indicates a multiplication of the speed to play (e.g: 1 = normal, 0.5 twice as slow); error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_playback_device_set_playback_speed

public static void rs2_playback_device_set_playback_speed(@Const
                                                          rs2_device device,
                                                          float speed,
                                                          @ByPtrPtr
                                                          rs2_error error)

rs2_playback_device_stop

public static void rs2_playback_device_stop(@Const
                                            rs2_device device,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

Stops the playback Calling stop() will stop all streaming playbakc sensors and will reset the playback (returning to beginning of file)

Parameters:: device - [in] A playback device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_playback_device_stop

public static void rs2_playback_device_stop(@Const
                                            rs2_device device,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_camera_info_to_string

@Cast(value="const char*")
public static BytePointer rs2_camera_info_to_string(@Cast(value="rs2_camera_info")
                                                                                int info)

rs2_stream_to_string

@Cast(value="const char*")
public static BytePointer rs2_stream_to_string(@Cast(value="rs2_stream")
                                                                           int stream)

rs2_format_to_string

@Cast(value="const char*")
public static BytePointer rs2_format_to_string(@Cast(value="rs2_format")
                                                                           int format)

rs2_delete_sensor_list
```
public static void rs2_delete_sensor_list(rs2_sensor_list info_list)
```
Deletes sensors list, any sensors created from this list will remain unaffected

Parameters:

info_list - [in] list to delete

rs2_get_sensors_count

public static int rs2_get_sensors_count(@Const
                                        rs2_sensor_list info_list,
                                        @Cast(value="rs2_error**")
                                        PointerPointer error)

Determines number of sensors in a list

Parameters:: info_list - [in] The list of connected sensors captured using rs2_query_sensors; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Sensors count

rs2_get_sensors_count

public static int rs2_get_sensors_count(@Const
                                        rs2_sensor_list info_list,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_delete_sensor
```
public static void rs2_delete_sensor(rs2_sensor sensor)
```
delete relasense sensor

Parameters:

sensor - [in] realsense sensor to delete

rs2_create_sensor

public static rs2_sensor rs2_create_sensor(@Const
                                           rs2_sensor_list list,
                                           int index,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

create sensor by index

Parameters:: index - [in] the zero based index of sensor to retrieve; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the requested sensor, should be released by rs2_delete_sensor

rs2_create_sensor

public static rs2_sensor rs2_create_sensor(@Const
                                           rs2_sensor_list list,
                                           int index,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_create_device_from_sensor

public static rs2_device rs2_create_device_from_sensor(@Const
                                                       rs2_sensor sensor,
                                                       @Cast(value="rs2_error**")
                                                       PointerPointer error)

This is a helper function allowing the user to discover the device from one of its sensors

Parameters:: sensor - [in] Pointer to a sensor; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: new device wrapper for the device of the sensor. Needs to be released by delete_device

rs2_create_device_from_sensor

public static rs2_device rs2_create_device_from_sensor(@Const
                                                       rs2_sensor sensor,
                                                       @ByPtrPtr
                                                       rs2_error error)

rs2_get_sensor_info

@Cast(value="const char*")
public static BytePointer rs2_get_sensor_info(@Const
                                                                          rs2_sensor sensor,
                                                                          @Cast(value="rs2_camera_info")
                                                                          int info,
                                                                          @Cast(value="rs2_error**")
                                                                          PointerPointer error)

retrieve sensor specific information, like versions of various internal components

Parameters:: sensor - [in] the RealSense sensor; info - [in] camera info type to retrieve; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the requested camera info string, in a format specific to the device model

rs2_get_sensor_info

@Cast(value="const char*")
public static BytePointer rs2_get_sensor_info(@Const
                                                                          rs2_sensor sensor,
                                                                          @Cast(value="rs2_camera_info")
                                                                          int info,
                                                                          @ByPtrPtr
                                                                          rs2_error error)

rs2_supports_sensor_info

public static int rs2_supports_sensor_info(@Const
                                           rs2_sensor sensor,
                                           @Cast(value="rs2_camera_info")
                                           int info,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

check if specific sensor info is supported

Parameters:: info - [in] the parameter to check for support; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if the parameter both exist and well-defined for the specific device

rs2_supports_sensor_info

public static int rs2_supports_sensor_info(@Const
                                           rs2_sensor sensor,
                                           @Cast(value="rs2_camera_info")
                                           int info,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_is_sensor_extendable_to

public static int rs2_is_sensor_extendable_to(@Const
                                              rs2_sensor sensor,
                                              @Cast(value="rs2_extension")
                                              int extension,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

Test if the given sensor can be extended to the requested extension

Parameters:: sensor - [in] Realsense sensor; extension - [in] The extension to which the sensor should be tested if it is extendable; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: non-zero value iff the sensor can be extended to the given extension

rs2_is_sensor_extendable_to

public static int rs2_is_sensor_extendable_to(@Const
                                              rs2_sensor sensor,
                                              @Cast(value="rs2_extension")
                                              int extension,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_get_depth_scale
```
public static float rs2_get_depth_scale(rs2_sensor sensor,
                                        @Cast(value="rs2_error**")
                                        PointerPointer error)
```
When called on a depth sensor, this method will return the number of meters represented by a single depth unit

Parameters:

sensor - [in] depth sensor

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

the number of meters represented by a single depth unit

rs2_get_depth_scale

public static float rs2_get_depth_scale(rs2_sensor sensor,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_depth_stereo_frame_get_baseline

public static float rs2_depth_stereo_frame_get_baseline(@Const
                                                        rs2_frame frame_ref,
                                                        @Cast(value="rs2_error**")
                                                        PointerPointer error)

Retrieve the stereoscopic baseline value from frame. Applicable to stereo-based depth modules

Parameters:: float - [out] Stereoscopic baseline in millimeters; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_depth_stereo_frame_get_baseline

public static float rs2_depth_stereo_frame_get_baseline(@Const
                                                        rs2_frame frame_ref,
                                                        @ByPtrPtr
                                                        rs2_error error)

rs2_get_stereo_baseline

public static float rs2_get_stereo_baseline(rs2_sensor sensor,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

Retrieve the stereoscopic baseline value from sensor. Applicable to stereo-based depth modules

Parameters:: float - [out] Stereoscopic baseline in millimeters; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_stereo_baseline

public static float rs2_get_stereo_baseline(rs2_sensor sensor,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_set_region_of_interest

public static void rs2_set_region_of_interest(@Const
                                              rs2_sensor sensor,
                                              int min_x,
                                              int min_y,
                                              int max_x,
                                              int max_y,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

\brief sets the active region of interest to be used by auto-exposure algorithm

Parameters:: sensor - [in] the RealSense sensor; min_x - [in] lower horizontal bound in pixels; min_y - [in] lower vertical bound in pixels; max_x - [in] upper horizontal bound in pixels; max_y - [in] upper vertical bound in pixels; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_region_of_interest

public static void rs2_set_region_of_interest(@Const
                                              rs2_sensor sensor,
                                              int min_x,
                                              int min_y,
                                              int max_x,
                                              int max_y,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_get_region_of_interest

public static void rs2_get_region_of_interest(@Const
                                              rs2_sensor sensor,
                                              IntPointer min_x,
                                              IntPointer min_y,
                                              IntPointer max_x,
                                              IntPointer max_y,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

\brief gets the active region of interest to be used by auto-exposure algorithm

Parameters:: sensor - [in] the RealSense sensor; min_x - [out] lower horizontal bound in pixels; min_y - [out] lower vertical bound in pixels; max_x - [out] upper horizontal bound in pixels; max_y - [out] upper vertical bound in pixels; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_region_of_interest

public static void rs2_get_region_of_interest(@Const
                                              rs2_sensor sensor,
                                              IntPointer min_x,
                                              IntPointer min_y,
                                              IntPointer max_x,
                                              IntPointer max_y,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_get_region_of_interest

public static void rs2_get_region_of_interest(@Const
                                              rs2_sensor sensor,
                                              IntBuffer min_x,
                                              IntBuffer min_y,
                                              IntBuffer max_x,
                                              IntBuffer max_y,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_get_region_of_interest

public static void rs2_get_region_of_interest(@Const
                                              rs2_sensor sensor,
                                              int[] min_x,
                                              int[] min_y,
                                              int[] max_x,
                                              int[] max_y,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_open

public static void rs2_open(rs2_sensor device,
                            @Const
                            rs2_stream_profile profile,
                            @Cast(value="rs2_error**")
                            PointerPointer error)

open subdevice for exclusive access, by committing to a configuration

Parameters:: device - [in] relevant RealSense device; profile - [in] stream profile that defines single stream configuration; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_open

public static void rs2_open(rs2_sensor device,
                            @Const
                            rs2_stream_profile profile,
                            @ByPtrPtr
                            rs2_error error)

rs2_open_multiple
```
public static void rs2_open_multiple(rs2_sensor device,
                                     @Cast(value="const rs2_stream_profile**")
                                     PointerPointer profiles,
                                     int count,
                                     @Cast(value="rs2_error**")
                                     PointerPointer error)
```
open subdevice for exclusive access, by committing to composite configuration, specifying one or more stream profiles this method should be used for interdependent streams, such as depth and infrared, that have to be configured together

Parameters:

device - [in] relevant RealSense device

profiles - [in] list of stream profiles discovered by get_stream_profiles

count - [in] number of simultaneous stream profiles to configure

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_open_multiple

public static void rs2_open_multiple(rs2_sensor device,
                                     @Const @ByPtrPtr
                                     rs2_stream_profile profiles,
                                     int count,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_close

public static void rs2_close(@Const
                             rs2_sensor sensor,
                             @Cast(value="rs2_error**")
                             PointerPointer error)

stop any streaming from specified subdevice

Parameters:: sensor - [in] RealSense device; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_close

public static void rs2_close(@Const
                             rs2_sensor sensor,
                             @ByPtrPtr
                             rs2_error error)

rs2_start

public static void rs2_start(@Const
                             rs2_sensor sensor,
                             rs2_frame_callback_ptr on_frame,
                             Pointer user,
                             @Cast(value="rs2_error**")
                             PointerPointer error)

start streaming from specified configured sensor

Parameters:: sensor - [in] RealSense device; on_frame - [in] function pointer to register as per-frame callback; user - [in] auxiliary data the user wishes to receive together with every frame callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_start

public static void rs2_start(@Const
                             rs2_sensor sensor,
                             rs2_frame_callback_ptr on_frame,
                             Pointer user,
                             @ByPtrPtr
                             rs2_error error)

rs2_start_cpp

public static void rs2_start_cpp(@Const
                                 rs2_sensor sensor,
                                 rs2_frame_callback callback,
                                 @Cast(value="rs2_error**")
                                 PointerPointer error)

start streaming from specified configured sensor

Parameters:: sensor - [in] RealSense device; callback - [in] callback object created from c++ application. ownership over the callback object is moved into the relevant streaming lock; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_start_cpp

public static void rs2_start_cpp(@Const
                                 rs2_sensor sensor,
                                 rs2_frame_callback callback,
                                 @ByPtrPtr
                                 rs2_error error)

rs2_start_queue

public static void rs2_start_queue(@Const
                                   rs2_sensor sensor,
                                   rs2_frame_queue queue,
                                   @Cast(value="rs2_error**")
                                   PointerPointer error)

start streaming from specified configured sensor of specific stream to frame queue

Parameters:: sensor - [in] RealSense Sensor; queue - [in] frame-queue to store new frames into; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_start_queue

public static void rs2_start_queue(@Const
                                   rs2_sensor sensor,
                                   rs2_frame_queue queue,
                                   @ByPtrPtr
                                   rs2_error error)

rs2_stop

public static void rs2_stop(@Const
                            rs2_sensor sensor,
                            @Cast(value="rs2_error**")
                            PointerPointer error)

stops streaming from specified configured device

Parameters:: sensor - [in] RealSense sensor; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_stop

public static void rs2_stop(@Const
                            rs2_sensor sensor,
                            @ByPtrPtr
                            rs2_error error)

rs2_set_notifications_callback

public static void rs2_set_notifications_callback(@Const
                                                  rs2_sensor sensor,
                                                  rs2_notification_callback_ptr on_notification,
                                                  Pointer user,
                                                  @Cast(value="rs2_error**")
                                                  PointerPointer error)

set callback to get notifications from specified sensor

Parameters:: sensor - [in] RealSense device; on_notification - [in] function pointer to register as per-notifications callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_notifications_callback

public static void rs2_set_notifications_callback(@Const
                                                  rs2_sensor sensor,
                                                  rs2_notification_callback_ptr on_notification,
                                                  Pointer user,
                                                  @ByPtrPtr
                                                  rs2_error error)

rs2_set_notifications_callback_cpp

public static void rs2_set_notifications_callback_cpp(@Const
                                                      rs2_sensor sensor,
                                                      rs2_notifications_callback callback,
                                                      @Cast(value="rs2_error**")
                                                      PointerPointer error)

set callback to get notifications from specified device

Parameters:: sensor - [in] RealSense sensor; callback - [in] callback object created from c++ application. ownership over the callback object is moved into the relevant subdevice lock; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_notifications_callback_cpp

public static void rs2_set_notifications_callback_cpp(@Const
                                                      rs2_sensor sensor,
                                                      rs2_notifications_callback callback,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_get_notification_description

@Cast(value="const char*")
public static BytePointer rs2_get_notification_description(rs2_notification notification,
                                                                                       @Cast(value="rs2_error**")
                                                                                       PointerPointer error)

retrieve description from notification handle

Parameters:: notification - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the notification description

rs2_get_notification_description

@Cast(value="const char*")
public static BytePointer rs2_get_notification_description(rs2_notification notification,
                                                                                       @ByPtrPtr
                                                                                       rs2_error error)

rs2_get_notification_timestamp

@Cast(value="rs2_time_t")
public static double rs2_get_notification_timestamp(rs2_notification notification,
                                                                               @Cast(value="rs2_error**")
                                                                               PointerPointer error)

retrieve timestamp from notification handle

Parameters:: notification - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the notification timestamp

rs2_get_notification_timestamp

@Cast(value="rs2_time_t")
public static double rs2_get_notification_timestamp(rs2_notification notification,
                                                                               @ByPtrPtr
                                                                               rs2_error error)

rs2_get_notification_severity

@Cast(value="rs2_log_severity")
public static int rs2_get_notification_severity(rs2_notification notification,
                                                                                 @Cast(value="rs2_error**")
                                                                                 PointerPointer error)

retrieve severity from notification handle

Parameters:: notification - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the notification severity

rs2_get_notification_severity

@Cast(value="rs2_log_severity")
public static int rs2_get_notification_severity(rs2_notification notification,
                                                                                 @ByPtrPtr
                                                                                 rs2_error error)

rs2_get_notification_category

@Cast(value="rs2_notification_category")
public static int rs2_get_notification_category(rs2_notification notification,
                                                                                          @Cast(value="rs2_error**")
                                                                                          PointerPointer error)

retrieve category from notification handle

Parameters:: notification - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the notification category

rs2_get_notification_category

@Cast(value="rs2_notification_category")
public static int rs2_get_notification_category(rs2_notification notification,
                                                                                          @ByPtrPtr
                                                                                          rs2_error error)

rs2_get_notification_serialized_data

@Cast(value="const char*")
public static BytePointer rs2_get_notification_serialized_data(rs2_notification notification,
                                                                                           @Cast(value="rs2_error**")
                                                                                           PointerPointer error)

retrieve serialized data from notification handle

Parameters:: notification - [in] handle returned from a callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the serialized data (in JSON format)

rs2_get_notification_serialized_data

@Cast(value="const char*")
public static BytePointer rs2_get_notification_serialized_data(rs2_notification notification,
                                                                                           @ByPtrPtr
                                                                                           rs2_error error)

rs2_get_stream_profiles

public static rs2_stream_profile_list rs2_get_stream_profiles(rs2_sensor sensor,
                                                              @Cast(value="rs2_error**")
                                                              PointerPointer error)

check if physical subdevice is supported

Parameters:: sensor - [in] input RealSense subdevice; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: list of stream profiles that given subdevice can provide, should be released by rs2_delete_profiles_list

rs2_get_stream_profiles

public static rs2_stream_profile_list rs2_get_stream_profiles(rs2_sensor sensor,
                                                              @ByPtrPtr
                                                              rs2_error error)

rs2_get_debug_stream_profiles

public static rs2_stream_profile_list rs2_get_debug_stream_profiles(rs2_sensor sensor,
                                                                    @Cast(value="rs2_error**")
                                                                    PointerPointer error)

retrieve list of debug stream profiles that given subdevice can provide

Parameters:: sensor - [in] input RealSense subdevice; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: list of debug stream profiles that given subdevice can provide, should be released by rs2_delete_profiles_list

rs2_get_debug_stream_profiles

public static rs2_stream_profile_list rs2_get_debug_stream_profiles(rs2_sensor sensor,
                                                                    @ByPtrPtr
                                                                    rs2_error error)

rs2_get_active_streams

public static rs2_stream_profile_list rs2_get_active_streams(rs2_sensor sensor,
                                                             @Cast(value="rs2_error**")
                                                             PointerPointer error)

check how subdevice is streaming

Parameters:: sensor - [in] input RealSense subdevice; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: list of stream profiles that given subdevice is currently streaming, should be released by rs2_delete_profiles_list

rs2_get_active_streams

public static rs2_stream_profile_list rs2_get_active_streams(rs2_sensor sensor,
                                                             @ByPtrPtr
                                                             rs2_error error)

rs2_get_stream_profile

@Const
public static rs2_stream_profile rs2_get_stream_profile(@Const
                                                                rs2_stream_profile_list list,
                                                                int index,
                                                                @Cast(value="rs2_error**")
                                                                PointerPointer error)

Get pointer to specific stream profile

Parameters:: list - [in] the list of supported profiles returned by rs2_get_supported_profiles; index - [in] the zero based index of the streaming mode; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_stream_profile

@Const
public static rs2_stream_profile rs2_get_stream_profile(@Const
                                                                rs2_stream_profile_list list,
                                                                int index,
                                                                @ByPtrPtr
                                                                rs2_error error)

rs2_get_stream_profile_data

public static void rs2_get_stream_profile_data(@Const
                                               rs2_stream_profile mode,
                                               @Cast(value="rs2_stream*")
                                               IntPointer stream,
                                               @Cast(value="rs2_format*")
                                               IntPointer format,
                                               IntPointer index,
                                               IntPointer unique_id,
                                               IntPointer framerate,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)

Extract common parameters of a stream profiles

Parameters:: mode - [in] input stream profile; stream - [out] stream type of the input profile; format - [out] binary data format of the input profile; index - [out] stream index the input profile in case there are multiple streams of the same type; unique_id - [out] identifier for the stream profile, unique within the application; framerate - [out] expected rate for data frames to arrive, meaning expected number of frames per second; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_stream_profile_data

public static void rs2_get_stream_profile_data(@Const
                                               rs2_stream_profile mode,
                                               @Cast(value="rs2_stream*")
                                               IntPointer stream,
                                               @Cast(value="rs2_format*")
                                               IntPointer format,
                                               IntPointer index,
                                               IntPointer unique_id,
                                               IntPointer framerate,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_get_stream_profile_data

public static void rs2_get_stream_profile_data(@Const
                                               rs2_stream_profile mode,
                                               @Cast(value="rs2_stream*")
                                               IntBuffer stream,
                                               @Cast(value="rs2_format*")
                                               IntBuffer format,
                                               IntBuffer index,
                                               IntBuffer unique_id,
                                               IntBuffer framerate,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_get_stream_profile_data

public static void rs2_get_stream_profile_data(@Const
                                               rs2_stream_profile mode,
                                               @Cast(value="rs2_stream*")
                                               int[] stream,
                                               @Cast(value="rs2_format*")
                                               int[] format,
                                               int[] index,
                                               int[] unique_id,
                                               int[] framerate,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_set_stream_profile_data

public static void rs2_set_stream_profile_data(rs2_stream_profile mode,
                                               @Cast(value="rs2_stream")
                                               int stream,
                                               int index,
                                               @Cast(value="rs2_format")
                                               int format,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)

Override some of the parameters of the stream profile

Parameters:: mode - [in] input stream profile; stream - [in] stream type for the profile; format - [in] binary data format of the profile; index - [in] stream index the profile in case there are multiple streams of the same type; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_stream_profile_data

public static void rs2_set_stream_profile_data(rs2_stream_profile mode,
                                               @Cast(value="rs2_stream")
                                               int stream,
                                               int index,
                                               @Cast(value="rs2_format")
                                               int format,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_clone_stream_profile

public static rs2_stream_profile rs2_clone_stream_profile(@Const
                                                          rs2_stream_profile mode,
                                                          @Cast(value="rs2_stream")
                                                          int stream,
                                                          int index,
                                                          @Cast(value="rs2_format")
                                                          int format,
                                                          @Cast(value="rs2_error**")
                                                          PointerPointer error)

Creates a copy of stream profile, assigning new values to some of the fields

Parameters:: mode - [in] input stream profile; stream - [in] stream type for the profile; format - [in] binary data format of the profile; index - [in] stream index the profile in case there are multiple streams of the same type; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: new stream profile, must be deleted by rs2_delete_stream_profile

rs2_clone_stream_profile

public static rs2_stream_profile rs2_clone_stream_profile(@Const
                                                          rs2_stream_profile mode,
                                                          @Cast(value="rs2_stream")
                                                          int stream,
                                                          int index,
                                                          @Cast(value="rs2_format")
                                                          int format,
                                                          @ByPtrPtr
                                                          rs2_error error)

rs2_clone_video_stream_profile

public static rs2_stream_profile rs2_clone_video_stream_profile(@Const
                                                                rs2_stream_profile mode,
                                                                @Cast(value="rs2_stream")
                                                                int stream,
                                                                int index,
                                                                @Cast(value="rs2_format")
                                                                int format,
                                                                int width,
                                                                int height,
                                                                @Const
                                                                rs2_intrinsics intr,
                                                                @Cast(value="rs2_error**")
                                                                PointerPointer error)

Creates a copy of stream profile, assigning new values to some of the fields

Parameters:: mode - [in] input stream profile; stream - [in] stream type for the profile; format - [in] binary data format of the profile; width - [in] new width for the profile; height - [in] new height for the profile; intr - [in] new intrinsics for the profile; index - [in] stream index the profile in case there are multiple streams of the same type; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: new stream profile, must be deleted by rs2_delete_stream_profile

rs2_clone_video_stream_profile

public static rs2_stream_profile rs2_clone_video_stream_profile(@Const
                                                                rs2_stream_profile mode,
                                                                @Cast(value="rs2_stream")
                                                                int stream,
                                                                int index,
                                                                @Cast(value="rs2_format")
                                                                int format,
                                                                int width,
                                                                int height,
                                                                @Const
                                                                rs2_intrinsics intr,
                                                                @ByPtrPtr
                                                                rs2_error error)

rs2_delete_stream_profile
```
public static void rs2_delete_stream_profile(rs2_stream_profile mode)
```
Delete stream profile allocated by rs2_clone_stream_profile Should not be called on stream profiles returned by the device

Parameters:

mode - [in] input stream profile

rs2_stream_profile_is

public static int rs2_stream_profile_is(@Const
                                        rs2_stream_profile mode,
                                        @Cast(value="rs2_extension")
                                        int type,
                                        @Cast(value="rs2_error**")
                                        PointerPointer error)

Try to extend stream profile to an extension type

Parameters:: mode - [in] input stream profile; type - [in] extension type, for example RS2_EXTENSION_VIDEO_STREAM_PROFILE; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: non-zero if profile is extendable to specified extension, zero otherwise

rs2_stream_profile_is

public static int rs2_stream_profile_is(@Const
                                        rs2_stream_profile mode,
                                        @Cast(value="rs2_extension")
                                        int type,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_get_video_stream_resolution

public static void rs2_get_video_stream_resolution(@Const
                                                   rs2_stream_profile mode,
                                                   IntPointer width,
                                                   IntPointer height,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

When called on a video stream profile, will return the width and the height of the stream

Parameters:: mode - [in] input stream profile; width - [out] width in pixels of the video stream; height - [out] height in pixels of the video stream; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_video_stream_resolution

public static void rs2_get_video_stream_resolution(@Const
                                                   rs2_stream_profile mode,
                                                   IntPointer width,
                                                   IntPointer height,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_get_video_stream_resolution

public static void rs2_get_video_stream_resolution(@Const
                                                   rs2_stream_profile mode,
                                                   IntBuffer width,
                                                   IntBuffer height,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_get_video_stream_resolution

public static void rs2_get_video_stream_resolution(@Const
                                                   rs2_stream_profile mode,
                                                   int[] width,
                                                   int[] height,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_get_motion_intrinsics

public static void rs2_get_motion_intrinsics(@Const
                                             rs2_stream_profile mode,
                                             rs2_motion_device_intrinsic intrinsics,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

Obtain the intrinsics of a specific stream configuration from the device.

Parameters:: mode - [in] input stream profile; intrinsics - [out] Pointer to the struct to store the data in; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_motion_intrinsics

public static void rs2_get_motion_intrinsics(@Const
                                             rs2_stream_profile mode,
                                             rs2_motion_device_intrinsic intrinsics,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_is_stream_profile_default

public static int rs2_is_stream_profile_default(@Const
                                                rs2_stream_profile mode,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

Returns non-zero if selected profile is recommended for the sensor This is an optional hint we offer to suggest profiles with best performance-quality tradeof

Parameters:: mode - [in] input stream profile; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: non-zero if selected profile is recommended for the sensor

rs2_is_stream_profile_default

public static int rs2_is_stream_profile_default(@Const
                                                rs2_stream_profile mode,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_get_stream_profiles_count

public static int rs2_get_stream_profiles_count(@Const
                                                rs2_stream_profile_list list,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

get the number of supported stream profiles

Parameters:: list - [in] the list of supported profiles returned by rs2_get_supported_profiles; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: number of supported subdevice profiles

rs2_get_stream_profiles_count

public static int rs2_get_stream_profiles_count(@Const
                                                rs2_stream_profile_list list,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_delete_stream_profiles_list
```
public static void rs2_delete_stream_profiles_list(rs2_stream_profile_list list)
```
delete stream profiles list

Parameters:

list - [in] the list of supported profiles returned by rs2_get_supported_profiles

rs2_get_extrinsics

public static void rs2_get_extrinsics(@Const
                                      rs2_stream_profile from,
                                      @Const
                                      rs2_stream_profile to,
                                      rs2_extrinsics extrin,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

Parameters:: from - [in] origin stream profile; to - [in] target stream profile; extrin - [out] extrinsics from origin to target; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_extrinsics

public static void rs2_get_extrinsics(@Const
                                      rs2_stream_profile from,
                                      @Const
                                      rs2_stream_profile to,
                                      rs2_extrinsics extrin,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_register_extrinsics

public static void rs2_register_extrinsics(@Const
                                           rs2_stream_profile from,
                                           @Const
                                           rs2_stream_profile to,
                                           @ByVal
                                           rs2_extrinsics extrin,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Parameters:: from - [in] origin stream profile; to - [in] target stream profile; extrin - [out] extrinsics from origin to target; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_register_extrinsics

public static void rs2_register_extrinsics(@Const
                                           rs2_stream_profile from,
                                           @Const
                                           rs2_stream_profile to,
                                           @ByVal
                                           rs2_extrinsics extrin,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_override_extrinsics

public static void rs2_override_extrinsics(@Const
                                           rs2_sensor sensor,
                                           @Const
                                           rs2_extrinsics extrinsics,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

\brief Override extrinsics of a given sensor that supports calibrated_sensor. This will affect extrinsics at the source device and may affect multiple profiles. Used for DEPTH_TO_RGB calibration.

Parameters:: sensor - [in] The sensor; extrinsics - [in] Extrinsics from Depth to the named sensor; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_override_extrinsics

public static void rs2_override_extrinsics(@Const
                                           rs2_sensor sensor,
                                           @Const
                                           rs2_extrinsics extrinsics,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_get_video_stream_intrinsics

public static void rs2_get_video_stream_intrinsics(@Const
                                                   rs2_stream_profile mode,
                                                   rs2_intrinsics intrinsics,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

When called on a video profile, returns the intrinsics of specific stream configuration

Parameters:: mode - [in] input stream profile; intrinsics - [out] resulting intrinsics for the video profile; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_video_stream_intrinsics

public static void rs2_get_video_stream_intrinsics(@Const
                                                   rs2_stream_profile mode,
                                                   rs2_intrinsics intrinsics,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_get_recommended_processing_blocks

public static rs2_processing_block_list rs2_get_recommended_processing_blocks(rs2_sensor sensor,
                                                                              @Cast(value="rs2_error**")
                                                                              PointerPointer error)

Returns the list of recommended processing blocks for a specific sensor. Order and configuration of the blocks are decided by the sensor

Parameters:: sensor - [in] input sensor; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: list of supported sensor recommended processing blocks

rs2_get_recommended_processing_blocks

public static rs2_processing_block_list rs2_get_recommended_processing_blocks(rs2_sensor sensor,
                                                                              @ByPtrPtr
                                                                              rs2_error error)

rs2_get_processing_block

public static rs2_processing_block rs2_get_processing_block(@Const
                                                            rs2_processing_block_list list,
                                                            int index,
                                                            @Cast(value="rs2_error**")
                                                            PointerPointer error)

Returns specific processing blocks from processing blocks list

Parameters:: list - [in] the processing blocks list; index - [in] the requested processing block; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: processing block

rs2_get_processing_block

public static rs2_processing_block rs2_get_processing_block(@Const
                                                            rs2_processing_block_list list,
                                                            int index,
                                                            @ByPtrPtr
                                                            rs2_error error)

rs2_get_recommended_processing_blocks_count

public static int rs2_get_recommended_processing_blocks_count(@Const
                                                              rs2_processing_block_list list,
                                                              @Cast(value="rs2_error**")
                                                              PointerPointer error)

Returns the processing blocks list size

Parameters:: list - [in] the processing blocks list; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the processing block list size

rs2_get_recommended_processing_blocks_count

public static int rs2_get_recommended_processing_blocks_count(@Const
                                                              rs2_processing_block_list list,
                                                              @ByPtrPtr
                                                              rs2_error error)

rs2_delete_recommended_processing_blocks
```
public static void rs2_delete_recommended_processing_blocks(rs2_processing_block_list list)
```
Deletes processing blocks list

Parameters:

list - [in] list to delete

rs2_import_localization_map

public static int rs2_import_localization_map(@Const
                                              rs2_sensor sensor,
                                              @Cast(value="const unsigned char*")
                                              BytePointer lmap_blob,
                                              @Cast(value="unsigned int")
                                              int blob_size,
                                              @Cast(value="rs2_error**")
                                              PointerPointer error)

Imports a localization map from file to tm2 tracking device

Parameters:: sensor - [in] TM2 position-tracking sensor; lmap_blob - [in] Localization map raw buffer, serialized; blob_size - [in] The buffer's size in bytes; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Non-zero if succeeded, otherwise 0

rs2_import_localization_map

public static int rs2_import_localization_map(@Const
                                              rs2_sensor sensor,
                                              @Cast(value="const unsigned char*")
                                              BytePointer lmap_blob,
                                              @Cast(value="unsigned int")
                                              int blob_size,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_import_localization_map

public static int rs2_import_localization_map(@Const
                                              rs2_sensor sensor,
                                              @Cast(value="const unsigned char*")
                                              ByteBuffer lmap_blob,
                                              @Cast(value="unsigned int")
                                              int blob_size,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_import_localization_map

public static int rs2_import_localization_map(@Const
                                              rs2_sensor sensor,
                                              @Cast(value="const unsigned char*")
                                              byte[] lmap_blob,
                                              @Cast(value="unsigned int")
                                              int blob_size,
                                              @ByPtrPtr
                                              rs2_error error)

rs2_export_localization_map

@Const
public static rs2_raw_data_buffer rs2_export_localization_map(@Const
                                                                      rs2_sensor sensor,
                                                                      @Cast(value="rs2_error**")
                                                                      PointerPointer error)

Extract and store the localization map of tm2 tracking device to file

Parameters:: sensor - [in] TM2 position-tracking sensor; lmap_fname - [in] The file name of the localization map; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Device's response in a rs2_raw_data_buffer, which should be released by rs2_delete_raw_data

rs2_export_localization_map

@Const
public static rs2_raw_data_buffer rs2_export_localization_map(@Const
                                                                      rs2_sensor sensor,
                                                                      @ByPtrPtr
                                                                      rs2_error error)

rs2_set_static_node

public static int rs2_set_static_node(@Const
                                      rs2_sensor sensor,
                                      @Cast(value="const char*")
                                      BytePointer guid,
                                      @Const @ByVal
                                      rs2_vector pos,
                                      @Const @ByVal
                                      rs2_quaternion orient,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

Create a named location tag

Parameters:: sensor - [in] T2xx position-tracking sensor; guid - [in] Null-terminated string of up to 127 characters; pos - [in] Position in meters, relative to the current tracking session; orient - [in] Quaternion orientation, expressed the the coordinate system of the current tracking session; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Non-zero if succeeded, otherwise 0

rs2_set_static_node

public static int rs2_set_static_node(@Const
                                      rs2_sensor sensor,
                                      @Cast(value="const char*")
                                      BytePointer guid,
                                      @Const @ByVal
                                      rs2_vector pos,
                                      @Const @ByVal
                                      rs2_quaternion orient,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_set_static_node

public static int rs2_set_static_node(@Const
                                      rs2_sensor sensor,
                                      String guid,
                                      @Const @ByVal
                                      rs2_vector pos,
                                      @Const @ByVal
                                      rs2_quaternion orient,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_get_static_node

public static int rs2_get_static_node(@Const
                                      rs2_sensor sensor,
                                      @Cast(value="const char*")
                                      BytePointer guid,
                                      rs2_vector pos,
                                      rs2_quaternion orient,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

Retrieve a named location tag

Parameters:: sensor - [in] T2xx position-tracking sensor; guid - [in] Null-terminated string of up to 127 characters; pos - [out] Position in meters of the tagged (stored) location; orient - [out] Quaternion orientation of the tagged (stored) location; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Non-zero if succeeded, otherwise 0

rs2_get_static_node

public static int rs2_get_static_node(@Const
                                      rs2_sensor sensor,
                                      @Cast(value="const char*")
                                      BytePointer guid,
                                      rs2_vector pos,
                                      rs2_quaternion orient,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_get_static_node

public static int rs2_get_static_node(@Const
                                      rs2_sensor sensor,
                                      String guid,
                                      rs2_vector pos,
                                      rs2_quaternion orient,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_remove_static_node

public static int rs2_remove_static_node(@Const
                                         rs2_sensor sensor,
                                         @Cast(value="const char*")
                                         BytePointer guid,
                                         @Cast(value="rs2_error**")
                                         PointerPointer error)

Remove a named location tag

Parameters:: sensor - [in] T2xx position-tracking sensor; guid - [in] Null-terminated string of up to 127 characters; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: Non-zero if succeeded, otherwise 0

rs2_remove_static_node

public static int rs2_remove_static_node(@Const
                                         rs2_sensor sensor,
                                         @Cast(value="const char*")
                                         BytePointer guid,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_remove_static_node

public static int rs2_remove_static_node(@Const
                                         rs2_sensor sensor,
                                         String guid,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_load_wheel_odometry_config

public static int rs2_load_wheel_odometry_config(@Const
                                                 rs2_sensor sensor,
                                                 @Cast(value="const unsigned char*")
                                                 BytePointer odometry_config_buf,
                                                 @Cast(value="unsigned int")
                                                 int blob_size,
                                                 @Cast(value="rs2_error**")
                                                 PointerPointer error)

Load Wheel odometer settings from host to device

Parameters:: odometry_config_buf - [in] odometer configuration/calibration blob serialized from jsom file
Returns:: true on success

rs2_load_wheel_odometry_config

public static int rs2_load_wheel_odometry_config(@Const
                                                 rs2_sensor sensor,
                                                 @Cast(value="const unsigned char*")
                                                 BytePointer odometry_config_buf,
                                                 @Cast(value="unsigned int")
                                                 int blob_size,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_load_wheel_odometry_config

public static int rs2_load_wheel_odometry_config(@Const
                                                 rs2_sensor sensor,
                                                 @Cast(value="const unsigned char*")
                                                 ByteBuffer odometry_config_buf,
                                                 @Cast(value="unsigned int")
                                                 int blob_size,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_load_wheel_odometry_config

public static int rs2_load_wheel_odometry_config(@Const
                                                 rs2_sensor sensor,
                                                 @Cast(value="const unsigned char*")
                                                 byte[] odometry_config_buf,
                                                 @Cast(value="unsigned int")
                                                 int blob_size,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_send_wheel_odometry

public static int rs2_send_wheel_odometry(@Const
                                          rs2_sensor sensor,
                                          @Cast(value="char")
                                          byte wo_sensor_id,
                                          @Cast(value="unsigned int")
                                          int frame_num,
                                          @Const @ByVal
                                          rs2_vector translational_velocity,
                                          @Cast(value="rs2_error**")
                                          PointerPointer error)

Send wheel odometry data for each individual sensor (wheel)

Parameters:: wo_sensor_id - [in] - Zero-based index of (wheel) sensor with the same type within device; frame_num - [in] - Monotonocally increasing frame number, managed per sensor.; translational_velocity - [in] - Translational velocity of the wheel sensor [meter/sec]
Returns:: true on success

rs2_send_wheel_odometry

public static int rs2_send_wheel_odometry(@Const
                                          rs2_sensor sensor,
                                          @Cast(value="char")
                                          byte wo_sensor_id,
                                          @Cast(value="unsigned int")
                                          int frame_num,
                                          @Const @ByVal
                                          rs2_vector translational_velocity,
                                          @ByPtrPtr
                                          rs2_error error)

rs2_set_intrinsics

public static void rs2_set_intrinsics(@Const
                                      rs2_sensor sensor,
                                      @Const
                                      rs2_stream_profile profile,
                                      @Const
                                      rs2_intrinsics intrinsics,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

Set intrinsics of a given sensor

Parameters:: sensor - [in] The RealSense device; profile - [in] Target stream profile; intrinsics - [in] Intrinsics value to be written to the device; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_intrinsics

public static void rs2_set_intrinsics(@Const
                                      rs2_sensor sensor,
                                      @Const
                                      rs2_stream_profile profile,
                                      @Const
                                      rs2_intrinsics intrinsics,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_override_intrinsics

public static void rs2_override_intrinsics(@Const
                                           rs2_sensor sensor,
                                           @Const
                                           rs2_intrinsics intrinsics,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

\brief Override intrinsics of a given sensor that supports calibrated_sensor. This will affect intrinsics at the source and may affect multiple profiles. Used for DEPTH_TO_RGB calibration.

Parameters:: sensor - [in] The RealSense device; intrinsics - [in] Intrinsics value to be written to the sensor; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_override_intrinsics

public static void rs2_override_intrinsics(@Const
                                           rs2_sensor sensor,
                                           @Const
                                           rs2_intrinsics intrinsics,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_set_extrinsics

public static void rs2_set_extrinsics(@Const
                                      rs2_sensor from_sensor,
                                      @Const
                                      rs2_stream_profile from_profile,
                                      rs2_sensor to_sensor,
                                      @Const
                                      rs2_stream_profile to_profile,
                                      @Const
                                      rs2_extrinsics extrinsics,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

Set extrinsics between two sensors

Parameters:: from_sensor - [in] Origin sensor; from_profile - [in] Origin profile; to_sensor - [in] Target sensor; to_profile - [in] Target profile; extrinsics - [out] Extrinsics from origin to target; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_extrinsics

public static void rs2_set_extrinsics(@Const
                                      rs2_sensor from_sensor,
                                      @Const
                                      rs2_stream_profile from_profile,
                                      rs2_sensor to_sensor,
                                      @Const
                                      rs2_stream_profile to_profile,
                                      @Const
                                      rs2_extrinsics extrinsics,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_get_dsm_params

public static void rs2_get_dsm_params(@Const
                                      rs2_sensor sensor,
                                      rs2_dsm_params p_params_out,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

Get the DSM parameters for a sensor

Parameters:: sensor - [in] Sensor that supports the CALIBRATED_SENSOR extension; p_params_out - [out] Pointer to the structure that will get the DSM parameters; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_get_dsm_params

public static void rs2_get_dsm_params(@Const
                                      rs2_sensor sensor,
                                      rs2_dsm_params p_params_out,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_override_dsm_params

public static void rs2_override_dsm_params(@Const
                                           rs2_sensor sensor,
                                           @Const
                                           rs2_dsm_params p_params,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

Set the sensor DSM parameters This should ideally be done when the stream is NOT running. If it is, the parameters may not take effect immediately.

Parameters:: sensor - [in] Sensor that supports the CALIBRATED_SENSOR extension; p_params - [out] Pointer to the structure that contains the DSM parameters; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_override_dsm_params

public static void rs2_override_dsm_params(@Const
                                           rs2_sensor sensor,
                                           @Const
                                           rs2_dsm_params p_params,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_reset_sensor_calibration

public static void rs2_reset_sensor_calibration(@Const
                                                rs2_sensor sensor,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)

Reset the sensor DSM parameters This should ideally be done when the stream is NOT running. May not take effect immediately.

Parameters:: sensor - [in] Sensor that supports the CALIBRATED_SENSOR extension; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_reset_sensor_calibration

public static void rs2_reset_sensor_calibration(@Const
                                                rs2_sensor sensor,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_set_motion_device_intrinsics

public static void rs2_set_motion_device_intrinsics(@Const
                                                    rs2_sensor sensor,
                                                    @Const
                                                    rs2_stream_profile profile,
                                                    @Const
                                                    rs2_motion_device_intrinsic intrinsics,
                                                    @Cast(value="rs2_error**")
                                                    PointerPointer error)

Set motion device intrinsics

Parameters:: sensor - [in] Motion sensor; profile - [in] Motion stream profile; intrinsics - [out] Pointer to the struct to store the data in; error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_set_motion_device_intrinsics

public static void rs2_set_motion_device_intrinsics(@Const
                                                    rs2_sensor sensor,
                                                    @Const
                                                    rs2_stream_profile profile,
                                                    @Const
                                                    rs2_motion_device_intrinsic intrinsics,
                                                    @ByPtrPtr
                                                    rs2_error error)

rs2_get_max_usable_depth_range

public static float rs2_get_max_usable_depth_range(@Const
                                                   rs2_sensor sensor,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)

When called on a depth sensor, this method will return the maximum range of the camera given the amount of ambient light in the scene

Parameters:: sensor - [in] depth sensor; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the max usable range in meters

rs2_get_max_usable_depth_range

public static float rs2_get_max_usable_depth_range(@Const
                                                   rs2_sensor sensor,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_create_config
```
public static rs2_config rs2_create_config(@Cast(value="rs2_error**")
                                           PointerPointer error)
```
Create a config instance The config allows pipeline users to request filters for the pipeline streams and device selection and configuration. This is an optional step in pipeline creation, as the pipeline resolves its streaming device internally. Config provides its users a way to set the filters and test if there is no conflict with the pipeline requirements from the device. It also allows the user to find a matching device for the config filters and the pipeline, in order to select a device explicitly, and modify its controls before streaming starts.

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

rs2_config* A pointer to a new config instance

rs2_create_config

public static rs2_config rs2_create_config(@ByPtrPtr
                                           rs2_error error)

rs2_delete_config
```
public static void rs2_delete_config(rs2_config config)
```
Deletes an instance of a config

Parameters:

config - [in] A pointer to an instance of a config

rs2_config_enable_stream
```
public static void rs2_config_enable_stream(rs2_config config,
                                            @Cast(value="rs2_stream")
                                            int stream,
                                            int index,
                                            int width,
                                            int height,
                                            @Cast(value="rs2_format")
                                            int format,
                                            int framerate,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)
```
Enable a device stream explicitly, with selected stream parameters. The method allows the application to request a stream with specific configuration. If no stream is explicitly enabled, the pipeline configures the device and its streams according to the attached computer vision modules and processing blocks requirements, or default configuration for the first available device. The application can configure any of the input stream parameters according to its requirement, or set to 0 for don't care value. The config accumulates the application calls for enable configuration methods, until the configuration is applied. Multiple enable stream calls for the same stream with conflicting parameters override each other, and the last call is maintained. Upon calling \c resolve(), the config checks for conflicts between the application configuration requests and the attached computer vision modules and processing blocks requirements, and fails if conflicts are found. Before \c resolve() is called, no conflict check is done.

Parameters:

config - [in] A pointer to an instance of a config

stream - [in] Stream type to be enabled

index - [in] Stream index, used for multiple streams of the same type. -1 indicates any.

width - [in] Stream image width - for images streams. 0 indicates any.

height - [in] Stream image height - for images streams. 0 indicates any.

format - [in] Stream data format - pixel format for images streams, of data type for other streams. RS2_FORMAT_ANY indicates any.

framerate - [in] Stream frames per second. 0 indicates any.

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_enable_stream

public static void rs2_config_enable_stream(rs2_config config,
                                            @Cast(value="rs2_stream")
                                            int stream,
                                            int index,
                                            int width,
                                            int height,
                                            @Cast(value="rs2_format")
                                            int format,
                                            int framerate,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_config_enable_all_stream
```
public static void rs2_config_enable_all_stream(rs2_config config,
                                                @Cast(value="rs2_error**")
                                                PointerPointer error)
```
Enable all device streams explicitly. The conditions and behavior of this method are similar to those of \c enable_stream(). This filter enables all raw streams of the selected device. The device is either selected explicitly by the application, or by the pipeline requirements or default. The list of streams is device dependent.

Parameters:

config - [in] A pointer to an instance of a config

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_enable_all_stream

public static void rs2_config_enable_all_stream(rs2_config config,
                                                @ByPtrPtr
                                                rs2_error error)

rs2_config_enable_device
```
public static void rs2_config_enable_device(rs2_config config,
                                            @Cast(value="const char*")
                                            BytePointer serial,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)
```
Select a specific device explicitly by its serial number, to be used by the pipeline. The conditions and behavior of this method are similar to those of \c enable_stream(). This method is required if the application needs to set device or sensor settings prior to pipeline streaming, to enforce the pipeline to use the configured device.

Parameters:

config - [in] A pointer to an instance of a config

serial - [in] device serial number, as returned by RS2_CAMERA_INFO_SERIAL_NUMBER

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_enable_device

public static void rs2_config_enable_device(rs2_config config,
                                            @Cast(value="const char*")
                                            BytePointer serial,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_config_enable_device

public static void rs2_config_enable_device(rs2_config config,
                                            String serial,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_config_enable_device_from_file
```
public static void rs2_config_enable_device_from_file(rs2_config config,
                                                      @Cast(value="const char*")
                                                      BytePointer file,
                                                      @Cast(value="rs2_error**")
                                                      PointerPointer error)
```
Select a recorded device from a file, to be used by the pipeline through playback. The device available streams are as recorded to the file, and \c resolve() considers only this device and configuration as available. This request cannot be used if enable_record_to_file() is called for the current config, and vise versa By default, playback is repeated once the file ends. To control this, see 'rs2_config_enable_device_from_file_repeat_option'.

Parameters:

config - [in] A pointer to an instance of a config

file - [in] The playback file of the device

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_enable_device_from_file

public static void rs2_config_enable_device_from_file(rs2_config config,
                                                      @Cast(value="const char*")
                                                      BytePointer file,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_config_enable_device_from_file

public static void rs2_config_enable_device_from_file(rs2_config config,
                                                      String file,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_config_enable_device_from_file_repeat_option

public static void rs2_config_enable_device_from_file_repeat_option(rs2_config config,
                                                                    @Cast(value="const char*")
                                                                    BytePointer file,
                                                                    int repeat_playback,
                                                                    @Cast(value="rs2_error**")
                                                                    PointerPointer error)

Select a recorded device from a file, to be used by the pipeline through playback. The device available streams are as recorded to the file, and \c resolve() considers only this device and configuration as available. This request cannot be used if enable_record_to_file() is called for the current config, and vise versa

Parameters:: config - [in] A pointer to an instance of a config; file - [in] The playback file of the device; repeat_playback - [in] if true, when file ends the playback starts again, in an infinite loop; if false, when file ends playback does not start again, and should by stopped manually by the user.; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_enable_device_from_file_repeat_option

public static void rs2_config_enable_device_from_file_repeat_option(rs2_config config,
                                                                    @Cast(value="const char*")
                                                                    BytePointer file,
                                                                    int repeat_playback,
                                                                    @ByPtrPtr
                                                                    rs2_error error)

rs2_config_enable_device_from_file_repeat_option

public static void rs2_config_enable_device_from_file_repeat_option(rs2_config config,
                                                                    String file,
                                                                    int repeat_playback,
                                                                    @ByPtrPtr
                                                                    rs2_error error)

rs2_config_enable_record_to_file

public static void rs2_config_enable_record_to_file(rs2_config config,
                                                    @Cast(value="const char*")
                                                    BytePointer file,
                                                    @Cast(value="rs2_error**")
                                                    PointerPointer error)

Requires that the resolved device would be recorded to file This request cannot be used if enable_device_from_file() is called for the current config, and vise versa

Parameters:: config - [in] A pointer to an instance of a config; file - [in] The desired file for the output record; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_enable_record_to_file

public static void rs2_config_enable_record_to_file(rs2_config config,
                                                    @Cast(value="const char*")
                                                    BytePointer file,
                                                    @ByPtrPtr
                                                    rs2_error error)

rs2_config_enable_record_to_file

public static void rs2_config_enable_record_to_file(rs2_config config,
                                                    String file,
                                                    @ByPtrPtr
                                                    rs2_error error)

rs2_config_disable_stream

public static void rs2_config_disable_stream(rs2_config config,
                                             @Cast(value="rs2_stream")
                                             int stream,
                                             @Cast(value="rs2_error**")
                                             PointerPointer error)

Disable a device stream explicitly, to remove any requests on this stream type. The stream can still be enabled due to pipeline computer vision module request. This call removes any filter on the stream configuration.

Parameters:: config - [in] A pointer to an instance of a config; stream - [in] Stream type, for which the filters are cleared; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_disable_stream

public static void rs2_config_disable_stream(rs2_config config,
                                             @Cast(value="rs2_stream")
                                             int stream,
                                             @ByPtrPtr
                                             rs2_error error)

rs2_config_disable_indexed_stream

public static void rs2_config_disable_indexed_stream(rs2_config config,
                                                     @Cast(value="rs2_stream")
                                                     int stream,
                                                     int index,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)

Disable a device stream explicitly, to remove any requests on this stream profile. The stream can still be enabled due to pipeline computer vision module request. This call removes any filter on the stream configuration.

Parameters:: config - [in] A pointer to an instance of a config; stream - [in] Stream type, for which the filters are cleared; index - [in] Stream index, for which the filters are cleared; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_disable_indexed_stream

public static void rs2_config_disable_indexed_stream(rs2_config config,
                                                     @Cast(value="rs2_stream")
                                                     int stream,
                                                     int index,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_config_disable_all_streams
```
public static void rs2_config_disable_all_streams(rs2_config config,
                                                  @Cast(value="rs2_error**")
                                                  PointerPointer error)
```
Disable all device stream explicitly, to remove any requests on the streams profiles. The streams can still be enabled due to pipeline computer vision module request. This call removes any filter on the streams configuration.

Parameters:

config - [in] A pointer to an instance of a config

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_config_disable_all_streams

public static void rs2_config_disable_all_streams(rs2_config config,
                                                  @ByPtrPtr
                                                  rs2_error error)

rs2_config_resolve
```
public static rs2_pipeline_profile rs2_config_resolve(rs2_config config,
                                                      rs2_pipeline pipe,
                                                      @Cast(value="rs2_error**")
                                                      PointerPointer error)
```
Resolve the configuration filters, to find a matching device and streams profiles. The method resolves the user configuration filters for the device and streams, and combines them with the requirements of the computer vision modules and processing blocks attached to the pipeline. If there are no conflicts of requests, it looks for an available device, which can satisfy all requests, and selects the first matching streams configuration. In the absence of any request, the rs2::config selects the first available device and the first color and depth streams configuration. The pipeline profile selection during \c start() follows the same method. Thus, the selected profile is the same, if no change occurs to the available devices occurs. Resolving the pipeline configuration provides the application access to the pipeline selected device for advanced control. The returned configuration is not applied to the device, so the application doesn't own the device sensors. However, the application can call \c enable_device(), to enforce the device returned by this method is selected by pipeline \c start(), and configure the device and sensors options or extensions before streaming starts.

Parameters:

config - [in] A pointer to an instance of a config

pipe - [in] The pipeline for which the selected filters are applied

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

A matching device and streams profile, which satisfies the filters and pipeline requests.

rs2_config_resolve

public static rs2_pipeline_profile rs2_config_resolve(rs2_config config,
                                                      rs2_pipeline pipe,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_config_can_resolve
```
public static int rs2_config_can_resolve(rs2_config config,
                                         rs2_pipeline pipe,
                                         @Cast(value="rs2_error**")
                                         PointerPointer error)
```
Check if the config can resolve the configuration filters, to find a matching device and streams profiles. The resolution conditions are as described in \c resolve().

Parameters:

config - [in] A pointer to an instance of a config

pipe - [in] The pipeline for which the selected filters are applied

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

True if a valid profile selection exists, false if no selection can be found under the config filters and the available devices.

rs2_config_can_resolve

public static int rs2_config_can_resolve(rs2_config config,
                                         rs2_pipeline pipe,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_create_pipeline
```
public static rs2_pipeline rs2_create_pipeline(rs2_context ctx,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)
```
Create a pipeline instance The pipeline simplifies the user interaction with the device and computer vision processing modules. The class abstracts the camera configuration and streaming, and the vision modules triggering and threading. It lets the application focus on the computer vision output of the modules, or the device output data. The pipeline can manage computer vision modules, which are implemented as a processing blocks. The pipeline is the consumer of the processing block interface, while the application consumes the computer vision interface.

Parameters:

ctx - [in] context

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_create_pipeline

public static rs2_pipeline rs2_create_pipeline(rs2_context ctx,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_pipeline_stop
```
public static void rs2_pipeline_stop(rs2_pipeline pipe,
                                     @Cast(value="rs2_error**")
                                     PointerPointer error)
```
Stop the pipeline streaming. The pipeline stops delivering samples to the attached computer vision modules and processing blocks, stops the device streaming and releases the device resources used by the pipeline. It is the application's responsibility to release any frame reference it owns. The method takes effect only after \c start() was called, otherwise an exception is raised.

Parameters:

pipe - [in] pipeline

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_pipeline_stop

public static void rs2_pipeline_stop(rs2_pipeline pipe,
                                     @ByPtrPtr
                                     rs2_error error)

rs2_pipeline_wait_for_frames
```
public static rs2_frame rs2_pipeline_wait_for_frames(rs2_pipeline pipe,
                                                     @Cast(value="unsigned int")
                                                     int timeout_ms,
                                                     @Cast(value="rs2_error**")
                                                     PointerPointer error)
```
Wait until a new set of frames becomes available. The frames set includes time-synchronized frames of each enabled stream in the pipeline. The method blocks the calling thread, and fetches the latest unread frames set. Device frames, which were produced while the function wasn't called, are dropped. To avoid frame drops, this method should be called as fast as the device frame rate. The application can maintain the frames handles to defer processing. However, if the application maintains too long history, the device may lack memory resources to produce new frames, and the following call to this method shall fail to retrieve new frames, until resources are retained.

Parameters:

pipe - [in] the pipeline

timeout_ms - [in] Max time in milliseconds to wait until an exception will be thrown

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

Set of coherent frames

rs2_pipeline_wait_for_frames

public static rs2_frame rs2_pipeline_wait_for_frames(rs2_pipeline pipe,
                                                     @Cast(value="unsigned int")
                                                     int timeout_ms,
                                                     @ByPtrPtr
                                                     rs2_error error)

rs2_pipeline_poll_for_frames
```
public static int rs2_pipeline_poll_for_frames(rs2_pipeline pipe,
                                               @Cast(value="rs2_frame**")
                                               PointerPointer output_frame,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)
```
Check if a new set of frames is available and retrieve the latest undelivered set. The frames set includes time-synchronized frames of each enabled stream in the pipeline. The method returns without blocking the calling thread, with status of new frames available or not. If available, it fetches the latest frames set. Device frames, which were produced while the function wasn't called, are dropped. To avoid frame drops, this method should be called as fast as the device frame rate. The application can maintain the frames handles to defer processing. However, if the application maintains too long history, the device may lack memory resources to produce new frames, and the following calls to this method shall return no new frames, until resources are retained.

Parameters:

pipe - [in] the pipeline

output_frame - [out] frame handle to be released using rs2_release_frame

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

true if new frame was stored to output_frame

rs2_pipeline_poll_for_frames

public static int rs2_pipeline_poll_for_frames(rs2_pipeline pipe,
                                               @ByPtrPtr
                                               rs2_frame output_frame,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_pipeline_try_wait_for_frames
```
public static int rs2_pipeline_try_wait_for_frames(rs2_pipeline pipe,
                                                   @Cast(value="rs2_frame**")
                                                   PointerPointer output_frame,
                                                   @Cast(value="unsigned int")
                                                   int timeout_ms,
                                                   @Cast(value="rs2_error**")
                                                   PointerPointer error)
```
Wait until a new set of frames becomes available. The frames set includes time-synchronized frames of each enabled stream in the pipeline. The method blocks the calling thread, and fetches the latest unread frames set. Device frames, which were produced while the function wasn't called, are dropped. To avoid frame drops, this method should be called as fast as the device frame rate. The application can maintain the frames handles to defer processing. However, if the application maintains too long history, the device may lack memory resources to produce new frames, and the following call to this method shall fail to retrieve new frames, until resources are retained.

Parameters:

pipe - [in] the pipeline

timeout_ms - [in] max time in milliseconds to wait until a frame becomes available

output_frame - [out] frame handle to be released using rs2_release_frame

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

true if new frame was stored to output_frame

rs2_pipeline_try_wait_for_frames

public static int rs2_pipeline_try_wait_for_frames(rs2_pipeline pipe,
                                                   @ByPtrPtr
                                                   rs2_frame output_frame,
                                                   @Cast(value="unsigned int")
                                                   int timeout_ms,
                                                   @ByPtrPtr
                                                   rs2_error error)

rs2_delete_pipeline
```
public static void rs2_delete_pipeline(rs2_pipeline pipe)
```
Delete a pipeline instance. Upon destruction, the pipeline will implicitly stop itself

Parameters:

pipe - [in] to delete

rs2_pipeline_start
```
public static rs2_pipeline_profile rs2_pipeline_start(rs2_pipeline pipe,
                                                      @Cast(value="rs2_error**")
                                                      PointerPointer error)
```
Start the pipeline streaming with its default configuration. The pipeline streaming loop captures samples from the device, and delivers them to the attached computer vision modules and processing blocks, according to each module requirements and threading model. During the loop execution, the application can access the camera streams by calling \c wait_for_frames() or \c poll_for_frames(). The streaming loop runs until the pipeline is stopped. Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised.

Parameters:

pipe - [in] a pointer to an instance of the pipeline

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

The actual pipeline device and streams profile, which was successfully configured to the streaming device.

rs2_pipeline_start

public static rs2_pipeline_profile rs2_pipeline_start(rs2_pipeline pipe,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_pipeline_start_with_config
```
public static rs2_pipeline_profile rs2_pipeline_start_with_config(rs2_pipeline pipe,
                                                                  rs2_config config,
                                                                  @Cast(value="rs2_error**")
                                                                  PointerPointer error)
```
Start the pipeline streaming according to the configuraion. The pipeline streaming loop captures samples from the device, and delivers them to the attached computer vision modules and processing blocks, according to each module requirements and threading model. During the loop execution, the application can access the camera streams by calling \c wait_for_frames() or \c poll_for_frames(). The streaming loop runs until the pipeline is stopped. Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised. The pipeline selects and activates the device upon start, according to configuration or a default configuration. When the rs2::config is provided to the method, the pipeline tries to activate the config \c resolve() result. If the application requests are conflicting with pipeline computer vision modules or no matching device is available on the platform, the method fails. Available configurations and devices may change between config \c resolve() call and pipeline start, in case devices are connected or disconnected, or another application acquires ownership of a device.

Parameters:

pipe - [in] a pointer to an instance of the pipeline

config - [in] A rs2::config with requested filters on the pipeline configuration. By default no filters are applied.

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

The actual pipeline device and streams profile, which was successfully configured to the streaming device.

rs2_pipeline_start_with_config

public static rs2_pipeline_profile rs2_pipeline_start_with_config(rs2_pipeline pipe,
                                                                  rs2_config config,
                                                                  @ByPtrPtr
                                                                  rs2_error error)

rs2_pipeline_start_with_callback
```
public static rs2_pipeline_profile rs2_pipeline_start_with_callback(rs2_pipeline pipe,
                                                                    rs2_frame_callback_ptr on_frame,
                                                                    Pointer user,
                                                                    @Cast(value="rs2_error**")
                                                                    PointerPointer error)
```
Start the pipeline streaming with its default configuration. The pipeline captures samples from the device, and delivers them to the through the provided frame callback. Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised. When starting the pipeline with a callback both \c wait_for_frames() or \c poll_for_frames() will throw exception.

Parameters:

pipe - [in] A pointer to an instance of the pipeline

on_frame - [in] function pointer to register as per-frame callback

user - [in] auxiliary data the user wishes to receive together with every frame callback

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

The actual pipeline device and streams profile, which was successfully configured to the streaming device.

rs2_pipeline_start_with_callback

public static rs2_pipeline_profile rs2_pipeline_start_with_callback(rs2_pipeline pipe,
                                                                    rs2_frame_callback_ptr on_frame,
                                                                    Pointer user,
                                                                    @ByPtrPtr
                                                                    rs2_error error)

rs2_pipeline_start_with_callback_cpp
```
public static rs2_pipeline_profile rs2_pipeline_start_with_callback_cpp(rs2_pipeline pipe,
                                                                        rs2_frame_callback callback,
                                                                        @Cast(value="rs2_error**")
                                                                        PointerPointer error)
```
Start the pipeline streaming with its default configuration. The pipeline captures samples from the device, and delivers them to the through the provided frame callback. Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised. When starting the pipeline with a callback both \c wait_for_frames() or \c poll_for_frames() will throw exception.

Parameters:

pipe - [in] A pointer to an instance of the pipeline

callback - [in] callback object created from c++ application. ownership over the callback object is moved into the relevant streaming lock

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

The actual pipeline device and streams profile, which was successfully configured to the streaming device.

rs2_pipeline_start_with_callback_cpp

public static rs2_pipeline_profile rs2_pipeline_start_with_callback_cpp(rs2_pipeline pipe,
                                                                        rs2_frame_callback callback,
                                                                        @ByPtrPtr
                                                                        rs2_error error)

rs2_pipeline_start_with_config_and_callback
```
public static rs2_pipeline_profile rs2_pipeline_start_with_config_and_callback(rs2_pipeline pipe,
                                                                               rs2_config config,
                                                                               rs2_frame_callback_ptr on_frame,
                                                                               Pointer user,
                                                                               @Cast(value="rs2_error**")
                                                                               PointerPointer error)
```
Start the pipeline streaming according to the configuraion. The pipeline captures samples from the device, and delivers them to the through the provided frame callback. Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised. When starting the pipeline with a callback both \c wait_for_frames() or \c poll_for_frames() will throw exception. The pipeline selects and activates the device upon start, according to configuration or a default configuration. When the rs2::config is provided to the method, the pipeline tries to activate the config \c resolve() result. If the application requests are conflicting with pipeline computer vision modules or no matching device is available on the platform, the method fails. Available configurations and devices may change between config \c resolve() call and pipeline start, in case devices are connected or disconnected, or another application acquires ownership of a device.

Parameters:

pipe - [in] A pointer to an instance of the pipeline

config - [in] A rs2::config with requested filters on the pipeline configuration. By default no filters are applied.

on_frame - [in] function pointer to register as per-frame callback

user - [in] auxiliary data the user wishes to receive together with every frame callback

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

The actual pipeline device and streams profile, which was successfully configured to the streaming device.

rs2_pipeline_start_with_config_and_callback

public static rs2_pipeline_profile rs2_pipeline_start_with_config_and_callback(rs2_pipeline pipe,
                                                                               rs2_config config,
                                                                               rs2_frame_callback_ptr on_frame,
                                                                               Pointer user,
                                                                               @ByPtrPtr
                                                                               rs2_error error)

rs2_pipeline_start_with_config_and_callback_cpp
```
public static rs2_pipeline_profile rs2_pipeline_start_with_config_and_callback_cpp(rs2_pipeline pipe,
                                                                                   rs2_config config,
                                                                                   rs2_frame_callback callback,
                                                                                   @Cast(value="rs2_error**")
                                                                                   PointerPointer error)
```
Start the pipeline streaming according to the configuraion. The pipeline captures samples from the device, and delivers them to the through the provided frame callback. Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised. When starting the pipeline with a callback both \c wait_for_frames() or \c poll_for_frames() will throw exception. The pipeline selects and activates the device upon start, according to configuration or a default configuration. When the rs2::config is provided to the method, the pipeline tries to activate the config \c resolve() result. If the application requests are conflicting with pipeline computer vision modules or no matching device is available on the platform, the method fails. Available configurations and devices may change between config \c resolve() call and pipeline start, in case devices are connected or disconnected, or another application acquires ownership of a device.

Parameters:

pipe - [in] A pointer to an instance of the pipeline

config - [in] A rs2::config with requested filters on the pipeline configuration. By default no filters are applied.

callback - [in] callback object created from c++ application. ownership over the callback object is moved into the relevant streaming lock

error - [out] If non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

The actual pipeline device and streams profile, which was successfully configured to the streaming device.

rs2_pipeline_start_with_config_and_callback_cpp

public static rs2_pipeline_profile rs2_pipeline_start_with_config_and_callback_cpp(rs2_pipeline pipe,
                                                                                   rs2_config config,
                                                                                   rs2_frame_callback callback,
                                                                                   @ByPtrPtr
                                                                                   rs2_error error)

rs2_pipeline_get_active_profile
```
public static rs2_pipeline_profile rs2_pipeline_get_active_profile(rs2_pipeline pipe,
                                                                   @Cast(value="rs2_error**")
                                                                   PointerPointer error)
```
Return the active device and streams profiles, used by the pipeline. The pipeline streams profiles are selected during \c start(). The method returns a valid result only when the pipeline is active - between calls to \c start() and \c stop(). After \c stop() is called, the pipeline doesn't own the device, thus, the pipeline selected device may change in subsequent activations.

Parameters:

pipe - [in] a pointer to an instance of the pipeline

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

The actual pipeline device and streams profile, which was successfully configured to the streaming device on start.

rs2_pipeline_get_active_profile

public static rs2_pipeline_profile rs2_pipeline_get_active_profile(rs2_pipeline pipe,
                                                                   @ByPtrPtr
                                                                   rs2_error error)

rs2_pipeline_profile_get_device
```
public static rs2_device rs2_pipeline_profile_get_device(rs2_pipeline_profile profile,
                                                         @Cast(value="rs2_error**")
                                                         PointerPointer error)
```
Retrieve the device used by the pipeline. The device class provides the application access to control camera additional settings - get device information, sensor options information, options value query and set, sensor specific extensions. Since the pipeline controls the device streams configuration, activation state and frames reading, calling the device API functions, which execute those operations, results in unexpected behavior. The pipeline streaming device is selected during pipeline \c start(). Devices of profiles, which are not returned by pipeline \c start() or \c get_active_profile(), are not guaranteed to be used by the pipeline.

Parameters:

profile - [in] A pointer to an instance of a pipeline profile

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

rs2_device* The pipeline selected device

rs2_pipeline_profile_get_device

public static rs2_device rs2_pipeline_profile_get_device(rs2_pipeline_profile profile,
                                                         @ByPtrPtr
                                                         rs2_error error)

rs2_pipeline_profile_get_streams

public static rs2_stream_profile_list rs2_pipeline_profile_get_streams(rs2_pipeline_profile profile,
                                                                       @Cast(value="rs2_error**")
                                                                       PointerPointer error)

Return the selected streams profiles, which are enabled in this profile.

Parameters:: profile - [in] A pointer to an instance of a pipeline profile; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: list of stream profiles

rs2_pipeline_profile_get_streams

public static rs2_stream_profile_list rs2_pipeline_profile_get_streams(rs2_pipeline_profile profile,
                                                                       @ByPtrPtr
                                                                       rs2_error error)

rs2_delete_pipeline_profile
```
public static void rs2_delete_pipeline_profile(rs2_pipeline_profile profile)
```
Deletes an instance of a pipeline profile

Parameters:

profile - [in] A pointer to an instance of a pipeline profile

RS2_API_VERSION_STR

@MemberGetter
public static String RS2_API_VERSION_STR()

RS2_API_FULL_VERSION_STR

@MemberGetter
public static String RS2_API_FULL_VERSION_STR()

rs2_get_raw_data_size

public static int rs2_get_raw_data_size(@Const
                                        rs2_raw_data_buffer buffer,
                                        @Cast(value="rs2_error**")
                                        PointerPointer error)

get the size of rs2_raw_data_buffer

Parameters:: buffer - [in] pointer to rs2_raw_data_buffer returned by rs2_send_and_receive_raw_data; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: size of rs2_raw_data_buffer

rs2_get_raw_data_size

public static int rs2_get_raw_data_size(@Const
                                        rs2_raw_data_buffer buffer,
                                        @ByPtrPtr
                                        rs2_error error)

rs2_delete_raw_data

public static void rs2_delete_raw_data(@Const
                                       rs2_raw_data_buffer buffer)

Delete rs2_raw_data_buffer

Parameters:: buffer - [in] rs2_raw_data_buffer returned by rs2_send_and_receive_raw_data

rs2_get_raw_data

@Cast(value="const unsigned char*")
public static BytePointer rs2_get_raw_data(@Const
                                                                                rs2_raw_data_buffer buffer,
                                                                                @Cast(value="rs2_error**")
                                                                                PointerPointer error)

Retrieve char array from rs2_raw_data_buffer

Parameters:: buffer - [in] rs2_raw_data_buffer returned by rs2_send_and_receive_raw_data; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: raw data

rs2_get_raw_data

@Cast(value="const unsigned char*")
public static BytePointer rs2_get_raw_data(@Const
                                                                                rs2_raw_data_buffer buffer,
                                                                                @ByPtrPtr
                                                                                rs2_error error)

rs2_get_api_version
```
public static int rs2_get_api_version(@Cast(value="rs2_error**")
                                      PointerPointer error)
```
Retrieve the API version from the source code. Evaluate that the value is conformant to the established policies

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

the version API encoded into integer value "1.9.3" -> 10903

rs2_get_api_version

public static int rs2_get_api_version(@ByPtrPtr
                                      rs2_error error)

rs2_log_to_console

public static void rs2_log_to_console(@Cast(value="rs2_log_severity")
                                      int min_severity,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

rs2_log_to_console

public static void rs2_log_to_console(@Cast(value="rs2_log_severity")
                                      int min_severity,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_log_to_file

public static void rs2_log_to_file(@Cast(value="rs2_log_severity")
                                   int min_severity,
                                   @Cast(value="const char*")
                                   BytePointer file_path,
                                   @Cast(value="rs2_error**")
                                   PointerPointer error)

rs2_log_to_file

public static void rs2_log_to_file(@Cast(value="rs2_log_severity")
                                   int min_severity,
                                   @Cast(value="const char*")
                                   BytePointer file_path,
                                   @ByPtrPtr
                                   rs2_error error)

rs2_log_to_file

public static void rs2_log_to_file(@Cast(value="rs2_log_severity")
                                   int min_severity,
                                   String file_path,
                                   @ByPtrPtr
                                   rs2_error error)

rs2_log_to_callback_cpp

public static void rs2_log_to_callback_cpp(@Cast(value="rs2_log_severity")
                                           int min_severity,
                                           rs2_log_callback callback,
                                           @Cast(value="rs2_error**")
                                           PointerPointer error)

rs2_log_to_callback_cpp

public static void rs2_log_to_callback_cpp(@Cast(value="rs2_log_severity")
                                           int min_severity,
                                           rs2_log_callback callback,
                                           @ByPtrPtr
                                           rs2_error error)

rs2_log_to_callback

public static void rs2_log_to_callback(@Cast(value="rs2_log_severity")
                                       int min_severity,
                                       rs2_log_callback_ptr callback,
                                       Pointer arg,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

rs2_log_to_callback

public static void rs2_log_to_callback(@Cast(value="rs2_log_severity")
                                       int min_severity,
                                       rs2_log_callback_ptr callback,
                                       Pointer arg,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_reset_logger

public static void rs2_reset_logger(@Cast(value="rs2_error**")
                                    PointerPointer error)

rs2_reset_logger

public static void rs2_reset_logger(@ByPtrPtr
                                    rs2_error error)

rs2_enable_rolling_log_file
```
public static void rs2_enable_rolling_log_file(@Cast(value="unsigned")
                                               int max_size,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)
```
Enable rolling log file when used with rs2_log_to_file: Upon reaching (max_size/2) bytes, the log will be renamed with an ".old" suffix and a new log created. Any previous .old file will be erased. Must have permissions to remove/rename files in log file directory.

Parameters:

max_size - [in] max file size in megabytes

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_enable_rolling_log_file

public static void rs2_enable_rolling_log_file(@Cast(value="unsigned")
                                               int max_size,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_get_log_message_line_number

@Cast(value="unsigned")
public static int rs2_get_log_message_line_number(@Const
                                                                           rs2_log_message msg,
                                                                           @Cast(value="rs2_error**")
                                                                           PointerPointer error)

rs2_get_log_message_line_number

@Cast(value="unsigned")
public static int rs2_get_log_message_line_number(@Const
                                                                           rs2_log_message msg,
                                                                           @ByPtrPtr
                                                                           rs2_error error)

rs2_get_log_message_filename

@Cast(value="const char*")
public static BytePointer rs2_get_log_message_filename(@Const
                                                                                   rs2_log_message msg,
                                                                                   @Cast(value="rs2_error**")
                                                                                   PointerPointer error)

rs2_get_log_message_filename

@Cast(value="const char*")
public static BytePointer rs2_get_log_message_filename(@Const
                                                                                   rs2_log_message msg,
                                                                                   @ByPtrPtr
                                                                                   rs2_error error)

rs2_get_raw_log_message

@Cast(value="const char*")
public static BytePointer rs2_get_raw_log_message(@Const
                                                                              rs2_log_message msg,
                                                                              @Cast(value="rs2_error**")
                                                                              PointerPointer error)

rs2_get_raw_log_message

@Cast(value="const char*")
public static BytePointer rs2_get_raw_log_message(@Const
                                                                              rs2_log_message msg,
                                                                              @ByPtrPtr
                                                                              rs2_error error)

rs2_get_full_log_message

@Cast(value="const char*")
public static BytePointer rs2_get_full_log_message(@Const
                                                                               rs2_log_message msg,
                                                                               @Cast(value="rs2_error**")
                                                                               PointerPointer error)

rs2_get_full_log_message

@Cast(value="const char*")
public static BytePointer rs2_get_full_log_message(@Const
                                                                               rs2_log_message msg,
                                                                               @ByPtrPtr
                                                                               rs2_error error)

rs2_log

public static void rs2_log(@Cast(value="rs2_log_severity")
                           int severity,
                           @Cast(value="const char*")
                           BytePointer message,
                           @Cast(value="rs2_error**")
                           PointerPointer error)

Add custom message into librealsense log

Parameters:: severity - [in] The log level for the message to be written under; message - [in] Message to be logged; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_log

public static void rs2_log(@Cast(value="rs2_log_severity")
                           int severity,
                           @Cast(value="const char*")
                           BytePointer message,
                           @ByPtrPtr
                           rs2_error error)

rs2_log

public static void rs2_log(@Cast(value="rs2_log_severity")
                           int severity,
                           String message,
                           @ByPtrPtr
                           rs2_error error)

rs2_depth_frame_get_distance

public static float rs2_depth_frame_get_distance(@Const
                                                 rs2_frame frame_ref,
                                                 int x,
                                                 int y,
                                                 @Cast(value="rs2_error**")
                                                 PointerPointer error)

Given the 2D depth coordinate (x,y) provide the corresponding depth in metric units

Parameters:: frame_ref - [in] 2D depth pixel coordinates (Left-Upper corner origin); x - [in] ,y 2D depth pixel coordinates (Left-Upper corner origin); error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs2_depth_frame_get_distance

public static float rs2_depth_frame_get_distance(@Const
                                                 rs2_frame frame_ref,
                                                 int x,
                                                 int y,
                                                 @ByPtrPtr
                                                 rs2_error error)

rs2_get_time
```
@Cast(value="rs2_time_t")
public static double rs2_get_time(@Cast(value="rs2_error**")
                                                             PointerPointer error)
```
return the time at specific time point

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

the time at specific time point, in live and record mode it will return the system time and in playback mode it will return the recorded time

rs2_get_time

@Cast(value="rs2_time_t")
public static double rs2_get_time(@ByPtrPtr
                                                             rs2_error error)

rs2_toggle_advanced_mode

public static void rs2_toggle_advanced_mode(rs2_device dev,
                                            int enable,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

rs2_toggle_advanced_mode

public static void rs2_toggle_advanced_mode(rs2_device dev,
                                            int enable,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_is_enabled

public static void rs2_is_enabled(rs2_device dev,
                                  IntPointer enabled,
                                  @Cast(value="rs2_error**")
                                  PointerPointer error)

rs2_is_enabled

public static void rs2_is_enabled(rs2_device dev,
                                  IntPointer enabled,
                                  @ByPtrPtr
                                  rs2_error error)

rs2_is_enabled

public static void rs2_is_enabled(rs2_device dev,
                                  IntBuffer enabled,
                                  @ByPtrPtr
                                  rs2_error error)

rs2_is_enabled

public static void rs2_is_enabled(rs2_device dev,
                                  int[] enabled,
                                  @ByPtrPtr
                                  rs2_error error)

rs2_set_depth_control

public static void rs2_set_depth_control(rs2_device dev,
                                         @Const
                                         STDepthControlGroup group,
                                         @Cast(value="rs2_error**")
                                         PointerPointer error)

rs2_set_depth_control

public static void rs2_set_depth_control(rs2_device dev,
                                         @Const
                                         STDepthControlGroup group,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_get_depth_control

public static void rs2_get_depth_control(rs2_device dev,
                                         STDepthControlGroup group,
                                         int mode,
                                         @Cast(value="rs2_error**")
                                         PointerPointer error)

rs2_get_depth_control

public static void rs2_get_depth_control(rs2_device dev,
                                         STDepthControlGroup group,
                                         int mode,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_set_rsm

public static void rs2_set_rsm(rs2_device dev,
                               @Const
                               STRsm group,
                               @Cast(value="rs2_error**")
                               PointerPointer error)

rs2_set_rsm

public static void rs2_set_rsm(rs2_device dev,
                               @Const
                               STRsm group,
                               @ByPtrPtr
                               rs2_error error)

rs2_get_rsm

public static void rs2_get_rsm(rs2_device dev,
                               STRsm group,
                               int mode,
                               @Cast(value="rs2_error**")
                               PointerPointer error)

rs2_get_rsm

public static void rs2_get_rsm(rs2_device dev,
                               STRsm group,
                               int mode,
                               @ByPtrPtr
                               rs2_error error)

rs2_set_rau_support_vector_control

public static void rs2_set_rau_support_vector_control(rs2_device dev,
                                                      @Const
                                                      STRauSupportVectorControl group,
                                                      @Cast(value="rs2_error**")
                                                      PointerPointer error)

rs2_set_rau_support_vector_control

public static void rs2_set_rau_support_vector_control(rs2_device dev,
                                                      @Const
                                                      STRauSupportVectorControl group,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_get_rau_support_vector_control

public static void rs2_get_rau_support_vector_control(rs2_device dev,
                                                      STRauSupportVectorControl group,
                                                      int mode,
                                                      @Cast(value="rs2_error**")
                                                      PointerPointer error)

rs2_get_rau_support_vector_control

public static void rs2_get_rau_support_vector_control(rs2_device dev,
                                                      STRauSupportVectorControl group,
                                                      int mode,
                                                      @ByPtrPtr
                                                      rs2_error error)

rs2_set_color_control

public static void rs2_set_color_control(rs2_device dev,
                                         @Const
                                         STColorControl group,
                                         @Cast(value="rs2_error**")
                                         PointerPointer error)

rs2_set_color_control

public static void rs2_set_color_control(rs2_device dev,
                                         @Const
                                         STColorControl group,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_get_color_control

public static void rs2_get_color_control(rs2_device dev,
                                         STColorControl group,
                                         int mode,
                                         @Cast(value="rs2_error**")
                                         PointerPointer error)

rs2_get_color_control

public static void rs2_get_color_control(rs2_device dev,
                                         STColorControl group,
                                         int mode,
                                         @ByPtrPtr
                                         rs2_error error)

rs2_set_rau_thresholds_control

public static void rs2_set_rau_thresholds_control(rs2_device dev,
                                                  @Const
                                                  STRauColorThresholdsControl group,
                                                  @Cast(value="rs2_error**")
                                                  PointerPointer error)

rs2_set_rau_thresholds_control

public static void rs2_set_rau_thresholds_control(rs2_device dev,
                                                  @Const
                                                  STRauColorThresholdsControl group,
                                                  @ByPtrPtr
                                                  rs2_error error)

rs2_get_rau_thresholds_control

public static void rs2_get_rau_thresholds_control(rs2_device dev,
                                                  STRauColorThresholdsControl group,
                                                  int mode,
                                                  @Cast(value="rs2_error**")
                                                  PointerPointer error)

rs2_get_rau_thresholds_control

public static void rs2_get_rau_thresholds_control(rs2_device dev,
                                                  STRauColorThresholdsControl group,
                                                  int mode,
                                                  @ByPtrPtr
                                                  rs2_error error)

rs2_set_slo_color_thresholds_control

public static void rs2_set_slo_color_thresholds_control(rs2_device dev,
                                                        @Const
                                                        STSloColorThresholdsControl group,
                                                        @Cast(value="rs2_error**")
                                                        PointerPointer error)

rs2_set_slo_color_thresholds_control

public static void rs2_set_slo_color_thresholds_control(rs2_device dev,
                                                        @Const
                                                        STSloColorThresholdsControl group,
                                                        @ByPtrPtr
                                                        rs2_error error)

rs2_get_slo_color_thresholds_control

public static void rs2_get_slo_color_thresholds_control(rs2_device dev,
                                                        STSloColorThresholdsControl group,
                                                        int mode,
                                                        @Cast(value="rs2_error**")
                                                        PointerPointer error)

rs2_get_slo_color_thresholds_control

public static void rs2_get_slo_color_thresholds_control(rs2_device dev,
                                                        STSloColorThresholdsControl group,
                                                        int mode,
                                                        @ByPtrPtr
                                                        rs2_error error)

rs2_set_slo_penalty_control

public static void rs2_set_slo_penalty_control(rs2_device dev,
                                               @Const
                                               STSloPenaltyControl group,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)

rs2_set_slo_penalty_control

public static void rs2_set_slo_penalty_control(rs2_device dev,
                                               @Const
                                               STSloPenaltyControl group,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_get_slo_penalty_control

public static void rs2_get_slo_penalty_control(rs2_device dev,
                                               STSloPenaltyControl group,
                                               int mode,
                                               @Cast(value="rs2_error**")
                                               PointerPointer error)

rs2_get_slo_penalty_control

public static void rs2_get_slo_penalty_control(rs2_device dev,
                                               STSloPenaltyControl group,
                                               int mode,
                                               @ByPtrPtr
                                               rs2_error error)

rs2_set_hdad

public static void rs2_set_hdad(rs2_device dev,
                                @Const
                                STHdad group,
                                @Cast(value="rs2_error**")
                                PointerPointer error)

rs2_set_hdad

public static void rs2_set_hdad(rs2_device dev,
                                @Const
                                STHdad group,
                                @ByPtrPtr
                                rs2_error error)

rs2_get_hdad

public static void rs2_get_hdad(rs2_device dev,
                                STHdad group,
                                int mode,
                                @Cast(value="rs2_error**")
                                PointerPointer error)

rs2_get_hdad

public static void rs2_get_hdad(rs2_device dev,
                                STHdad group,
                                int mode,
                                @ByPtrPtr
                                rs2_error error)

rs2_set_color_correction

public static void rs2_set_color_correction(rs2_device dev,
                                            @Const
                                            STColorCorrection group,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

rs2_set_color_correction

public static void rs2_set_color_correction(rs2_device dev,
                                            @Const
                                            STColorCorrection group,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_get_color_correction

public static void rs2_get_color_correction(rs2_device dev,
                                            STColorCorrection group,
                                            int mode,
                                            @Cast(value="rs2_error**")
                                            PointerPointer error)

rs2_get_color_correction

public static void rs2_get_color_correction(rs2_device dev,
                                            STColorCorrection group,
                                            int mode,
                                            @ByPtrPtr
                                            rs2_error error)

rs2_set_depth_table

public static void rs2_set_depth_table(rs2_device dev,
                                       @Const
                                       STDepthTableControl group,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

rs2_set_depth_table

public static void rs2_set_depth_table(rs2_device dev,
                                       @Const
                                       STDepthTableControl group,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_get_depth_table

public static void rs2_get_depth_table(rs2_device dev,
                                       STDepthTableControl group,
                                       int mode,
                                       @Cast(value="rs2_error**")
                                       PointerPointer error)

rs2_get_depth_table

public static void rs2_get_depth_table(rs2_device dev,
                                       STDepthTableControl group,
                                       int mode,
                                       @ByPtrPtr
                                       rs2_error error)

rs2_set_ae_control

public static void rs2_set_ae_control(rs2_device dev,
                                      @Const
                                      STAEControl group,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

rs2_set_ae_control

public static void rs2_set_ae_control(rs2_device dev,
                                      @Const
                                      STAEControl group,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_get_ae_control

public static void rs2_get_ae_control(rs2_device dev,
                                      STAEControl group,
                                      int mode,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

rs2_get_ae_control

public static void rs2_get_ae_control(rs2_device dev,
                                      STAEControl group,
                                      int mode,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_set_census

public static void rs2_set_census(rs2_device dev,
                                  @Const
                                  STCensusRadius group,
                                  @Cast(value="rs2_error**")
                                  PointerPointer error)

rs2_set_census

public static void rs2_set_census(rs2_device dev,
                                  @Const
                                  STCensusRadius group,
                                  @ByPtrPtr
                                  rs2_error error)

rs2_get_census

public static void rs2_get_census(rs2_device dev,
                                  STCensusRadius group,
                                  int mode,
                                  @Cast(value="rs2_error**")
                                  PointerPointer error)

rs2_get_census

public static void rs2_get_census(rs2_device dev,
                                  STCensusRadius group,
                                  int mode,
                                  @ByPtrPtr
                                  rs2_error error)

rs2_set_amp_factor

public static void rs2_set_amp_factor(rs2_device dev,
                                      @Const
                                      STAFactor group,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

rs2_set_amp_factor

public static void rs2_set_amp_factor(rs2_device dev,
                                      @Const
                                      STAFactor group,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_get_amp_factor

public static void rs2_get_amp_factor(rs2_device dev,
                                      STAFactor group,
                                      int mode,
                                      @Cast(value="rs2_error**")
                                      PointerPointer error)

rs2_get_amp_factor

public static void rs2_get_amp_factor(rs2_device dev,
                                      STAFactor group,
                                      int mode,
                                      @ByPtrPtr
                                      rs2_error error)

rs2_project_point_to_pixel

public static void rs2_project_point_to_pixel(FloatPointer pixel,
                                              @Const
                                              rs2_intrinsics intrin,
                                              @Const
                                              FloatPointer point)

rs2_project_point_to_pixel

public static void rs2_project_point_to_pixel(FloatBuffer pixel,
                                              @Const
                                              rs2_intrinsics intrin,
                                              @Const
                                              FloatBuffer point)

rs2_project_point_to_pixel

public static void rs2_project_point_to_pixel(float[] pixel,
                                              @Const
                                              rs2_intrinsics intrin,
                                              @Const
                                              float[] point)

rs2_deproject_pixel_to_point

public static void rs2_deproject_pixel_to_point(FloatPointer point,
                                                @Const
                                                rs2_intrinsics intrin,
                                                @Const
                                                FloatPointer pixel,
                                                float depth)

rs2_deproject_pixel_to_point

public static void rs2_deproject_pixel_to_point(FloatBuffer point,
                                                @Const
                                                rs2_intrinsics intrin,
                                                @Const
                                                FloatBuffer pixel,
                                                float depth)

rs2_deproject_pixel_to_point

public static void rs2_deproject_pixel_to_point(float[] point,
                                                @Const
                                                rs2_intrinsics intrin,
                                                @Const
                                                float[] pixel,
                                                float depth)

rs2_transform_point_to_point

public static void rs2_transform_point_to_point(FloatPointer to_point,
                                                @Const
                                                rs2_extrinsics extrin,
                                                @Const
                                                FloatPointer from_point)

rs2_transform_point_to_point

public static void rs2_transform_point_to_point(FloatBuffer to_point,
                                                @Const
                                                rs2_extrinsics extrin,
                                                @Const
                                                FloatBuffer from_point)

rs2_transform_point_to_point

public static void rs2_transform_point_to_point(float[] to_point,
                                                @Const
                                                rs2_extrinsics extrin,
                                                @Const
                                                float[] from_point)

rs2_fov

public static void rs2_fov(@Const
                           rs2_intrinsics intrin,
                           FloatPointer to_fov)

rs2_fov

public static void rs2_fov(@Const
                           rs2_intrinsics intrin,
                           FloatBuffer to_fov)

rs2_fov

public static void rs2_fov(@Const
                           rs2_intrinsics intrin,
                           float[] to_fov)

rs2_project_color_pixel_to_depth_pixel

public static void rs2_project_color_pixel_to_depth_pixel(FloatPointer to_pixel,
                                                          @Cast(value="const uint16_t*")
                                                          ShortPointer data,
                                                          float depth_scale,
                                                          float depth_min,
                                                          float depth_max,
                                                          @Const
                                                          rs2_intrinsics depth_intrin,
                                                          @Const
                                                          rs2_intrinsics color_intrin,
                                                          @Const
                                                          rs2_extrinsics color_to_depth,
                                                          @Const
                                                          rs2_extrinsics depth_to_color,
                                                          @Const
                                                          FloatPointer from_pixel)

rs2_project_color_pixel_to_depth_pixel

public static void rs2_project_color_pixel_to_depth_pixel(FloatBuffer to_pixel,
                                                          @Cast(value="const uint16_t*")
                                                          ShortBuffer data,
                                                          float depth_scale,
                                                          float depth_min,
                                                          float depth_max,
                                                          @Const
                                                          rs2_intrinsics depth_intrin,
                                                          @Const
                                                          rs2_intrinsics color_intrin,
                                                          @Const
                                                          rs2_extrinsics color_to_depth,
                                                          @Const
                                                          rs2_extrinsics depth_to_color,
                                                          @Const
                                                          FloatBuffer from_pixel)

rs2_project_color_pixel_to_depth_pixel

public static void rs2_project_color_pixel_to_depth_pixel(float[] to_pixel,
                                                          @Cast(value="const uint16_t*")
                                                          short[] data,
                                                          float depth_scale,
                                                          float depth_min,
                                                          float depth_max,
                                                          @Const
                                                          rs2_intrinsics depth_intrin,
                                                          @Const
                                                          rs2_intrinsics color_intrin,
                                                          @Const
                                                          rs2_extrinsics color_to_depth,
                                                          @Const
                                                          rs2_extrinsics depth_to_color,
                                                          @Const
                                                          float[] from_pixel)

Class realsense2

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.librealsense2.presets.realsense2

Methods inherited from class java.lang.Object

Field Detail

RS2_NOTIFICATION_CATEGORY_FRAMES_TIMEOUT

RS2_NOTIFICATION_CATEGORY_FRAME_CORRUPTED

RS2_NOTIFICATION_CATEGORY_HARDWARE_ERROR

RS2_NOTIFICATION_CATEGORY_HARDWARE_EVENT

RS2_NOTIFICATION_CATEGORY_UNKNOWN_ERROR

RS2_NOTIFICATION_CATEGORY_FIRMWARE_UPDATE_RECOMMENDED

RS2_NOTIFICATION_CATEGORY_POSE_RELOCALIZATION

RS2_NOTIFICATION_CATEGORY_COUNT

RS2_EXCEPTION_TYPE_UNKNOWN

RS2_EXCEPTION_TYPE_CAMERA_DISCONNECTED

RS2_EXCEPTION_TYPE_BACKEND

RS2_EXCEPTION_TYPE_INVALID_VALUE

RS2_EXCEPTION_TYPE_WRONG_API_CALL_SEQUENCE

RS2_EXCEPTION_TYPE_NOT_IMPLEMENTED

RS2_EXCEPTION_TYPE_DEVICE_IN_RECOVERY_MODE

RS2_EXCEPTION_TYPE_IO

RS2_EXCEPTION_TYPE_COUNT

RS2_DISTORTION_NONE

RS2_DISTORTION_MODIFIED_BROWN_CONRADY

RS2_DISTORTION_INVERSE_BROWN_CONRADY

RS2_DISTORTION_FTHETA

RS2_DISTORTION_BROWN_CONRADY

RS2_DISTORTION_KANNALA_BRANDT4

RS2_DISTORTION_COUNT

RS2_DSM_CORRECTION_NONE

RS2_DSM_CORRECTION_AOT

RS2_DSM_CORRECTION_TOA

RS2_DSM_CORRECTION_COUNT

RS2_LOG_SEVERITY_DEBUG

RS2_LOG_SEVERITY_INFO

RS2_LOG_SEVERITY_WARN

RS2_LOG_SEVERITY_ERROR

RS2_LOG_SEVERITY_FATAL

RS2_LOG_SEVERITY_NONE

RS2_LOG_SEVERITY_COUNT

RS2_LOG_SEVERITY_ALL

RS2_EXTENSION_UNKNOWN

RS2_EXTENSION_DEBUG

RS2_EXTENSION_INFO

RS2_EXTENSION_MOTION

RS2_EXTENSION_OPTIONS

RS2_EXTENSION_VIDEO

RS2_EXTENSION_ROI

RS2_EXTENSION_DEPTH_SENSOR

RS2_EXTENSION_VIDEO_FRAME

RS2_EXTENSION_MOTION_FRAME

RS2_EXTENSION_COMPOSITE_FRAME

RS2_EXTENSION_POINTS

RS2_EXTENSION_DEPTH_FRAME

RS2_EXTENSION_ADVANCED_MODE

RS2_EXTENSION_RECORD

RS2_EXTENSION_VIDEO_PROFILE

RS2_EXTENSION_PLAYBACK

RS2_EXTENSION_DEPTH_STEREO_SENSOR

RS2_EXTENSION_DISPARITY_FRAME

RS2_EXTENSION_MOTION_PROFILE

RS2_EXTENSION_POSE_FRAME

RS2_EXTENSION_POSE_PROFILE

RS2_EXTENSION_TM2

RS2_EXTENSION_SOFTWARE_DEVICE

RS2_EXTENSION_SOFTWARE_SENSOR

RS2_EXTENSION_DECIMATION_FILTER

RS2_EXTENSION_THRESHOLD_FILTER

RS2_EXTENSION_DISPARITY_FILTER

RS2_EXTENSION_SPATIAL_FILTER

RS2_EXTENSION_TEMPORAL_FILTER

RS2_EXTENSION_HOLE_FILLING_FILTER

RS2_EXTENSION_ZERO_ORDER_FILTER

RS2_EXTENSION_RECOMMENDED_FILTERS

RS2_EXTENSION_POSE

RS2_EXTENSION_POSE_SENSOR

RS2_EXTENSION_WHEEL_ODOMETER

RS2_EXTENSION_GLOBAL_TIMER