Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
recorder.h
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2015 Intel Corporation. All Rights Reserved.
3 
4 #pragma once
5 
6 #include "../../include/librealsense2/h/rs_internal.h"
7 #include "backend.h"
8 #include "context.h"
9 #include <vector>
10 #include <mutex>
11 #include <chrono>
12 #include <atomic>
13 #include <map>
14 
15 namespace librealsense
16 {
17  namespace platform
18  {
19  enum class call_type
20  {
21  none,
30  uvc_lock,
31  uvc_unlock,
32  uvc_get_pu,
33  uvc_set_pu,
37  uvc_set_xu,
38  uvc_get_xu,
41  uvc_play,
44  uvc_close,
45  uvc_frame,
48  hid_open,
49  hid_close,
52  hid_frame,
58  };
59 
61  {
62  public:
63  int dist(uint32_t x, uint32_t y) const;
64 
65  std::vector<uint8_t> decode(const std::vector<uint8_t>& input) const;
66 
67  std::vector<uint8_t> encode(uint8_t* data, size_t size) const;
68 
69  int min_dist = 110;
70  int max_length = 32;
71  };
72 
73  struct call
74  {
76  double timestamp = 0;
77  int entity_id = 0;
78  std::string inline_string;
79 
80  int param1 = 0;
81  int param2 = 0;
82  int param3 = 0;
83  int param4 = 0;
84  int param5 = 0;
85  int param6 = 0;
86 
87  bool had_error = false;
88 
89  int param7 = 0;
90  int param8 = 0;
91  int param9 = 0;
92  int param10 = 0;
93  int param11 = 0;
94  int param12 = 0;
95 
96 
97  };
98 
99  struct lookup_key
100  {
103  };
105 
106  class recording
107  {
108  public:
109  recording(std::shared_ptr<time_service> ts = nullptr, std::shared_ptr<playback_device_watcher> watcher = nullptr);
110 
111  double get_time();
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);
114 
115  int save_blob(const void* ptr, size_t size);
116 
117  template<class T>
118  std::pair<int, int> insert_list(std::vector<T> list, std::vector<T>& target)
119  {
120  std::pair<int, int> range;
121 
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());
125 
126  return range;
127  }
128 
129  template<class T>
130  void save_list(std::vector<T> list, std::vector<T>& target, call_type type, int entity_id)
131  {
132  std::lock_guard<std::recursive_mutex> lock(_mutex);
133  call c;
134  c.type = type;
135  c.entity_id = entity_id;
136  auto range = insert_list(list, target);
137  c.param1 = range.first;
138  c.param2 = range.second;
139 
140  c.timestamp = get_current_time();
141  calls.push_back(c);
142  }
143 
145  {
146  std::lock_guard<std::recursive_mutex> lock(_mutex);
147  call c;
148  c.type = key.type;
149  c.entity_id = key.entity_id;
150  c.timestamp = get_current_time();
151  calls.push_back(c);
152  return calls[calls.size() - 1];
153  }
154 
155  template<class T>
156  std::vector<T> load_list(const std::vector<T>& source, const call& c)
157  {
158  std::vector<T> results;
159  std::lock_guard<std::recursive_mutex> lock(_mutex);
160  for (auto i = c.param1; i < c.param2; i++)
161  {
162  results.push_back(source[i]);
163  }
164  return results;
165  }
166 
167  template<class T>
168  std::vector<T> load_list(const std::vector<T>& source, const int range_start, const int range_end)
169  {
170  std::vector<T> results;
171  std::lock_guard<std::recursive_mutex> lock(_mutex);
172  for (auto i = range_start; i < range_end; i++)
173  {
174  results.push_back(source[i]);
175  }
176  return results;
177  }
179  {
180  std::lock_guard<std::recursive_mutex> lock(_mutex);
181  call c;
182  c.type = k.type;
183  c.entity_id = k.entity_id;
184 
185  auto range = insert_list(old.uvc_devices, uvc_device_infos);
186  c.param1 = range.first;
187  c.param2 = range.second;
188 
189  range = insert_list(old.usb_devices, usb_device_infos);
190  c.param3 = range.first;
191  c.param4 = range.second;
192 
193  range = insert_list(old.hid_devices, hid_device_infos);
194  c.param5 = range.first;
195  c.param6 = range.second;
196 
197  range = insert_list(curr.uvc_devices, uvc_device_infos);
198  c.param7 = range.first;
199  c.param8 = range.second;
200 
201  range = insert_list(curr.usb_devices, usb_device_infos);
202  c.param9 = range.first;
203  c.param10 = range.second;
204 
205  range = insert_list(curr.hid_devices, hid_device_infos);
206  c.param11 = range.first;
207  c.param12 = range.second;
208 
209  c.timestamp = get_current_time();
210  calls.push_back(c);
211  }
212 
213  void save_device_info_list(std::vector<uvc_device_info> list, lookup_key k)
214  {
215  save_list(list, uvc_device_infos, k.type, k.entity_id);
216  }
217 
218  void save_device_info_list(std::vector<hid_device_info> list, lookup_key k)
219  {
220  save_list(list, hid_device_infos, k.type, k.entity_id);
221  }
222 
223  void save_device_info_list(std::vector<usb_device_info> list, lookup_key k)
224  {
225  save_list(list, usb_device_infos, k.type, k.entity_id);
226  }
227 
228  void save_stream_profiles(std::vector<stream_profile> list, lookup_key key)
229  {
230  save_list(list, stream_profiles, key.type, key.entity_id);
231  }
232 
233  void save_hid_sensors(std::vector<hid_sensor> list, lookup_key key)
234  {
235  save_list(list, hid_sensors, key.type, key.entity_id);
236  }
237 
238  void save_hid_sensors2_inputs(std::vector<hid_sensor_input> list, lookup_key key)
239  {
240  save_list(list, hid_sensor_inputs, key.type, key.entity_id);
241  }
242 
243 
244  std::vector<stream_profile> load_stream_profiles(int id, call_type type)
245  {
246  auto&& c = find_call(type, id);
247  return load_list(stream_profiles, c);
248  }
249 
251  {
252  auto&& c = find_call(k.type, k.entity_id);
253 
254  old.uvc_devices = load_list(uvc_device_infos, c.param1, c.param2);
255  old.usb_devices = load_list(usb_device_infos, c.param3, c.param4);
256  old.hid_devices = load_list(hid_device_infos, c.param5, c.param6);
257 
258  curr.uvc_devices = load_list(uvc_device_infos, c.param7, c.param8);
259  curr.usb_devices = load_list(usb_device_infos, c.param9, c.param10);
260  curr.hid_devices = load_list(hid_device_infos, c.param11, c.param12);
261 
262  }
263 
264  std::vector<usb_device_info> load_usb_device_info_list()
265  {
267  return load_list(usb_device_infos, c);
268  }
269 
270  std::vector<uvc_device_info> load_uvc_device_info_list()
271  {
273  return load_list(uvc_device_infos, c);
274  }
275 
276  std::vector<hid_device_info> load_hid_device_info_list()
277  {
279  return load_list(hid_device_infos, c);
280  }
281 
282  std::vector<hid_sensor> load_hid_sensors2_list(int entity_id)
283  {
284  auto&& c = find_call(call_type::hid_get_sensors, entity_id);
285  return load_list(hid_sensors, c);
286  }
287 
288  std::vector<uint8_t> load_blob(int id) const
289  {
290  return blobs[id];
291  }
292 
293  call& find_call(call_type t, int entity_id, std::function<bool(const call& c)> history_match_validation = [](const call& c) {return true; });
294  call* cycle_calls(call_type call_type, int id);
295  call* pick_next_call(int id = 0);
296  size_t size() const { return calls.size(); }
297 
298  private:
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;
303  std::vector<stream_profile> stream_profiles;
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;
308 
309  std::recursive_mutex _mutex;
310  std::shared_ptr<time_service> _ts;
311 
312  std::map<size_t, size_t> _cursors;
313  std::map<size_t, size_t> _cycles;
314 
315  double get_current_time();
316 
317  void invoke_device_changed_event();
318 
319  double _curr_time = 0;
320  };
321 
322  class record_backend;
323 
325  {
326  public:
327  void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override;
328  void stream_on(std::function<void(const notification& n)> error_handler = [](const notification& n) {}) override;
329  void start_callbacks() override;
330  void stop_callbacks() override;
331  void close(stream_profile profile) override;
332  void set_power_state(power_state state) override;
333  power_state get_power_state() const override;
334  void init_xu(const extension_unit& xu) override;
335  bool set_xu(const extension_unit& xu, uint8_t ctrl, const uint8_t* data, int len) override;
336  bool get_xu(const extension_unit& xu, uint8_t ctrl, uint8_t* data, int len) const override;
337  control_range get_xu_range(const extension_unit& xu, uint8_t ctrl, int len) const override;
338  bool get_pu(rs2_option opt, int32_t& value) const override;
339  bool set_pu(rs2_option opt, int32_t value) override;
340  control_range get_pu_range(rs2_option opt) const override;
341  std::vector<stream_profile> get_profiles() const override;
342  void lock() const override;
343  void unlock() const override;
344  std::string get_device_location() const override;
345 
347  std::shared_ptr<uvc_device> source,
348  std::shared_ptr<compression_algorithm> compression,
349  int id, const record_backend* owner)
350  : _source(source), _entity_id(id),
351  _compression(compression), _owner(owner) {}
352 
353  private:
354  std::shared_ptr<uvc_device> _source;
355  int _entity_id;
356  std::shared_ptr<compression_algorithm> _compression;
357  const record_backend* _owner;
358  };
359 
361  {
362  public:
363  void open(const std::vector<hid_profile>& hid_profiles) override;
364  void close() override;
365  void stop_capture() override;
366  void start_capture(hid_callback callback) override;
367  std::vector<hid_sensor> get_sensors() override;
368  std::vector<uint8_t> get_custom_report_data(const std::string& custom_sensor_name,
369  const std::string& report_name,
370  custom_sensor_report_field report_field) override;
371 
372  record_hid_device(std::shared_ptr<hid_device> source,
373  int id, const record_backend* owner)
374  : _source(source), _entity_id(id), _owner(owner) {}
375 
376  private:
377  std::shared_ptr<hid_device> _source;
378  int _entity_id;
379  const record_backend* _owner;
380  };
381 
383  {
384  public:
385  std::vector<uint8_t> send_receive(const std::vector<uint8_t>& data, int timeout_ms, bool require_response) override;
386 
387  record_usb_device(std::shared_ptr<usb_device> source,
388  int id, const record_backend* owner)
389  : _source(source), _entity_id(id), _owner(owner) {}
390 
391  private:
392  std::shared_ptr<usb_device> _source;
393  int _entity_id;
394  const record_backend* _owner;
395  };
396 
397 
399  {
400  public:
401  record_device_watcher(const record_backend* owner, std::shared_ptr<device_watcher> source_watcher, int id) :
402  _source_watcher(source_watcher), _owner(owner), _entity_id(id) {}
403 
405  {
406  stop();
407  }
408 
409  void start(device_changed_callback callback) override;
410 
411  void stop() override;
412 
413  private:
414  const record_backend* _owner;
415  std::shared_ptr<device_watcher> _source_watcher;
416  int _entity_id;
417  };
418 
419  class record_backend : public backend
420  {
421  public:
422  std::shared_ptr<hid_device> create_hid_device(hid_device_info info) const override;
423  std::vector<hid_device_info> query_hid_devices() const override;
424  std::shared_ptr<uvc_device> create_uvc_device(uvc_device_info info) const override;
425  std::vector<uvc_device_info> query_uvc_devices() const override;
426  std::shared_ptr<usb_device> create_usb_device(usb_device_info info) const override;
427  std::vector<usb_device_info> query_usb_devices() const override;
428  std::shared_ptr<time_service> create_time_service() const override;
429  std::shared_ptr<device_watcher> create_device_watcher() const override;
430 
431  record_backend(std::shared_ptr<backend> source,
432  const char* filename,
433  const char* section,
434  rs2_recording_mode mode);
435  ~record_backend();
436 
437  rs2_recording_mode get_mode() const { return _mode; }
438 
439  template<class T>
440  auto try_record(T t, int entity_id, call_type type) const
441  -> decltype(t((recording*)nullptr, *((lookup_key*)nullptr)))
442  {
443  lookup_key k{ entity_id, type };
444  _entity_count = 0;
445  try
446  {
447  return t(_rec.get(), k);
448  }
449  catch (const std::exception& ex)
450  {
451  auto&& c = _rec->add_call(k);
452  c.had_error = true;
453  c.inline_string = ex.what();
454 
455  throw;
456  }
457  catch (...)
458  {
459  auto&& c = _rec->add_call(k);
460  c.had_error = true;
461  c.inline_string = "Unknown exception has occurred!";
462 
463  throw;
464  }
465  }
466 
467  private:
468  void write_to_file() const;
469 
470  std::shared_ptr<backend> _source;
471 
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;
477  rs2_recording_mode _mode;
478  };
479 
480  typedef std::vector<std::pair<stream_profile, frame_callback>> configurations;
481 
483  {
484 
485  public:
486  playback_device_watcher(int id);
488  void start(device_changed_callback callback) override;
489  void stop() override;
490 
492 
493  private:
494  int _entity_id;
495  std::atomic<bool> _alive;
496  std::thread _callback_thread;
497  dispatcher _dispatcher;
498  device_changed_callback _callback;
499  std::recursive_mutex _mutex;
500  };
501 
503  {
504  public:
505  void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override;
506  void stream_on(std::function<void(const notification& n)> error_handler = [](const notification& n) {}) override;
507  void start_callbacks() override;
508  void stop_callbacks() override;
509  void close(stream_profile profile) override;
510  void set_power_state(power_state state) override;
511  power_state get_power_state() const override;
512  void init_xu(const extension_unit& xu) override;
513  bool set_xu(const extension_unit& xu, uint8_t ctrl, const uint8_t* data, int len) override;
514  bool get_xu(const extension_unit& xu, uint8_t ctrl, uint8_t* data, int len) const override;
515  control_range get_xu_range(const extension_unit& xu, uint8_t ctrl, int len) const override;
516  bool get_pu(rs2_option opt, int32_t& value) const override;
517  bool set_pu(rs2_option opt, int32_t value) override;
518  control_range get_pu_range(rs2_option opt) const override;
519  std::vector<stream_profile> get_profiles() const override;
520  void lock() const override;
521  void unlock() const override;
522  std::string get_device_location() const override;
523 
524  explicit playback_uvc_device(std::shared_ptr<recording> rec, int id);
525 
526  void callback_thread();
528 
529  private:
530  stream_profile get_profile(call* frame) const;
531 
532  std::shared_ptr<recording> _rec;
533  int _entity_id;
534  std::atomic<bool> _alive;
535  std::thread _callback_thread;
536  configurations _callbacks;
537  configurations _commitments;
538  std::mutex _callback_mutex;
539  compression_algorithm _compression;
540  };
541 
542 
544  {
545  public:
546  std::vector<uint8_t> send_receive(const std::vector<uint8_t>& data, int timeout_ms, bool require_response) override;
547 
548  explicit playback_usb_device(std::shared_ptr<recording> rec,
549  int id) : _rec(rec), _entity_id(id) {}
550 
551  private:
552  std::shared_ptr<recording> _rec;
553  int _entity_id;
554  };
555 
557  {
558  public:
559  void open(const std::vector<hid_profile>& hid_profiles) override;
560  void close() override;
561  void stop_capture() override;
562  void start_capture(hid_callback callback) override;
563  std::vector<hid_sensor> get_sensors() override;
564  std::vector<uint8_t> get_custom_report_data(const std::string& custom_sensor_name,
565  const std::string& report_name,
566  custom_sensor_report_field report_field) override;
567  void callback_thread();
569 
570  explicit playback_hid_device(std::shared_ptr<recording> rec, int id);
571 
572  private:
573  std::shared_ptr<recording> _rec;
574  std::mutex _callback_mutex;
575  platform::hid_callback _callback;
576  int _entity_id;
577  std::thread _callback_thread;
578  std::atomic<bool> _alive;
579  };
580 
581  class playback_backend : public backend
582  {
583  public:
584  std::shared_ptr<hid_device> create_hid_device(hid_device_info info) const override;
585  std::vector<hid_device_info> query_hid_devices() const override;
586  std::shared_ptr<uvc_device> create_uvc_device(uvc_device_info info) const override;
587  std::vector<uvc_device_info> query_uvc_devices() const override;
588  std::shared_ptr<usb_device> create_usb_device(usb_device_info info) const override;
589  std::vector<usb_device_info> query_usb_devices() const override;
590  std::shared_ptr<time_service> create_time_service() const override;
591  std::shared_ptr<device_watcher> create_device_watcher() const override;
592 
593  explicit playback_backend(const char* filename, const char* section);
594  private:
595 
596  std::shared_ptr<playback_device_watcher> _device_watcher;
597  std::shared_ptr<recording> _rec;
598  };
599 
601  {
602  public:
604  _rec(rec) {}
605 
606  virtual rs2_time_t get_time() const override
607  {
608  return _rec.get_time();
609  }
610  private:
611  recording& _rec;
612  };
613  }
614 }
std::vector< hid_sensor > get_sensors() override
bool set_xu(const extension_unit &xu, uint8_t ctrl, const uint8_t *data, int len) override
recording(std::shared_ptr< time_service > ts=nullptr, std::shared_ptr< playback_device_watcher > watcher=nullptr)
int param5
Definition: recorder.h:84
record_usb_device(std::shared_ptr< usb_device > source, int id, const record_backend *owner)
Definition: recorder.h:387
int param9
Definition: recorder.h:91
std::vector< hid_sensor > get_sensors() override
std::string get_device_location() const override
call_type type
Definition: recorder.h:102
void init_xu(const extension_unit &xu) override
std::shared_ptr< usb_device > create_usb_device(usb_device_info info) const override
bool set_xu(const extension_unit &xu, uint8_t ctrl, const uint8_t *data, int len) override
void stream_on(std::function< void(const notification &n)> error_handler=[](const notification &n) {}) override
Definition: backend.h:351
Definition: backend.h:621
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls...
Definition: rs_option.h:22
playback_usb_device(std::shared_ptr< recording > rec, int id)
Definition: recorder.h:548
std::vector< uint8_t > encode(uint8_t *data, size_t size) const
std::vector< stream_profile > get_profiles() const override
Definition: backend.h:368
int param11
Definition: recorder.h:93
std::shared_ptr< hid_device > create_hid_device(hid_device_info info) const override
void init_xu(const extension_unit &xu) override
rs2_recording_mode
Definition: rs_internal.h:25
void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override
Definition: recorder.h:419
int entity_id
Definition: recorder.h:101
call * cycle_calls(call_type call_type, int id)
Definition: concurrency.h:125
std::vector< uint8_t > send_receive(const std::vector< uint8_t > &data, int timeout_ms, bool require_response) override
std::vector< uint8_t > load_blob(int id) const
Definition: recorder.h:288
void save_device_info_list(std::vector< hid_device_info > list, lookup_key k)
Definition: recorder.h:218
int entity_id
Definition: recorder.h:77
std::shared_ptr< time_service > create_time_service() const override
void start(device_changed_callback callback) override
int param2
Definition: recorder.h:81
static std::shared_ptr< recording > load(const char *filename, const char *section, std::shared_ptr< playback_device_watcher > watcher=nullptr)
bool had_error
Definition: recorder.h:87
std::shared_ptr< uvc_device > create_uvc_device(uvc_device_info info) const override
void close(stream_profile profile) override
bool get_xu(const extension_unit &xu, uint8_t ctrl, uint8_t *data, int len) const override
int param6
Definition: recorder.h:85
int save_blob(const void *ptr, size_t size)
std::vector< stream_profile > get_profiles() const override
std::vector< hid_device_info > load_hid_device_info_list()
Definition: recorder.h:276
void open(const std::vector< hid_profile > &hid_profiles) override
rs2_recording_mode get_mode() const
Definition: recorder.h:437
std::vector< usb_device_info > query_usb_devices() const override
void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override
void set_power_state(power_state state) override
double timestamp
Definition: recorder.h:76
size_t size() const
Definition: recorder.h:296
Definition: archive.h:63
Definition: algo.h:16
Definition: recorder.h:99
std::vector< T > load_list(const std::vector< T > &source, const call &c)
Definition: recorder.h:156
Definition: recorder.h:73
call & add_call(lookup_key key)
Definition: recorder.h:144
std::vector< hid_device_info > hid_devices
Definition: backend.h:570
void raise_callback(backend_device_group old, backend_device_group curr)
record_backend(std::shared_ptr< backend > source, const char *filename, const char *section, rs2_recording_mode mode)
std::string inline_string
Definition: recorder.h:78
int param10
Definition: recorder.h:92
int min_dist
Definition: recorder.h:69
bool get_xu(const extension_unit &xu, uint8_t ctrl, uint8_t *data, int len) const override
call_type type
Definition: recorder.h:75
void close(stream_profile profile) override
std::vector< uint8_t > send_receive(const std::vector< uint8_t > &data, int timeout_ms, bool require_response) override
std::vector< hid_sensor > load_hid_sensors2_list(int entity_id)
Definition: recorder.h:282
std::vector< uvc_device_info > query_uvc_devices() const override
int param3
Definition: recorder.h:82
std::function< void(backend_device_group old, backend_device_group curr)> device_changed_callback
Definition: backend.h:619
virtual rs2_time_t get_time() const override
Definition: recorder.h:606
void start_capture(hid_callback callback) override
void start_capture(hid_callback callback) override
control_range get_xu_range(const extension_unit &xu, uint8_t ctrl, int len) const override
Definition: backend.h:92
power_state
Definition: backend.h:123
std::vector< stream_profile > load_stream_profiles(int id, call_type type)
Definition: recorder.h:244
std::shared_ptr< time_service > create_time_service() const override
void load_device_changed_data(backend_device_group &old, backend_device_group &curr, lookup_key k)
Definition: recorder.h:250
int dist(uint32_t x, uint32_t y) const
std::shared_ptr< device_watcher > create_device_watcher() const override
std::shared_ptr< hid_device > create_hid_device(hid_device_info info) const override
auto try_record(T t, int entity_id, call_type type) const -> decltype(t((recording *) nullptr, *((lookup_key *) nullptr)))
Definition: recorder.h:440
int param4
Definition: recorder.h:83
void save_list(std::vector< T > list, std::vector< T > &target, call_type type, int entity_id)
Definition: recorder.h:130
void start(device_changed_callback callback) override
call_type
Definition: recorder.h:19
int param12
Definition: recorder.h:94
void set_power_state(power_state state) override
playback_uvc_device(std::shared_ptr< recording > rec, int id)
record_hid_device(std::shared_ptr< hid_device > source, int id, const record_backend *owner)
Definition: recorder.h:372
std::vector< std::pair< stream_profile, frame_callback > > configurations
Definition: recorder.h:480
record_device_watcher(const record_backend *owner, std::shared_ptr< device_watcher > source_watcher, int id)
Definition: recorder.h:401
std::vector< hid_device_info > query_hid_devices() const override
int param7
Definition: recorder.h:89
std::vector< uvc_device_info > query_uvc_devices() const override
void stream_on(std::function< void(const notification &n)> error_handler=[](const notification &n) {}) override
std::string get_device_location() const override
playback_hid_device(std::shared_ptr< recording > rec, int id)
std::vector< uint8_t > decode(const std::vector< uint8_t > &input) const
custom_sensor_report_field
Definition: backend.h:344
std::function< void(stream_profile, frame_object, std::function< void()>)> frame_callback
Definition: backend.h:177
void save_hid_sensors2_inputs(std::vector< hid_sensor_input > list, lookup_key key)
Definition: recorder.h:238
std::vector< usb_device_info > query_usb_devices() const override
std::vector< usb_device_info > load_usb_device_info_list()
Definition: recorder.h:264
std::pair< int, int > insert_list(std::vector< T > list, std::vector< T > &target)
Definition: recorder.h:118
power_state get_power_state() const override
Definition: recorder.h:106
Definition: backend.h:543
record_uvc_device(std::shared_ptr< uvc_device > source, std::shared_ptr< compression_algorithm > compression, int id, const record_backend *owner)
Definition: recorder.h:346
control_range get_xu_range(const extension_unit &xu, uint8_t ctrl, int len) const override
recording_time_service(recording &rec)
Definition: recorder.h:603
Definition: backend.h:348
std::vector< usb_device_info > usb_devices
Definition: backend.h:569
std::vector< uint8_t > get_custom_report_data(const std::string &custom_sensor_name, const std::string &report_name, custom_sensor_report_field report_field) override
void save_device_changed_data(backend_device_group old, backend_device_group curr, lookup_key k)
Definition: recorder.h:178
bool get_pu(rs2_option opt, int32_t &value) const override
std::vector< T > load_list(const std::vector< T > &source, const int range_start, const int range_end)
Definition: recorder.h:168
std::vector< std::shared_ptr< stream_profile_interface > > stream_profiles
Definition: streaming.h:104
~record_device_watcher()
Definition: recorder.h:404
Definition: backend.h:387
control_range get_pu_range(rs2_option opt) const override
power_state get_power_state() const override
Definition: types.h:846
control_range get_pu_range(rs2_option opt) const override
void save_device_info_list(std::vector< uvc_device_info > list, lookup_key k)
Definition: recorder.h:213
std::vector< hid_device_info > query_hid_devices() const override
std::shared_ptr< uvc_device > create_uvc_device(uvc_device_info info) const override
std::vector< uint8_t > get_custom_report_data(const std::string &custom_sensor_name, const std::string &report_name, custom_sensor_report_field report_field) override
std::function< void(const sensor_data &)> hid_callback
Definition: backend.h:366
std::vector< uvc_device_info > uvc_devices
Definition: backend.h:568
std::shared_ptr< usb_device > create_usb_device(usb_device_info info) const override
bool set_pu(rs2_option opt, int32_t value) override
double rs2_time_t
Definition: rs_types.h:179
void save_stream_profiles(std::vector< stream_profile > list, lookup_key key)
Definition: recorder.h:228
bool get_pu(rs2_option opt, int32_t &value) const override
int param1
Definition: recorder.h:80
int param8
Definition: recorder.h:90
std::shared_ptr< device_watcher > create_device_watcher() const override
void save_hid_sensors(std::vector< hid_sensor > list, lookup_key key)
Definition: recorder.h:233
int max_length
Definition: recorder.h:70
playback_backend(const char *filename, const char *section)
void save(const char *filename, const char *section, bool append=false) const
call & find_call(call_type t, int entity_id, std::function< bool(const call &c)> history_match_validation=[](const call &c) {return true;})
bool set_pu(rs2_option opt, int32_t value) override
std::vector< uvc_device_info > load_uvc_device_info_list()
Definition: recorder.h:270
void save_device_info_list(std::vector< usb_device_info > list, lookup_key k)
Definition: recorder.h:223
void open(const std::vector< hid_profile > &hid_profiles) override