193 lines
9.3 KiB
C
193 lines
9.3 KiB
C
/* License: Apache 2.0. See LICENSE file in root directory.
|
|
Copyright(c) 2017 Intel Corporation. All Rights Reserved. */
|
|
|
|
/** \file rs_record_playback.h
|
|
* \brief
|
|
* Exposes record and playback functionality for C compilers
|
|
*/
|
|
|
|
|
|
#ifndef LIBREALSENSE_RS2_RECORD_PLAYBACK_H
|
|
#define LIBREALSENSE_RS2_RECORD_PLAYBACK_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "rs_types.h"
|
|
|
|
typedef enum rs2_playback_status
|
|
{
|
|
RS2_PLAYBACK_STATUS_UNKNOWN, /**< Unknown state */
|
|
RS2_PLAYBACK_STATUS_PLAYING, /**< One or more sensors were started, playback is reading and raising data */
|
|
RS2_PLAYBACK_STATUS_PAUSED, /**< One or more sensors were started, but playback paused reading and paused raising data*/
|
|
RS2_PLAYBACK_STATUS_STOPPED, /**< All sensors were stopped, or playback has ended (all data was read). This is the initial playback status*/
|
|
RS2_PLAYBACK_STATUS_COUNT
|
|
} rs2_playback_status;
|
|
|
|
const char* rs2_playback_status_to_string(rs2_playback_status status);
|
|
|
|
typedef void (*rs2_playback_status_changed_callback_ptr)(rs2_playback_status);
|
|
|
|
/**
|
|
* Creates a recording device to record the given device and save it to the given file
|
|
* \param[in] device The device to record
|
|
* \param[in] file The desired path to which the recorder should save the data
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return A pointer to a device that records its data to file, or null in case of failure
|
|
*/
|
|
rs2_device* rs2_create_record_device(const rs2_device* device, const char* file, rs2_error** error);
|
|
|
|
/**
|
|
* Creates a recording device to record the given device and save it to the given file
|
|
* \param[in] device The device to record
|
|
* \param[in] file The desired path to which the recorder should save the data
|
|
* \param[in] compression_enabled Indicates if compression is enabled, 0 means false, otherwise true
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return A pointer to a device that records its data to file, or null in case of failure
|
|
*/
|
|
rs2_device* rs2_create_record_device_ex(const rs2_device* device, const char* file, int compression_enabled, rs2_error** 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
|
|
* \param[in] device A recording device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_record_device_pause(const rs2_device* device, rs2_error** 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
|
|
* \param[in] device A recording device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_record_device_resume(const rs2_device* device, rs2_error** error);
|
|
|
|
/**
|
|
* Gets the name of the file to which the recorder is writing
|
|
* \param[in] device A recording device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return The name of the file to which the recorder is writing
|
|
*/
|
|
const char* rs2_record_device_filename(const rs2_device* device, rs2_error** error);
|
|
|
|
/**
|
|
* Creates a playback device to play the content of the given file
|
|
* \param[in] file Path to the file to play
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return A pointer to a device that plays data from the file, or null in case of failure
|
|
*/
|
|
rs2_device* rs2_create_playback_device(const char* file, rs2_error** error);
|
|
|
|
/**
|
|
* Gets the path of the file used by the playback device
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return Path to the file used by the playback device
|
|
*/
|
|
const char* rs2_playback_device_get_file_path(const rs2_device* device, rs2_error** error);
|
|
|
|
/**
|
|
* Gets the total duration of the file in units of nanoseconds
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return Total duration of the file in units of nanoseconds
|
|
*/
|
|
unsigned long long int rs2_playback_get_duration(const rs2_device* device, rs2_error** error);
|
|
|
|
/**
|
|
* Set the playback to a specified time point of the played data
|
|
* \param[in] device A playback device.
|
|
* \param[in] time The time point to which playback should seek, expressed in units of nanoseconds (zero value = start)
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_playback_seek(const rs2_device* device, long long int time, rs2_error** error);
|
|
|
|
/**
|
|
* Gets the current position of the playback in the file in terms of time. Units are expressed in nanoseconds
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return Current position of the playback in the file in terms of time. Units are expressed in nanoseconds
|
|
*/
|
|
unsigned long long int rs2_playback_get_position(const rs2_device* device, rs2_error** 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
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_playback_device_resume(const rs2_device* device, rs2_error** error);
|
|
|
|
/**
|
|
* Un-pauses the playback
|
|
* Calling resume() while playback status is "Playing" or "Stopped" does nothing
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_playback_device_pause(const rs2_device* device, rs2_error** 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).
|
|
* \param[in] device A playback device
|
|
* \param[in] real_time Indicates if real time is requested, 0 means false, otherwise true
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_playback_device_set_real_time(const rs2_device* device, int real_time, rs2_error** error);
|
|
|
|
/**
|
|
* Indicates if playback is in real time mode or non real time
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return True iff playback is in real time mode. 0 means false, otherwise true
|
|
*/
|
|
int rs2_playback_device_is_real_time(const rs2_device* device, rs2_error** 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
|
|
* \param[in] device A playback device
|
|
* \param[in] callback A callback handler that will be invoked when the playback status changes
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_playback_device_set_status_changed_callback(const rs2_device* device, rs2_playback_status_changed_callback* callback, rs2_error** error);
|
|
|
|
/**
|
|
* Returns the current state of the playback device
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
* \return Current state of the playback
|
|
*/
|
|
rs2_playback_status rs2_playback_device_get_current_status(const rs2_device* device, rs2_error** error);
|
|
|
|
/**
|
|
* Set the playing speed
|
|
*
|
|
* \param[in] device A playback device
|
|
* \param[in] speed Indicates a multiplication of the speed to play (e.g: 1 = normal, 0.5 twice as slow)
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_playback_device_set_playback_speed(const rs2_device* device, float speed, rs2_error** error);
|
|
|
|
/**
|
|
* Stops the playback
|
|
* Calling stop() will stop all streaming playbakc sensors and will reset the playback (returning to beginning of file)
|
|
* \param[in] device A playback device
|
|
* \param[out] error If non-null, receives any error that occurs during this call, otherwise, errors are ignored
|
|
*/
|
|
void rs2_playback_device_stop(const rs2_device* device, rs2_error** error);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif
|