src/ivcam/sr300.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 <vector>
7 #include <map>
8 #include <mutex>
9 #include <string>
10 
11 #include "device.h"
12 #include "context.h"
13 #include "backend.h"
14 #include "ivcam-private.h"
15 #include "hw-monitor.h"
16 #include "metadata-parser.h"
17 #include "image.h"
18 #include <cstddef>
19 #include "environment.h"
20 #include "core/debug.h"
21 #include "stream.h"
24 #include "firmware_logger_device.h"
25 
26 namespace librealsense
27 {
28  const uint16_t SR306_PID = 0x0aa3;
29  const uint16_t SR300_PID = 0x0aa5;
30  const uint16_t SR300v2_PID = 0x0B48;
31  const uint16_t SR300_RECOVERY = 0x0ab3;
32 
33  const double TIMESTAMP_10NSEC_TO_MSEC = 0.00001;
34 
35  class sr300_camera;
36  class sr3xx_camera;
37 
39  {
40  bool started;
42 
44  mutable uint64_t counter;
45  mutable std::recursive_mutex _mtx;
46  public:
47  sr300_timestamp_reader() : started(false), total(0), last_timestamp(0), counter(0) {}
48 
49  void reset() override
50  {
51  std::lock_guard<std::recursive_mutex> lock(_mtx);
52  started = false;
53  total = 0;
54  last_timestamp = 0;
55  counter = 0;
56  }
57 
58  double get_frame_timestamp(const std::shared_ptr<frame_interface>& frame) override
59  {
60  std::lock_guard<std::recursive_mutex> lock(_mtx);
61 
62  // Timestamps are encoded within the first 32 bits of the image and provided in 10nsec units
63  auto f = std::dynamic_pointer_cast<librealsense::frame>(frame);
64  if (!f)
65  {
66  LOG_ERROR("Frame is not valid. Failed to downcast to librealsense::frame.");
67  return 0;
68  }
69  uint32_t rolling_timestamp = *reinterpret_cast<const uint32_t *>(f->get_frame_data());
70  if (!started)
71  {
72  total = last_timestamp = rolling_timestamp;
73  last_timestamp = rolling_timestamp;
74  started = true;
75  }
76 
77  const int delta = rolling_timestamp - last_timestamp; // NOTE: Relies on undefined behavior: signed int wraparound
78  last_timestamp = rolling_timestamp;
79  total += delta;
80 
81  return total * 0.00001; // to msec
82  }
83 
84  unsigned long long get_frame_counter(const std::shared_ptr<frame_interface>& frame) const override
85  {
86  std::lock_guard<std::recursive_mutex> lock(_mtx);
87  return ++counter;
88  }
89 
90  rs2_timestamp_domain get_frame_timestamp_domain(const std::shared_ptr<frame_interface>& frame) const override
91  {
92  auto f = std::dynamic_pointer_cast<librealsense::frame>(frame);
93  if (!f)
94  {
95  LOG_ERROR("Frame is not valid. Failed to downcast to librealsense::frame.");
97  }
98  if (f->additional_data.metadata_size >= platform::uvc_header_size)
100  else
102  }
103  };
104 
106  {
107  std::unique_ptr<sr300_timestamp_reader> _backup_timestamp_reader;
109  mutable std::recursive_mutex _mtx;
111 
112  protected:
113 
114  bool has_metadata_ts(const std::shared_ptr<frame_interface>& frame) const
115  {
116  auto f = std::dynamic_pointer_cast<librealsense::frame>(frame);
117  if (!f)
118  {
119  LOG_ERROR("Frame is not valid. Failed to downcast to librealsense::frame.");
120  return false;
121  }
122  // Metadata support for a specific stream is immutable
123  const bool has_md_ts = [&] { std::lock_guard<std::recursive_mutex> lock(_mtx);
124  return ((f->additional_data.metadata_blob.data() != nullptr) && (f->additional_data.metadata_size >= platform::uvc_header_size) && ((byte*)f->additional_data.metadata_blob.data())[0] >= platform::uvc_header_size);
125  }();
126 
127  return has_md_ts;
128  }
129 
130  bool has_metadata_fc(const std::shared_ptr<frame_interface>& frame) const
131  {
132  auto f = std::dynamic_pointer_cast<librealsense::frame>(frame);
133  if (!f)
134  {
135  LOG_ERROR("Frame is not valid. Failed to downcast to librealsense::frame.");
136  return false;
137  }
138  // Metadata support for a specific stream is immutable
139  const bool has_md_frame_counter = [&] { std::lock_guard<std::recursive_mutex> lock(_mtx);
140  return ((f->additional_data.metadata_blob.data() != nullptr) && (f->additional_data.metadata_size > platform::uvc_header_size) && ((byte*)f->additional_data.metadata_blob.data())[0] > platform::uvc_header_size);
141  }();
142 
143  return has_md_frame_counter;
144  }
145 
146  public:
147  sr300_timestamp_reader_from_metadata() :_backup_timestamp_reader(nullptr), one_time_note(false)
148  {
149  _backup_timestamp_reader = std::unique_ptr<sr300_timestamp_reader>(new sr300_timestamp_reader());
150  reset();
151  }
152 
153  rs2_time_t get_frame_timestamp(const std::shared_ptr<frame_interface>& frame) override;
154 
155  unsigned long long get_frame_counter(const std::shared_ptr<frame_interface>& frame) const override;
156 
157  void reset() override;
158 
159  rs2_timestamp_domain get_frame_timestamp_domain(const std::shared_ptr<frame_interface>& frame) const override;
160  };
161 
162  class sr300_info : public device_info
163  {
164  public:
165  std::shared_ptr<device_interface> create(std::shared_ptr<context> ctx,
166  bool register_device_notifications) const override;
167 
168  sr300_info(std::shared_ptr<context> ctx,
172  : device_info(ctx),
173  _color(std::move(color)), _depth(std::move(depth)), _hwm(std::move(hwm)) {}
174 
175  static std::vector<std::shared_ptr<device_info>> pick_sr300_devices(
176  std::shared_ptr<context> ctx,
177  std::vector<platform::uvc_device_info>& platform,
178  std::vector<platform::usb_device_info>& usb);
179 
181  {
182  if (_color.pid)
183  return platform::backend_device_group({ _color, _depth }, { _hwm });
184  return platform::backend_device_group({ _depth }, { _hwm });
185  }
186 
187  private:
191  };
192 
193  class sr3xx_camera : public virtual device,
194  public debug_interface,
195  public updatable,
197  {
198  public:
199  std::vector<tagged_profile> get_profiles_tags() const override
200  {
201  std::vector<tagged_profile> tags;
203  tags.push_back({ RS2_STREAM_INFRARED, -1, 640, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
204  return tags;
205  };
206 
207  class preset_option : public option_base
208  {
209  public:
210  void set(float value) override
211  {
212  if (!is_valid(value))
213  throw invalid_value_exception(to_string() << "set(preset_option) failed! Given value " << value << " is out of range.");
214 
215  _owner.rs2_apply_ivcam_preset(static_cast<int>(value));
216  last_value = value;
217  _recording_function(*this);
218  }
219 
220  float query() const override { return last_value; }
221 
222  bool is_enabled() const override { return true; }
223 
224  const char* get_description() const override
225  {
226  return "Recommended sets of options optimized for different visual use-cases";
227  }
228 
229  const char* get_value_description(float val) const override
230  {
232  static_cast<rs2_sr300_visual_preset>(
233  static_cast<int>(val)));
234  }
235 
236  explicit preset_option(sr3xx_camera& owner, const option_range& opt_range)
237  : option_base(opt_range),
238  _owner(owner)
239  {}
240 
241  private:
244  };
245 
247  {
248  public:
250  std::shared_ptr<uvc_sensor> uvc_sensor,
251  const std::map<uint32_t, rs2_format>& sr300_depth_fourcc_to_rs2_format,
252  const std::map<uint32_t, rs2_stream>& sr300_depth_fourcc_to_rs2_stream)
253  : synthetic_sensor("Coded-Light Depth Sensor", uvc_sensor, owner, sr300_depth_fourcc_to_rs2_format, sr300_depth_fourcc_to_rs2_stream), _owner(owner)
254  {}
255 
257  {
258  return make_depth_intrinsics(*_owner->_camer_calib_params, { int(profile.width), int(profile.height) });
259  }
260 
262  {
264 
265  auto&& results = synthetic_sensor::init_stream_profiles();
266 
267  for (auto&& p : results)
268  {
269  // Register stream types
270  if (p->get_stream_type() == RS2_STREAM_DEPTH)
271  {
272  assign_stream(_owner->_depth_stream, p);
273  }
274  else if (p->get_stream_type() == RS2_STREAM_INFRARED)
275  {
276  assign_stream(_owner->_ir_stream, p);
277  }
278 
279  // Register intrinsics
280  auto&& video = dynamic_cast<video_stream_profile_interface*>(p.get());
281 
282  const auto&& profile = to_profile(p.get());
283  std::weak_ptr<sr300_depth_sensor> wp =
284  std::dynamic_pointer_cast<sr300_depth_sensor>(this->shared_from_this());
285 
286  video->set_intrinsics([profile, wp]()
287  {
288  auto sp = wp.lock();
289  if (sp)
290  return sp->get_intrinsics(profile);
291  else
292  return rs2_intrinsics{};
293  });
294  }
295 
296  return results;
297  }
298 
299  float get_depth_scale() const override { return get_option(RS2_OPTION_DEPTH_UNITS).query(); }
300 
301  void create_snapshot(std::shared_ptr<depth_sensor>& snapshot) const override
302  {
303  snapshot = std::make_shared<depth_sensor_snapshot>(get_depth_scale());
304  }
305  void enable_recording(std::function<void(const depth_sensor&)> recording_function) override
306  {
307  get_option(RS2_OPTION_DEPTH_UNITS).enable_recording([this, recording_function](const option& o) {
308  recording_function(*this);
309  });
310  }
311 
312  static processing_blocks get_sr300_depth_recommended_proccesing_blocks();
313 
315  {
316  return get_sr300_depth_recommended_proccesing_blocks();
317  };
318 
319  private:
320  const sr3xx_camera* _owner;
321  };
322 
323  std::shared_ptr<synthetic_sensor> create_depth_device(std::shared_ptr<context> ctx,
325 
326  std::vector<uint8_t> send_receive_raw_data(const std::vector<uint8_t>& input) override
327  {
328  return _hw_monitor->send(input);
329  }
330 
331  void hardware_reset() override
332  {
333  force_hardware_reset();
334  }
335 
336  synthetic_sensor& get_depth_sensor() { return dynamic_cast<synthetic_sensor&>(device::get_sensor(_depth_device_idx)); }
337 
339  {
340  synthetic_sensor& depth_sensor = get_depth_sensor();
341  return dynamic_cast<uvc_sensor&>(*depth_sensor.get_raw_sensor());
342  }
343 
344  sr3xx_camera(std::shared_ptr<context> ctx,
346  const platform::usb_device_info& hwm_device,
348  bool register_device_notifications);
349 
351  {
352  const auto DEPTH_CONTROLS = 5;
353  const rs2_option arr_options[DEPTH_CONTROLS] = {
359  };
360 
361  // This extra functionality is disable for now:
362  //const ivcam::cam_auto_range_request ar_requests[RS2_IVCAM_VISUAL_PRESET_COUNT] =
363  //{
364  // { 1, 1, 180, 303, 180, 2, 16, -1, 1000, 450 }, /* ShortRange */
365  // { 1, 0, 303, 605, 303, -1, -1, -1, 1250, 975 }, /* LongRange */
366  // { 0, 0, -1, -1, -1, -1, -1, -1, -1, -1 }, /* BackgroundSegmentation */
367  // { 1, 1, 100, 179, 100, 2, 16, -1, 1000, 450 }, /* GestureRecognition */
368  // { 0, 1, -1, -1, -1, 2, 16, 16, 1000, 450 }, /* ObjectScanning */
369  // { 0, 0, -1, -1, -1, -1, -1, -1, -1, -1 }, /* FaceAnalytics */
370  // { 2, 0, 40, 1600, 800, -1, -1, -1, -1, -1 }, /* FaceLogin */
371  // { 1, 1, 100, 179, 179, 2, 16, -1, 1000, 450 }, /* GRCursor */
372  // { 0, 0, -1, -1, -1, -1, -1, -1, -1, -1 }, /* Default */
373  // { 1, 1, 180, 605, 303, 2, 16, -1, 1250, 650 }, /* MidRange */
374  // { 2, 0, 40, 1600, 800, -1, -1, -1, -1, -1 }, /* IROnly */
375  //};
376 
377  const float arr_values[RS2_SR300_VISUAL_PRESET_COUNT][DEPTH_CONTROLS] = {
378  { 1, 1, 5, 1, -1 }, /* ShortRange */
379  { 1, 1, 7, 0, -1 }, /* LongRange */
380  { 16, 1, 6, 2, 22 }, /* BackgroundSegmentation */
381  { 1, 1, 6, 3, -1 }, /* GestureRecognition */
382  { 1, 1, 3, 1, 9 }, /* ObjectScanning */
383  { 16, 1, 5, 1, 22 }, /* FaceAnalytics */
384  { 1, -1, -1, -1, -1 }, /* FaceLogin */
385  { 1, 1, 6, 1, -1 }, /* GRCursor */
386  { 16, 1, 5, 3, 9 }, /* Default */
387  { 1, 1, 5, 1, -1 }, /* MidRange */
388  { 1, -1, -1, -1, -1 } /* IROnly */
389  };
390 
391  // The Default preset is handled differently from all the rest,
392  // When the user applies the Default preset the camera is expected to return to
393  // Default values of depth options:
394  if (preset == RS2_SR300_VISUAL_PRESET_DEFAULT)
395  {
396  for (auto opt : arr_options)
397  {
398  auto&& o = get_depth_sensor().get_option(opt);
399  o.set(o.get_range().def);
400  }
401  }
402  else
403  {
404  for (auto i = 0; i < DEPTH_CONTROLS; i++)
405  {
406  if (arr_values[preset][i] >= 0)
407  {
408  auto&& o = get_depth_sensor().get_option(arr_options[i]);
409  o.set(arr_values[preset][i]);
410  }
411  }
412  //if (arr_values[preset][0] == 1)
413  //set_auto_range(ar_requests[preset]);
414  }
415  }
416  void create_snapshot(std::shared_ptr<debug_interface>& snapshot) const override;
417  void enable_recording(std::function<void(const debug_interface&)> record_action) override;
418 
419  void enter_update_state() const override;
420  std::vector<uint8_t> backup_flash(update_progress_callback_ptr callback) override;
421  void update_flash(const std::vector<uint8_t>& image, update_progress_callback_ptr callback, int update_mode) override;
422 
423  virtual std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
424 
425  private:
427  bool _is_locked = true;
428 
429  template<class T>
431  {
432  auto raw_sensor = depth.get_raw_sensor();
433  auto raw_uvc_sensor = As<uvc_sensor, sensor_base>(raw_sensor);
434  assert(raw_uvc_sensor);
435  depth.register_option(opt,
436  std::make_shared<uvc_xu_option<T>>(
437  *raw_uvc_sensor,
439  id, std::move(desc)));
440  }
441 
443  {
444  auto arr = std::make_shared<ivcam::cam_auto_range_request>();
445  auto arr_reader_writer = make_struct_interface<ivcam::cam_auto_range_request>(
446  [arr]() { return *arr; },
447  [arr, this](ivcam::cam_auto_range_request r) {
448  set_auto_range(r);
449  *arr = r;
450  });
451  //register_option(RS2_OPTION_SR300_AUTO_RANGE_ENABLE_MOTION_VERSUS_RANGE, RS2_SUBDEVICE_DEPTH,
452  // make_field_option(arr_reader_writer, &ivcam::cam_auto_range_request::enableMvR, { 0, 2, 1, 1 }));
453  //register_option(RS2_OPTION_SR300_AUTO_RANGE_ENABLE_LASER, RS2_SUBDEVICE_DEPTH,
454  // make_field_option(arr_reader_writer, &ivcam::cam_auto_range_request::enableLaser, { 0, 1, 1, 1 }));
455  // etc..
456  }
457 
458  static rs2_intrinsics make_depth_intrinsics(const ivcam::camera_calib_params& c, const int2& dims);
459  float read_mems_temp() const;
460  int read_ir_temp() const;
461 
462  void force_hardware_reset() const;
463  void enable_timestamp(bool colorEnable, bool depthEnable) const;
464  void set_auto_range(const ivcam::cam_auto_range_request& c) const;
465 
466  ivcam::camera_calib_params get_calibration() const;
467 
468  protected:
469 
470  //TODO - add these to device class as pure virtual methods
471  command get_firmware_logs_command() const;
472  command get_flash_logs_command() const;
473 
474  std::shared_ptr<stream_interface> _depth_stream;
475  std::shared_ptr<stream_interface> _ir_stream;
476  std::shared_ptr<hw_monitor> _hw_monitor;
477  std::shared_ptr<lazy<rs2_extrinsics>> _depth_to_color_extrinsics;
479  };
480 
481  class sr300_camera: public sr3xx_camera {
482  public:
483  std::vector<tagged_profile> get_profiles_tags() const override
484  {
485  std::vector<tagged_profile> tags = sr3xx_camera::get_profiles_tags();
487  return tags;
488  };
489 
490  std::shared_ptr<synthetic_sensor> create_color_device(std::shared_ptr<context> ctx,
492 
494  {
495  public:
497  std::shared_ptr<uvc_sensor> uvc_sensor,
498  const std::map<uint32_t, rs2_format>& sr300_color_fourcc_to_rs2_format,
499  const std::map<uint32_t, rs2_stream>& sr300_color_fourcc_to_rs2_stream)
500  : synthetic_sensor("RGB Camera", uvc_sensor, owner, sr300_color_fourcc_to_rs2_format, sr300_color_fourcc_to_rs2_stream), _owner(owner)
501  {}
502 
504  {
505  return make_color_intrinsics(*_owner->_camer_calib_params, { int(profile.width), int(profile.height) });
506  }
507 
509  {
511 
512  auto&& results = synthetic_sensor::init_stream_profiles();
513 
514  for (auto&& p : results)
515  {
516  // Register stream types
517  if (p->get_stream_type() == RS2_STREAM_COLOR)
518  {
519  assign_stream(_owner->_color_stream, p);
520  }
521 
522  // Register intrinsics
523  auto&& video = dynamic_cast<video_stream_profile_interface*>(p.get());
524 
525  const auto&& profile = to_profile(p.get());
526  std::weak_ptr<sr300_color_sensor> wp =
527  std::dynamic_pointer_cast<sr300_color_sensor>(this->shared_from_this());
528  video->set_intrinsics([profile, wp]()
529  {
530  auto sp = wp.lock();
531  if (sp)
532  return sp->get_intrinsics(profile);
533  else
534  return rs2_intrinsics{};
535  });
536  }
537 
538  return results;
539  }
540 
542  {
544  }
545 
546  private:
548  };
549 
550  sr300_camera(std::shared_ptr<context> ctx,
551  const platform::uvc_device_info& color,
553  const platform::usb_device_info& hwm_device,
555  bool register_device_notifications);
556 
557  virtual std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
558 
559  private:
560  static rs2_intrinsics make_color_intrinsics(const ivcam::camera_calib_params& c, const int2& dims);
561  std::shared_ptr<stream_interface> _color_stream;
562 
563  protected:
565  };
566 
567  class sr305_camera final : public sr300_camera {
568  public:
569  sr305_camera(std::shared_ptr<context> ctx,
572  const platform::usb_device_info& hwm_device,
574  bool register_device_notifications);
575  };
576 
577  class sr306_camera final : public sr3xx_camera {
578  public:
579  sr306_camera(std::shared_ptr<context> ctx,
581  const platform::usb_device_info& hwm_device,
583  bool register_device_notifications);
584 
585  std::vector<tagged_profile> get_profiles_tags() const override
586  {
587  std::vector<tagged_profile> tags;
590  return tags;
591  };
592  };
593 }
void enable_recording(std::function< void(const depth_sensor &)> recording_function) override
static const textual_icon lock
Definition: model-views.h:218
virtual void register_option(rs2_option id, std::shared_ptr< option > option)
Definition: sensor.cpp:1070
preset_option(sr3xx_camera &owner, const option_range &opt_range)
sr300_color_sensor(sr300_camera *owner, std::shared_ptr< uvc_sensor > uvc_sensor, const std::map< uint32_t, rs2_format > &sr300_color_fourcc_to_rs2_format, const std::map< uint32_t, rs2_stream > &sr300_color_fourcc_to_rs2_stream)
std::vector< tagged_profile > get_profiles_tags() const override
std::unique_ptr< sr300_timestamp_reader > _backup_timestamp_reader
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls...
Definition: rs_option.h:22
const uint16_t SR300_RECOVERY
std::map< uint32_t, rs2_stream > sr300_color_fourcc_to_rs2_stream
Definition: sr300.cpp:24
GLfloat GLfloat p
Definition: glext.h:12687
constexpr uint8_t uvc_header_size
Definition: backend.h:165
std::shared_ptr< sensor_base > get_raw_sensor() const
Definition: sensor.h:218
GLuint color
processing_blocks get_color_recommended_proccesing_blocks()
Definition: sensor.cpp:216
GLfloat value
const platform::extension_unit depth_xu
Definition: ivcam-private.h:25
virtual stream_profiles init_stream_profiles() override
Definition: sensor.cpp:1225
const uint16_t SR300v2_PID
GLint GLint GLsizei GLsizei GLsizei depth
std::vector< tagged_profile > get_profiles_tags() const override
unsigned short uint16_t
Definition: stdint.h:79
GLsizei const GLchar *const * string
const char * rs2_sr300_visual_preset_to_string(rs2_sr300_visual_preset preset)
Definition: rs.cpp:1270
bool has_metadata_ts(const std::shared_ptr< frame_interface > &frame) const
std::shared_ptr< hw_monitor > _hw_monitor
unsigned char uint8_t
Definition: stdint.h:78
rs2_intrinsics get_intrinsics(const stream_profile &profile) const override
arithmetic_wraparound< uint32_t, uint64_t > ts_wrap
GLenum GLenum GLsizei void * image
bool is_valid(const plane_3d &p)
Definition: rendering.h:243
std::shared_ptr< rs2_update_progress_callback > update_progress_callback_ptr
Definition: src/types.h:1077
GLuint GLfloat * val
rs2_intrinsics get_intrinsics(const stream_profile &profile) const override
std::map< uint32_t, rs2_format > sr300_color_fourcc_to_rs2_format
Definition: sr300.cpp:19
GLdouble f
const char * get_description() const override
sr300_info(std::shared_ptr< context > ctx, platform::uvc_device_info color, platform::uvc_device_info depth, platform::usb_device_info hwm)
std::shared_ptr< lazy< rs2_extrinsics > > _depth_to_color_extrinsics
const GLubyte * c
Definition: glext.h:12690
bool has_metadata_fc(const std::shared_ptr< frame_interface > &frame) const
GLdouble GLdouble r
processing_blocks get_recommended_processing_blocks() const override
const char * get_value_description(float val) const override
platform::usb_device_info _hwm
const double TIMESTAMP_10NSEC_TO_MSEC
void hardware_reset() override
unsigned int uint32_t
Definition: stdint.h:80
GLboolean GLuint group
Definition: glext.h:5688
std::map< uint32_t, rs2_format > sr300_depth_fourcc_to_rs2_format
Definition: sr300.cpp:30
platform::uvc_device_info _depth
def callback(frame)
Definition: t265_stereo.py:91
unsigned __int64 uint64_t
Definition: stdint.h:90
std::map< uint32_t, rs2_stream > sr300_depth_fourcc_to_rs2_stream
Definition: sr300.cpp:36
float get_depth_scale(rs2::device dev)
lazy< ivcam::camera_calib_params > _camer_calib_params
#define LOG_ERROR(...)
Definition: src/types.h:242
platform::backend_device_group get_device_data() const override
std::vector< std::shared_ptr< stream_profile_interface >> stream_profiles
Definition: streaming.h:165
processing_blocks get_recommended_processing_blocks() const override
static environment & get_instance()
extrinsics_graph & get_extrinsics_graph()
void create_snapshot(std::shared_ptr< depth_sensor > &snapshot) const override
sensor_interface & get_sensor(size_t subdevice) override
Definition: device.cpp:187
std::shared_ptr< stream_interface > _ir_stream
std::vector< uint8_t > send_receive_raw_data(const std::vector< uint8_t > &input) override
unsigned char byte
Definition: src/types.h:52
std::shared_ptr< stream_interface > _depth_stream
GLenum GLenum GLenum input
Definition: glext.h:10805
stream_profile to_profile(const stream_profile_interface *sp)
Definition: src/stream.h:185
const uint16_t SR306_PID
double get_frame_timestamp(const std::shared_ptr< frame_interface > &frame) override
typename::boost::move_detail::remove_reference< T >::type && move(T &&t) BOOST_NOEXCEPT
Video stream intrinsics.
Definition: rs_types.h:58
std::vector< tagged_profile > get_profiles_tags() const override
int i
rs2_timestamp_domain get_frame_timestamp_domain(const std::shared_ptr< frame_interface > &frame) const override
unsigned long long get_frame_counter(const std::shared_ptr< frame_interface > &frame) const override
uvc_sensor & get_raw_depth_sensor()
const uint16_t SR300_PID
platform::uvc_device_info _color
double rs2_time_t
Definition: rs_types.h:300
void rs2_apply_ivcam_preset(int preset)
std::shared_ptr< stream_interface > _color_stream
sr300_depth_sensor(sr3xx_camera *owner, std::shared_ptr< uvc_sensor > uvc_sensor, const std::map< uint32_t, rs2_format > &sr300_depth_fourcc_to_rs2_format, const std::map< uint32_t, rs2_stream > &sr300_depth_fourcc_to_rs2_stream)
void register_depth_xu(synthetic_sensor &depth, rs2_option opt, uint8_t id, std::string desc) const
synthetic_sensor & get_depth_sensor()
std::string to_string(T value)
rs2_timestamp_domain
Specifies the clock in relation to which the frame timestamp was measured.
Definition: rs_frame.h:19


librealsense2
Author(s): Sergey Dorodnicov , Doron Hirshberg , Mark Horn , Reagan Lopez , Itay Carpis
autogenerated on Mon May 3 2021 02:50:10