You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
378 lines
23 KiB
378 lines
23 KiB
/* 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
|