6 #include "../../include/librealsense2/h/rs_internal.h" 63 int dist(uint32_t x, uint32_t y)
const;
65 std::vector<uint8_t>
decode(
const std::vector<uint8_t>& input)
const;
67 std::vector<uint8_t>
encode(uint8_t* data,
size_t size)
const;
109 recording(std::shared_ptr<time_service> ts =
nullptr, std::shared_ptr<playback_device_watcher> watcher =
nullptr);
112 void save(
const char* filename,
const char* section,
bool append =
false)
const;
113 static std::shared_ptr<recording>
load(
const char* filename,
const char* section, std::shared_ptr<playback_device_watcher> watcher =
nullptr);
118 std::pair<int, int>
insert_list(std::vector<T> list, std::vector<T>& target)
120 std::pair<int, int> range;
122 range.first =
static_cast<int>(target.size());
123 for (
auto&& i : list) target.push_back(i);
124 range.second =
static_cast<int>(target.size());
132 std::lock_guard<std::recursive_mutex> lock(_mutex);
146 std::lock_guard<std::recursive_mutex> lock(_mutex);
152 return calls[calls.size() - 1];
158 std::vector<T> results;
159 std::lock_guard<std::recursive_mutex> lock(_mutex);
162 results.push_back(source[i]);
168 std::vector<T>
load_list(
const std::vector<T>& source,
const int range_start,
const int range_end)
170 std::vector<T> results;
171 std::lock_guard<std::recursive_mutex> lock(_mutex);
172 for (
auto i = range_start; i < range_end; i++)
174 results.push_back(source[i]);
180 std::lock_guard<std::recursive_mutex> lock(_mutex);
296 size_t size()
const {
return calls.size(); }
299 std::vector<call> calls;
300 std::vector<std::vector<uint8_t>> blobs;
301 std::vector<uvc_device_info> uvc_device_infos;
302 std::vector<usb_device_info> usb_device_infos;
304 std::vector<hid_device_info> hid_device_infos;
305 std::vector<hid_sensor> hid_sensors;
306 std::vector<hid_sensor_input> hid_sensor_inputs;
307 std::shared_ptr<playback_device_watcher> _watcher;
309 std::recursive_mutex _mutex;
310 std::shared_ptr<time_service> _ts;
312 std::map<size_t, size_t> _cursors;
313 std::map<size_t, size_t> _cycles;
315 double get_current_time();
317 void invoke_device_changed_event();
319 double _curr_time = 0;
322 class record_backend;
341 std::vector<stream_profile>
get_profiles()
const override;
342 void lock()
const override;
343 void unlock()
const override;
347 std::shared_ptr<uvc_device> source,
348 std::shared_ptr<compression_algorithm> compression,
350 : _source(source), _entity_id(id),
351 _compression(compression), _owner(owner) {}
354 std::shared_ptr<uvc_device> _source;
356 std::shared_ptr<compression_algorithm> _compression;
363 void open(
const std::vector<hid_profile>& hid_profiles)
override;
364 void close()
override;
369 const std::string& report_name,
374 : _source(source), _entity_id(id), _owner(owner) {}
377 std::shared_ptr<hid_device> _source;
385 std::vector<uint8_t>
send_receive(
const std::vector<uint8_t>& data,
int timeout_ms,
bool require_response)
override;
389 : _source(source), _entity_id(id), _owner(owner) {}
392 std::shared_ptr<usb_device> _source;
402 _source_watcher(source_watcher), _owner(owner), _entity_id(id) {}
411 void stop()
override;
415 std::shared_ptr<device_watcher> _source_watcher;
432 const char* filename,
447 return t(_rec.get(), k);
449 catch (
const std::exception& ex)
451 auto&& c = _rec->add_call(k);
459 auto&& c = _rec->add_call(k);
468 void write_to_file()
const;
470 std::shared_ptr<backend> _source;
472 std::shared_ptr<recording> _rec;
473 mutable std::atomic<int> _entity_count;
474 std::string _filename;
475 std::string _section;
476 std::shared_ptr<compression_algorithm> _compression;
489 void stop()
override;
495 std::atomic<bool> _alive;
496 std::thread _callback_thread;
499 std::recursive_mutex _mutex;
519 std::vector<stream_profile>
get_profiles()
const override;
520 void lock()
const override;
521 void unlock()
const override;
532 std::shared_ptr<recording> _rec;
534 std::atomic<bool> _alive;
535 std::thread _callback_thread;
538 std::mutex _callback_mutex;
546 std::vector<uint8_t>
send_receive(
const std::vector<uint8_t>& data,
int timeout_ms,
bool require_response)
override;
549 int id) : _rec(rec), _entity_id(id) {}
552 std::shared_ptr<recording> _rec;
559 void open(
const std::vector<hid_profile>& hid_profiles)
override;
560 void close()
override;
565 const std::string& report_name,
573 std::shared_ptr<recording> _rec;
574 std::mutex _callback_mutex;
577 std::thread _callback_thread;
578 std::atomic<bool> _alive;
596 std::shared_ptr<playback_device_watcher> _device_watcher;
597 std::shared_ptr<recording> _rec;
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls...
Definition: rs_option.h:22
rs2_recording_mode
Definition: rs_internal.h:25
Definition: concurrency.h:125
std::vector< std::shared_ptr< stream_profile_interface > > stream_profiles
Definition: streaming.h:104
double rs2_time_t
Definition: rs_types.h:179