/* License: Apache 2.0. See LICENSE file in root directory.
Copyright(c) 2017 Intel Corporation. All Rights Reserved. */
/** \file rs_frame.h
* \brief
* Exposes RealSense frame functionality for C compilers
*/
#ifndef LIBREALSENSE_RS2_FRAME_H
#define LIBREALSENSE_RS2_FRAME_H
#ifdef __cplusplus
extern "C" {
#endif
#include "rs_types.h"
/** \brief Specifies the clock in relation to which the frame timestamp was measured. */
typedef enum rs2_timestamp_domain
{
RS2_TIMESTAMP_DOMAIN_HARDWARE_CLOCK, /**< Frame timestamp was measured in relation to the camera clock */
RS2_TIMESTAMP_DOMAIN_SYSTEM_TIME, /**< Frame timestamp was measured in relation to the OS system clock */
RS2_TIMESTAMP_DOMAIN_GLOBAL_TIME, /**< Frame timestamp was measured in relation to the camera clock and converted to OS system clock by constantly measure the difference*/
RS2_TIMESTAMP_DOMAIN_COUNT /**< Number of enumeration values. Not a valid input: intended to be used in for-loops. */
} rs2_timestamp_domain;
const char* rs2_timestamp_domain_to_string(rs2_timestamp_domain info);
/** \brief Per-Frame-Metadata is the set of read-only properties that might be exposed for each individual frame. */
typedef enum rs2_frame_metadata_value
{
RS2_FRAME_METADATA_FRAME_COUNTER , /**< A sequential index managed per-stream. Integer value*/
RS2_FRAME_METADATA_FRAME_TIMESTAMP , /**< Timestamp set by device clock when data readout and transmit commence. usec*/
RS2_FRAME_METADATA_SENSOR_TIMESTAMP , /**< Timestamp of the middle of sensor's exposure calculated by device. usec*/
RS2_FRAME_METADATA_ACTUAL_EXPOSURE , /**< Sensor's exposure width. When Auto Exposure (AE) is on the value is controlled by firmware. usec*/
RS2_FRAME_METADATA_GAIN_LEVEL , /**< A relative value increasing which will increase the Sensor's gain factor. \
When AE is set On, the value is controlled by firmware. Integer value*/
RS2_FRAME_METADATA_AUTO_EXPOSURE , /**< Auto Exposure Mode indicator. Zero corresponds to AE switched off. */
RS2_FRAME_METADATA_WHITE_BALANCE , /**< White Balance setting as a color temperature. Kelvin degrees*/
RS2_FRAME_METADATA_TIME_OF_ARRIVAL , /**< Time of arrival in system clock */
RS2_FRAME_METADATA_TEMPERATURE , /**< Temperature of the device, measured at the time of the frame capture. Celsius degrees */
RS2_FRAME_METADATA_BACKEND_TIMESTAMP , /**< Timestamp get from uvc driver. usec*/
RS2_FRAME_METADATA_ACTUAL_FPS , /**< Actual fps, times 1000 (30.1 fps would be 30100 in the metadata) */
RS2_FRAME_METADATA_FRAME_LASER_POWER , /**< Laser power value 0-360. */
RS2_FRAME_METADATA_FRAME_LASER_POWER_MODE , /**< Laser power mode. Zero corresponds to Laser power switched off and one for switched on. deprecated, replaced by RS2_FRAME_METADATA_FRAME_EMITTER_MODE*/
RS2_FRAME_METADATA_EXPOSURE_PRIORITY , /**< Exposure priority. */
RS2_FRAME_METADATA_EXPOSURE_ROI_LEFT , /**< Left region of interest for the auto exposure Algorithm. */
RS2_FRAME_METADATA_EXPOSURE_ROI_RIGHT , /**< Right region of interest for the auto exposure Algorithm. */
RS2_FRAME_METADATA_EXPOSURE_ROI_TOP , /**< Top region of interest for the auto exposure Algorithm. */
RS2_FRAME_METADATA_EXPOSURE_ROI_BOTTOM , /**< Bottom region of interest for the auto exposure Algorithm. */
RS2_FRAME_METADATA_BRIGHTNESS , /**< Color image brightness. */
RS2_FRAME_METADATA_CONTRAST , /**< Color image contrast. */
RS2_FRAME_METADATA_SATURATION , /**< Color image saturation. */
RS2_FRAME_METADATA_SHARPNESS , /**< Color image sharpness. */
RS2_FRAME_METADATA_AUTO_WHITE_BALANCE_TEMPERATURE , /**< Auto white balance temperature Mode indicator. Zero corresponds to automatic mode switched off. */
RS2_FRAME_METADATA_BACKLIGHT_COMPENSATION , /**< Color backlight compensation. Zero corresponds to switched off. */
RS2_FRAME_METADATA_HUE , /**< Color image hue. */
RS2_FRAME_METADATA_GAMMA , /**< Color image gamma. */
RS2_FRAME_METADATA_MANUAL_WHITE_BALANCE , /**< Color image white balance. */
RS2_FRAME_METADATA_POWER_LINE_FREQUENCY , /**< Power Line Frequency for anti-flickering Off/50Hz/60Hz/Auto. */
RS2_FRAME_METADATA_LOW_LIGHT_COMPENSATION , /**< Color lowlight compensation. Zero corresponds to switched off. */
RS2_FRAME_METADATA_FRAME_EMITTER_MODE , /**< Emitter mode: 0 - all emitters disabled. 1 - laser enabled. 2 - auto laser enabled (opt). 3 - LED enabled (opt).*/
RS2_FRAME_METADATA_FRAME_LED_POWER , /**< Led power value 0-360. */
RS2_FRAME_METADATA_RAW_FRAME_SIZE , /**< The number of transmitted payload bytes, not including metadata */
RS2_FRAME_METADATA_GPIO_INPUT_DATA , /**< GPIO input data */
RS2_FRAME_METADATA_SEQUENCE_NAME , /**< sub-preset id */
RS2_FRAME_METADATA_SEQUENCE_ID , /**< sub-preset sequence id */
RS2_FRAME_METADATA_SEQUENCE_SIZE , /**< sub-preset sequence size */
//mipi metadata_values
RS2_FRAME_METADATA_TRIGGER , /**< Frame trigger type */
RS2_FRAME_METADATA_PRESET , /**< Preset id, used in MIPI SKU Metadata */
RS2_FRAME_METADATA_INPUT_WIDTH , /**< Frame input width in pixels, used as safety attribute */
RS2_FRAME_METADATA_INPUT_HEIGHT , /**< Frame input height in pixels, used as safety attribute */
RS2_FRAME_METADATA_SUB_PRESET_INFO , /**< Sub-preset information */
RS2_FRAME_METADATA_CALIB_INFO , /**< FW-controlled frame counter to be using in Calibration scenarios */
RS2_FRAME_METADATA_CRC , /**< CRC checksum of the Metadata */
RS2_FRAME_METADATA_COUNT
} rs2_frame_metadata_value;
const char* rs2_frame_metadata_to_string(rs2_frame_metadata_value metadata);
const char* rs2_frame_metadata_value_to_string(rs2_frame_metadata_value metadata);
/** \brief Calibration target type. */
typedef enum rs2_calib_target_type
{
RS2_CALIB_TARGET_RECT_GAUSSIAN_DOT_VERTICES, /**< Flat rectangle with vertices as the centers of Gaussian dots */
RS2_CALIB_TARGET_ROI_RECT_GAUSSIAN_DOT_VERTICES, /**< Flat rectangle with vertices as the centers of Gaussian dots with target inside the ROI */
RS2_CALIB_TARGET_POS_GAUSSIAN_DOT_VERTICES, /**< Positions of vertices as the centers of Gaussian dots with target inside the ROI */
RS2_CALIB_TARGET_COUNT /**< Number of enumeration values. Not a valid input: intended to be used in for-loops. */
} rs2_calib_target_type;
const char* rs2_calib_target_type_to_string(rs2_calib_target_type type);
/**
* retrieve metadata from frame handle
* \param[in] frame handle returned from a callback
* \param[in] frame_metadata the rs2_frame_metadata whose latest frame we are interested in
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return the metadata value
*/
rs2_metadata_type rs2_get_frame_metadata(const rs2_frame* frame, rs2_frame_metadata_value frame_metadata, rs2_error** error);
/**
* determine device metadata
* \param[in] frame handle returned from a callback
* \param[in] frame_metadata the metadata to check for support
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return true if device has this metadata
*/
int rs2_supports_frame_metadata(const rs2_frame* frame, rs2_frame_metadata_value frame_metadata, rs2_error** 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)
* \param[in] frameset handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return the timestamp domain of the frame (camera / microcontroller / system time)
*/
rs2_timestamp_domain rs2_get_frame_timestamp_domain(const rs2_frame* frameset, rs2_error** error);
/**
* retrieve timestamp from frame handle in milliseconds
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return the timestamp of the frame in milliseconds
*/
rs2_time_t rs2_get_frame_timestamp(const rs2_frame* frame, rs2_error** error);
/**
* retrieve frame parent sensor from frame handle
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return the parent sensor of the frame
*/
rs2_sensor* rs2_get_frame_sensor(const rs2_frame* frame, rs2_error** error);
/**
* retrieve frame number from frame handle
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return the frame number
*/
unsigned long long rs2_get_frame_number(const rs2_frame* frame, rs2_error** error);
/**
* retrieve data size from frame handle
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return the size of the frame data
*/
int rs2_get_frame_data_size(const rs2_frame* frame, rs2_error** error);
/**
* retrieve data from frame handle
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return the pointer to the start of the frame data
*/
const void* rs2_get_frame_data(const rs2_frame* frame, rs2_error** error);
/**
* retrieve frame width in pixels
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return frame width in pixels
*/
int rs2_get_frame_width(const rs2_frame* frame, rs2_error** error);
/**
* retrieve frame height in pixels
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return frame height in pixels
*/
int rs2_get_frame_height(const rs2_frame* frame, rs2_error** error);
/**
* retrieve the scaling factor to use when converting a depth frame's get_data() units to meters
* \return float - depth, in meters, per 1 unit stored in the frame data
*/
float rs2_depth_frame_get_units( const rs2_frame* frame, rs2_error** error );
/**
* retrieve frame stride in bytes (number of bytes from start of line N to start of line N+1)
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return stride in bytes
*/
int rs2_get_frame_stride_in_bytes(const rs2_frame* frame, rs2_error** error);
/**
* retrieve bits per pixels in the frame image
* (note that bits per pixel is not necessarily divided by 8, as in 12bpp)
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return bits per pixel
*/
int rs2_get_frame_bits_per_pixel(const rs2_frame* frame, rs2_error** error);
/**
* create additional reference to a frame without duplicating frame data
* \param[in] frame handle returned from a callback
* \param[out] error if non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return new frame reference, has to be released by rs2_release_frame
*/
void rs2_frame_add_ref(rs2_frame* frame, rs2_error ** error);
/**
* relases the frame handle
* \param[in] frame handle returned from a callback
*/
void rs2_release_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
* \param[in] frame handle returned from a callback
*/
void rs2_keep_frame(rs2_frame* frame);
/**
* 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
* \param[in] frame Points frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return Pointer to an array of vertices, lifetime is managed by the frame
*/
rs2_vertex* rs2_get_frame_vertices(const rs2_frame* frame, rs2_error** error);
/**
* When called on Points frame type, this method creates a ply file of the model with the given file name.
* \param[in] frame Points frame
* \param[in] fname The name for the ply file
* \param[in] texture Texture frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
*/
void rs2_export_to_ply(const rs2_frame* frame, const char* fname, rs2_frame* texture, rs2_error** 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
* \param[in] frame Points frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return Pointer to an array of texture coordinates, lifetime is managed by the frame
*/
rs2_pixel* rs2_get_frame_texture_coordinates(const rs2_frame* frame, rs2_error** error);
/**
* When called on Points frame type, this method returns the number of vertices in the frame
* \param[in] frame Points frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return Number of vertices
*/
int rs2_get_frame_points_count(const rs2_frame* frame, rs2_error** error);
/**
* Returns the stream profile that was used to start the stream of this frame
* \param[in] frame frame reference, owned by the user
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return Pointer to the stream profile object, lifetime is managed elsewhere
*/
const rs2_stream_profile* rs2_get_frame_stream_profile(const rs2_frame* frame, rs2_error** error);
/**
* Test if the given frame can be extended to the requested extension
* \param[in] frame Realsense frame
* \param[in] extension_type The extension to which the frame should be tested if it is extendable
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return non-zero value iff the frame can be extended to the given extension
*/
int rs2_is_frame_extendable_to(const rs2_frame* frame, rs2_extension extension_type, rs2_error ** error);
/**
* Allocate new video frame using a frame-source provided form a processing block
* \param[in] source Frame pool to allocate the frame from
* \param[in] new_stream New stream profile to assign to newly created frame
* \param[in] original A reference frame that can be used to fill in auxilary information like format, width, height, bpp, stride (if applicable)
* \param[in] new_bpp New value for bits per pixel for the allocated frame
* \param[in] new_width New value for width for the allocated frame
* \param[in] new_height New value for height for the allocated frame
* \param[in] new_stride New value for stride in bytes for the allocated frame
* \param[in] frame_type New value for frame type for the allocated frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return 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_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, rs2_extension frame_type, rs2_error** error);
/**
* Allocate new motion frame using a frame-source provided form a processing block
* \param[in] source Frame pool to allocate the frame from
* \param[in] new_stream New stream profile to assign to newly created frame
* \param[in] original A reference frame that can be used to fill in auxilary information like format, width, height, bpp, stride (if applicable)
* \param[in] frame_type New value for frame type for the allocated frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return 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_frame* rs2_allocate_synthetic_motion_frame(rs2_source* source, const rs2_stream_profile* new_stream, rs2_frame* original,
rs2_extension frame_type, rs2_error** error);
/**
* Allocate new points frame using a frame-source provided from a processing block
* \param[in] source Frame pool to allocate the frame from
* \param[in] new_stream New stream profile to assign to newly created frame
* \param[in] original A reference frame that can be used to fill in auxilary information like format, width, height, bpp, stride (if applicable)
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return 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_frame* rs2_allocate_points(rs2_source* source, const rs2_stream_profile* new_stream, rs2_frame* original, rs2_error** error);
/**
* Allocate new composite frame, aggregating a set of existing frames
* \param[in] source Frame pool to allocate the frame from
* \param[in] frames Array of existing frames
* \param[in] count Number of input frames
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return 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_frame* rs2_allocate_composite_frame(rs2_source* source, rs2_frame** frames, int count, rs2_error** error);
/**
* Extract frame from within a composite frame
* \param[in] composite Composite frame
* \param[in] index Index of the frame to extract within the composite frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return 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_frame* rs2_extract_frame(rs2_frame* composite, int index, rs2_error** error);
/**
* Get number of frames embedded within a composite frame
* \param[in] composite Composite input frame
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
* \return Number of embedded frames
*/
int rs2_embedded_frames_count(rs2_frame* composite, rs2_error** error);
/**
* This method will dispatch frame callback on a frame
* \param[in] source Frame pool provided by the processing block
* \param[in] frame Frame to dispatch, frame ownership is passed to this function, so you don't have to call release_frame after it
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
*/
void rs2_synthetic_frame_ready(rs2_source* source, rs2_frame* frame, rs2_error** error);
/**
* When called on Pose frame type, this method returns the transformation represented by the pose data
* \param[in] frame Pose frame
* \param[out] pose Pointer to a user allocated struct, which contains the pose info after a successful return
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
*/
void rs2_pose_frame_get_pose_data(const rs2_frame* frame, rs2_pose* pose, rs2_error** error);
/**
* Extract the target dimensions on the specific target
* \param[in] frame Left or right camera frame of specified size based on the target type
* \param[in] calib_type Calibration target type
* \param[in] target_dims_size Target dimension array size. 4 for RS2_CALIB_TARGET_RECT_GAUSSIAN_DOT_VERTICES and 8 for RS2_CALIB_TARGET_POS_GAUSSIAN_DOT_VERTICES.
* \param[out] target_dims 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
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
*/
void rs2_extract_target_dimensions(const rs2_frame* frame, rs2_calib_target_type calib_type, float * target_dims, unsigned int target_dims_size, rs2_error** error);
#ifdef __cplusplus
}
#endif
#endif