d400-factory.cpp
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2016 Intel Corporation. All Rights Reserved.
3 
4 #include <mutex>
5 #include <chrono>
6 #include <vector>
7 #include <iterator>
8 #include <cstddef>
9 
10 #include "device.h"
11 #include "image.h"
12 #include "metadata-parser.h"
13 
14 #include <src/core/matcher-factory.h>
15 
16 #include "d400-info.h"
17 #include "d400-private.h"
18 #include "d400-options.h"
19 #include "ds/ds-timestamp.h"
20 #include "d400-nonmonochrome.h"
21 #include "d400-active.h"
22 #include "d400-color.h"
23 #include "d400-motion.h"
24 #include "d400-thermal-monitor.h"
25 #include "sync.h"
26 
27 #include <src/platform/platform-utils.h>
28 
29 #include "firmware_logger_device.h"
30 #include "device-calibration.h"
31 
32 #include <rsutils/string/from.h>
33 
34 #include <src/ds/features/auto-exposure-limit-feature.h>
35 #include <src/ds/features/gain-limit-feature.h>
36 #include <src/ds/features/gyro-sensitivity-feature.h>
37 
38 namespace librealsense
39 {
40  // PSR
41  class rs400_device : public d400_nonmonochrome,
42  public ds_advanced_mode_base,
43  public firmware_logger_device
44  {
45  public:
46  rs400_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
47  : device( dev_info, register_device_notifications )
48  , backend_device( dev_info, register_device_notifications )
49  , d400_device( dev_info )
50  , d400_nonmonochrome( dev_info )
51  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
52  , firmware_logger_device(
53  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
54  {
55  }
56 
57  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
58 
59  std::vector<tagged_profile> get_profiles_tags() const override
60  {
61  std::vector<tagged_profile> tags;
62  auto usb_spec = get_usb_spec();
63  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
64  {
65  tags.push_back({ RS2_STREAM_DEPTH, -1, 1280, 720, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
66  tags.push_back({ RS2_STREAM_INFRARED, 1, 1280, 720, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
67  tags.push_back({ RS2_STREAM_INFRARED, 2, 1280, 720, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET });
68  }
69  else
70  {
71  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
72  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_RGB8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
73  tags.push_back({ RS2_STREAM_INFRARED, 2, 640, 480, RS2_FORMAT_RGB8, 15, profile_tag::PROFILE_TAG_SUPERSET });
74  }
75  return tags;
76  };
77  };
78 
79  // Not used, should be removed with EOL devices clean up
80  class rs405u_device : public ds5u_device,
81  public ds_advanced_mode_base,
82  public firmware_logger_device
83  {
84  public:
85  rs405u_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
86  : device(dev_info, register_device_notifications),
87  backend_device( dev_info, register_device_notifications ),
88  ds5u_device(dev_info),
89  ds_advanced_mode_base(d400_device::_hw_monitor, get_depth_sensor()),
90  firmware_logger_device(dev_info, d400_device::_hw_monitor,
91  get_firmware_logs_command(),
92  get_flash_logs_command()) {}
93 
94  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
95 
96  std::vector<tagged_profile> get_profiles_tags() const override
97  {
98  std::vector<tagged_profile> tags;
99  auto usb_spec = get_usb_spec();
100  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
101  {
102  tags.push_back({ RS2_STREAM_DEPTH, -1, 720, 720, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
103  tags.push_back({ RS2_STREAM_INFRARED, 1, 1152, 1152, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
104  tags.push_back({ RS2_STREAM_INFRARED, 2, 1152, 1152, RS2_FORMAT_Y16, 30, profile_tag::PROFILE_TAG_SUPERSET });
105  }
106  else
107  {
108  tags.push_back({ RS2_STREAM_DEPTH, -1, 720, 720, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
109  tags.push_back({ RS2_STREAM_INFRARED, 1, 1152, 1152, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
110  tags.push_back({ RS2_STREAM_INFRARED, 2, 1152, 1152, RS2_FORMAT_Y16, 15, profile_tag::PROFILE_TAG_SUPERSET });
111  }
112  return tags;
113  };
114 
115  bool contradicts(const stream_profile_interface* a, const std::vector<stream_profile>& others) const override
116  {
117  if (auto vid_a = dynamic_cast<const video_stream_profile_interface*>(a))
118  {
119  for (auto request : others)
120  {
121  if (a->get_framerate() != 0 && request.fps != 0 && (a->get_framerate() != request.fps))
122  return true;
123  }
124  }
125  return false;
126  }
127  };
128 
129  // ASR (D460)
130  class rs410_device : public d400_nonmonochrome,
131  public d400_active,
132  public ds_advanced_mode_base,
133  public firmware_logger_device
134  {
135  public:
136  rs410_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
137  : device( dev_info, register_device_notifications )
138  , backend_device( dev_info, register_device_notifications )
139  , d400_device( dev_info )
140  , d400_nonmonochrome( dev_info )
141  , d400_active( dev_info )
142  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
143  , firmware_logger_device(
144  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
145  {
146  }
147 
148  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
149 
150  std::vector<tagged_profile> get_profiles_tags() const override
151  {
152  std::vector<tagged_profile> tags;
153  auto usb_spec = get_usb_spec();
154  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
155  {
156  tags.push_back({ RS2_STREAM_DEPTH, -1, 1280, 720, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
157  tags.push_back({ RS2_STREAM_INFRARED, 0, 1280, 720, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
158  }
159  else
160  {
161  //TODO: F416 currntlly detected as RS_USB2_PID when connected via USB2 port
162  }
163  return tags;
164  };
165  };
166 
167  // ASRC
168  class rs415_device : public d400_nonmonochrome,
169  public d400_active,
170  public d400_color,
171  public ds_advanced_mode_base,
172  public firmware_logger_device
173  {
174  public:
175  rs415_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
176  : device( dev_info, register_device_notifications )
177  , backend_device( dev_info, register_device_notifications )
178  , d400_device( dev_info )
179  , d400_nonmonochrome( dev_info )
180  , d400_active( dev_info )
181  , d400_color( dev_info )
182  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
183  , firmware_logger_device(
184  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
185  {
186  }
187 
188  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
189 
190  std::vector<tagged_profile> get_profiles_tags() const override
191  {
192  std::vector<tagged_profile> tags;
193  auto usb_spec = get_usb_spec();
194  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
195  {
196  tags.push_back({ RS2_STREAM_COLOR, -1, 1280, 720, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
197  tags.push_back({ RS2_STREAM_DEPTH, -1, 1280, 720, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
198  tags.push_back({ RS2_STREAM_INFRARED, -1, 1280, 720, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
199  }
200  else
201  {
202  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
203  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
204  tags.push_back({ RS2_STREAM_INFRARED, -1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
205  }
206  return tags;
207  };
208  };
209 
210  class rs416_device : public d400_nonmonochrome,
211  public d400_active,
212  public ds_advanced_mode_base,
213  public firmware_logger_device
214  {
215  public:
216  rs416_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
217  : device( dev_info, register_device_notifications )
218  , backend_device( dev_info, register_device_notifications )
219  , d400_device( dev_info )
220  , d400_nonmonochrome( dev_info )
221  , d400_active( dev_info )
222  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
223  , firmware_logger_device(
224  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
225  {
226  }
227 
228  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
229 
230  std::vector<tagged_profile> get_profiles_tags() const override
231  {
232  std::vector<tagged_profile> tags;
233  auto usb_spec = get_usb_spec();
234  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
235  {
236  tags.push_back({ RS2_STREAM_DEPTH, -1, 720, 720, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
237  tags.push_back({ RS2_STREAM_INFRARED, 0, 720, 720, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
238  }
239  else
240  {
241  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
242  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
243  }
244  return tags;
245  };
246 
247  bool contradicts(const stream_profile_interface* a, const std::vector<stream_profile>& others) const override
248  {
249  if (auto vid_a = dynamic_cast<const video_stream_profile_interface*>(a))
250  {
251  for (auto request : others)
252  {
253  if (a->get_framerate() != 0 && request.fps != 0 && (a->get_framerate() != request.fps))
254  return true;
255  }
256  }
257  return false;
258  }
259  };
260 
261  class rs416_rgb_device :
262  public d400_nonmonochrome,
263  public d400_active,
264  public d400_color,
265  public ds_advanced_mode_base,
266  public firmware_logger_device
267 
268  {
269  public:
270  rs416_rgb_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
271  : device( dev_info, register_device_notifications )
272  , backend_device( dev_info, register_device_notifications )
273  , d400_device( dev_info )
274  , d400_nonmonochrome( dev_info )
275  , d400_active( dev_info )
276  , d400_color( dev_info )
277  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
278  , firmware_logger_device(
279  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
280  {
281  }
282 
283  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
284 
285  std::vector<tagged_profile> get_profiles_tags() const override
286  {
287  std::vector<tagged_profile> tags;
288  auto usb_spec = get_usb_spec();
289  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
290  {
291  tags.push_back({ RS2_STREAM_DEPTH, -1, 720, 720, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
292  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
293  tags.push_back({ RS2_STREAM_INFRARED, 1, 720, 720, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
294  }
295  else
296  {
297  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
298  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
299  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
300  }
301  return tags;
302  };
303 
304  bool contradicts(const stream_profile_interface* a, const std::vector<stream_profile>& others) const override
305  {
306  if (auto vid_a = dynamic_cast<const video_stream_profile_interface*>(a))
307  {
308  for (auto request : others)
309  {
310  if (a->get_framerate() != 0 && request.fps != 0 && (a->get_framerate() != request.fps))
311  return true;
312  }
313  }
314  return false;
315  }
316  };
317 
318  // PWGT
319  class rs420_mm_device : public d400_motion,
320  public ds_advanced_mode_base,
321  public firmware_logger_device
322  {
323  public:
324  rs420_mm_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
325  : device( dev_info, register_device_notifications )
326  , backend_device( dev_info, register_device_notifications )
327  , d400_device( dev_info )
328  , d400_motion( dev_info )
329  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
330  , firmware_logger_device(
331  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
332  {
333  }
334 
335  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
336 
337  std::vector<tagged_profile> get_profiles_tags() const override
338  {
339  std::vector<tagged_profile> tags;
340  auto usb_spec = get_usb_spec();
341  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
342  {
343  tags.push_back({ RS2_STREAM_DEPTH, -1, 848, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
344  tags.push_back({ RS2_STREAM_INFRARED, 1, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
345  tags.push_back({ RS2_STREAM_INFRARED, 2, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
346  }
347  else
348  {
349  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
350  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
351  tags.push_back({ RS2_STREAM_INFRARED, 2, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
352  }
353 
354  if (_fw_version >= firmware_version("5.10.4.0"))
355  {
356  tags.push_back({ RS2_STREAM_FISHEYE, -1, 640, 480, RS2_FORMAT_RAW8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT});
357  tags.push_back({RS2_STREAM_GYRO, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_200, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
358  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_63, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
359  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_100, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
360  }
361 
362  return tags;
363  };
364  };
365 
366  // PWG
367  class rs420_device : public d400_device,
368  public ds_advanced_mode_base,
369  public firmware_logger_device
370  {
371  public:
372  rs420_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
373  : device( dev_info, register_device_notifications )
374  , backend_device( dev_info, register_device_notifications )
375  , d400_device( dev_info )
376  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
377  , firmware_logger_device(
378  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
379  {
380  }
381 
382  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
383 
384  std::vector<tagged_profile> get_profiles_tags() const override
385  {
386  std::vector<tagged_profile> tags;
387  auto usb_spec = get_usb_spec();
388  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
389  {
390  tags.push_back({ RS2_STREAM_DEPTH, -1, 848, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
391  tags.push_back({ RS2_STREAM_INFRARED, 1, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
392  tags.push_back({ RS2_STREAM_INFRARED, 2, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
393  }
394  else
395  {
396  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
397  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
398  tags.push_back({ RS2_STREAM_INFRARED, 2, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
399  }
400  return tags;
401  };
402  };
403 
404  // AWG
405  class rs430_device : public d400_active,
406  public ds_advanced_mode_base,
407  public firmware_logger_device
408  {
409  public:
410  rs430_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
411  : device( dev_info, register_device_notifications )
412  , backend_device( dev_info, register_device_notifications )
413  , d400_device( dev_info )
414  , d400_active( dev_info )
415  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
416  , firmware_logger_device(
417  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
418  {
419  }
420 
421  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
422 
423  std::vector<tagged_profile> get_profiles_tags() const override
424  {
425  std::vector<tagged_profile> tags;
426  auto usb_spec = get_usb_spec();
427  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
428  {
429  tags.push_back({ RS2_STREAM_DEPTH, -1, 848, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
430  tags.push_back({ RS2_STREAM_INFRARED, 1, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
431  tags.push_back({ RS2_STREAM_INFRARED, 2, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
432  }
433  else
434  {
435  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
436  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
437  tags.push_back({ RS2_STREAM_INFRARED, 2, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
438  }
439  return tags;
440  };
441  };
442 
443  class rs430i_device : public d400_active,
444  public ds_advanced_mode_base,
445  public d400_motion,
446  public firmware_logger_device
447  {
448  public:
449  rs430i_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
450  : device( dev_info, register_device_notifications )
451  , backend_device( dev_info, register_device_notifications )
452  , d400_device( dev_info )
453  , d400_active( dev_info )
454  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
455  , d400_motion( dev_info )
456  , firmware_logger_device(
457  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
458  {
459  }
460 
461  std::vector<tagged_profile> get_profiles_tags() const override
462  {
463  std::vector<tagged_profile> tags;
464  auto usb_spec = get_usb_spec();
465  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
466  {
467  tags.push_back({ RS2_STREAM_DEPTH, -1, 848, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
468  tags.push_back({ RS2_STREAM_INFRARED, 1, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
469  tags.push_back({ RS2_STREAM_INFRARED, 2, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
470  }
471  else
472  {
473  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
474  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
475  tags.push_back({ RS2_STREAM_INFRARED, 2, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
476  }
477  tags.push_back({ RS2_STREAM_GYRO, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_200, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
478  tags.push_back({ RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_63, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
479  tags.push_back({ RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_100, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
480 
481  return tags;
482  };
483  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
484  };
485 
486  // AWGT
487  class rs430_mm_device : public d400_active,
488  public d400_motion,
489  public ds_advanced_mode_base,
490  public firmware_logger_device
491  {
492  public:
493  rs430_mm_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
494  : device( dev_info, register_device_notifications )
495  , backend_device( dev_info, register_device_notifications )
496  , d400_device( dev_info )
497  , d400_active( dev_info )
498  , d400_motion( dev_info )
499  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
500  , firmware_logger_device(
501  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
502  {
503  }
504 
505  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
506 
507  std::vector<tagged_profile> get_profiles_tags() const override
508  {
509  std::vector<tagged_profile> tags;
510  auto usb_spec = get_usb_spec();
511  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
512  {
513  tags.push_back({ RS2_STREAM_DEPTH, -1, 848, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
514  tags.push_back({ RS2_STREAM_INFRARED, 1, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
515  tags.push_back({ RS2_STREAM_INFRARED, 2, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
516 
517  }
518  else
519  {
520  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
521  tags.push_back({ RS2_STREAM_INFRARED, 1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
522  tags.push_back({ RS2_STREAM_INFRARED, 2, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
523  }
524 
525  tags.push_back({ RS2_STREAM_FISHEYE, -1, 640, 480, RS2_FORMAT_RAW8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT});
526  if (_fw_version >= firmware_version("5.10.4.0")) // Back-compat with records is required
527  {
528  tags.push_back({RS2_STREAM_GYRO, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_200, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
529  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_63, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
530  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_100, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
531  }
532 
533  return tags;
534  };
535  };
536 
537  // AWGC
538  class rs435_device : public d400_active,
539  public d400_color,
540  public ds_advanced_mode_base,
541  public firmware_logger_device
542  {
543  public:
544  rs435_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
545  : device( dev_info, register_device_notifications )
546  , backend_device( dev_info, register_device_notifications )
547  , d400_device( dev_info )
548  , d400_active( dev_info )
549  , d400_color( dev_info )
550  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
551  , firmware_logger_device(
552  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
553  {
554  }
555 
556  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
557 
558  std::vector<tagged_profile> get_profiles_tags() const override
559  {
560  std::vector<tagged_profile> tags;
561  auto usb_spec = get_usb_spec();
562  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
563  {
564  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
565  tags.push_back({ RS2_STREAM_DEPTH, -1, 848, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
566  tags.push_back({ RS2_STREAM_INFRARED, -1, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
567  }
568  else
569  {
570  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
571  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
572  tags.push_back({ RS2_STREAM_INFRARED, -1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
573  }
574  return tags;
575  };
576  };
577 
578  // D457 Development
579  class rs457_device : public d400_active,
580  public d400_color,
581  public d400_motion_uvc,
582  public ds_advanced_mode_base,
583  public firmware_logger_device
584  {
585  public:
586  rs457_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
587  : device( dev_info, register_device_notifications )
588  , backend_device( dev_info, register_device_notifications )
589  , d400_device( dev_info )
590  , d400_active( dev_info )
591  , d400_color( dev_info )
592  , d400_motion_uvc( dev_info )
593  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
594  , firmware_logger_device(
595  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
596  {
597  }
598 
599  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
600 
601  std::vector<tagged_profile> get_profiles_tags() const override
602  {
603  std::vector<tagged_profile> tags;
604 
605  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
606  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
607 
608  return tags;
609  };
610  };
611 
612  // AWGCT
613  class rs430_rgb_mm_device : public d400_active,
614  public d400_color,
615  public d400_motion,
616  public ds_advanced_mode_base,
617  public firmware_logger_device
618  {
619  public:
620  rs430_rgb_mm_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
621  : device( dev_info, register_device_notifications )
622  , backend_device( dev_info, register_device_notifications )
623  , d400_device( dev_info )
624  , d400_active( dev_info )
625  , d400_color( dev_info )
626  , d400_motion( dev_info )
627  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
628  , firmware_logger_device(
629  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
630  {
631  }
632 
633  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
634 
635  std::vector<tagged_profile> get_profiles_tags() const override
636  {
637  std::vector<tagged_profile> tags;
638  auto usb_spec = get_usb_spec();
639  if (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined)
640  {
641  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
642  tags.push_back({ RS2_STREAM_DEPTH, -1, 848, 480, RS2_FORMAT_Z16, 30, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
643  tags.push_back({ RS2_STREAM_INFRARED, -1, 848, 480, RS2_FORMAT_Y8, 30, profile_tag::PROFILE_TAG_SUPERSET });
644  }
645  else
646  {
647  tags.push_back({ RS2_STREAM_COLOR, -1, 640, 480, RS2_FORMAT_RGB8, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
648  tags.push_back({ RS2_STREAM_DEPTH, -1, 640, 480, RS2_FORMAT_Z16, 15, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
649  tags.push_back({ RS2_STREAM_INFRARED, -1, 640, 480, RS2_FORMAT_Y8, 15, profile_tag::PROFILE_TAG_SUPERSET });
650  }
651  return tags;
652  };
653  };
654 
655 
656  class rs435i_device : public d400_active,
657  public d400_color,
658  public d400_motion,
659  public ds_advanced_mode_base,
660  public firmware_logger_device
661  {
662  public:
663  rs435i_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
664  : device( dev_info, register_device_notifications )
665  , backend_device( dev_info, register_device_notifications )
666  , d400_device( dev_info )
667  , d400_active( dev_info )
668  , d400_color( dev_info )
669  , d400_motion( dev_info )
670  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
671  , firmware_logger_device(
672  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
673  {
674  check_and_restore_rgb_stream_extrinsic();
675  if( _fw_version >= firmware_version( 5, 16, 0, 0 ) )
676  register_feature(
677  std::make_shared< gyro_sensitivity_feature >( get_raw_motion_sensor(), get_motion_sensor() ) );
678  }
679 
680 
681  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
682 
683  std::vector<tagged_profile> get_profiles_tags() const override
684  {
685  std::vector<tagged_profile> tags;
686  auto usb_spec = get_usb_spec();
687  bool usb3mode = (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined);
688 
689  int depth_width = usb3mode ? 848 : 640;
690  int depth_height = usb3mode ? 480 : 480;
691  int color_width = usb3mode ? 1280 : 640;
692  int color_height = usb3mode ? 720 : 480;
693  int fps = usb3mode ? 30 : 15;
694 
695  tags.push_back({ RS2_STREAM_COLOR, -1, color_width, color_height, RS2_FORMAT_RGB8, fps, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
696  tags.push_back({ RS2_STREAM_DEPTH, -1, depth_width, depth_height, RS2_FORMAT_Z16, fps, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
697  tags.push_back({ RS2_STREAM_INFRARED, -1, depth_width, depth_height, RS2_FORMAT_Y8, fps, profile_tag::PROFILE_TAG_SUPERSET });
698  tags.push_back({RS2_STREAM_GYRO, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_200, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
699  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_63, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
700  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_100, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
701  return tags;
702  };
703  bool compress_while_record() const override { return false; }
704 
705  private:
706  void check_and_restore_rgb_stream_extrinsic()
707  {
708  for(auto iter = 0, rec =0; iter < 2; iter++, rec++)
709  {
710  std::vector< uint8_t > cal;
711  try
712  {
713  cal = *_color_calib_table_raw;
714  }
715  catch (...)
716  {
717  LOG_WARNING("Cannot read RGB calibration table");
718  }
719 
720  if (!is_rgb_extrinsic_valid(cal) && !rec)
721  {
722  restore_rgb_extrinsic();
723  }
724  else
725  break;
726  };
727  }
728 
729  bool is_rgb_extrinsic_valid(const std::vector<uint8_t>& raw_data) const
730  {
731  try
732  {
733  // verify extrinsic calibration table structure
734  auto table = ds::check_calib<ds::d400_rgb_calibration_table>(raw_data);
735 
736  if ( (table->header.version != 0 && table->header.version != 0xffff) && (table->header.table_size >= sizeof(ds::d400_rgb_calibration_table) - sizeof(ds::table_header)))
737  {
738  float3 trans_vector = table->translation_rect;
739  // Translation Heuristic tests
740  auto found = false;
741  for (auto i = 0; i < 3; i++)
742  {
743  //Nan/Infinity are not allowed
744  if (!std::isfinite(trans_vector[i]))
745  {
746  LOG_WARNING("RGB extrinsic - translation is corrupted: " << trans_vector);
747  return false;
748  }
749  // Translation must be assigned for at least one axis
750  if (std::fabs(trans_vector[i]) > std::numeric_limits<float>::epsilon())
751  found = true;
752  }
753 
754  if (!found)
755  {
756  LOG_WARNING("RGB extrinsic - invalid (zero) translation: " << trans_vector);
757  return false;
758  }
759 
760  // Rotation Heuristic tests
761  auto num_found = 0;
762  float3x3 rect_rot_mat = table->rotation_matrix_rect;
763  for (auto i = 0; i < 3; i++)
764  {
765  for (auto j = 0; j < 3; j++)
766  {
767  //Nan/Infinity are not allowed
768  if (!std::isfinite(rect_rot_mat(i, j)))
769  {
770  LOG_DEBUG("RGB extrinsic - rotation matrix corrupted:\n" << rect_rot_mat);
771  return false;
772  }
773 
774  if (std::fabs(rect_rot_mat(i, j)) > std::numeric_limits<float>::epsilon())
775  num_found++;
776  }
777  }
778 
779  bool res = (num_found >= 3); // At least three matrix indexes must be non-zero
780  if (!res) // At least three matrix indexes must be non-zero
781  LOG_DEBUG("RGB extrinsic - rotation matrix invalid:\n" << rect_rot_mat);
782 
783  return res;
784  }
785  else
786  {
787  LOG_WARNING("RGB extrinsic - header corrupted: "
788  << "Version: " <<std::setfill('0') << std::setw(4) << std::hex << table->header.version
789  << ", type " << std::dec << table->header.table_type << ", size " << table->header.table_size);
790  return false;
791  }
792  }
793  catch (...)
794  {
795  return false;
796  }
797  }
798 
799  void assign_rgb_stream_extrinsic( const std::vector< uint8_t > & calib )
800  {
801  //write calibration to preset
802  command cmd(ds::fw_cmd::SETINTCALNEW, 0x20, 0x2);
803  cmd.data = calib;
804  d400_device::_hw_monitor->send(cmd);
805  }
806 
807  std::vector< uint8_t > read_sector( const uint32_t address, const uint16_t size ) const
808  {
809  if (size > ds_advanced_mode_base::HW_MONITOR_COMMAND_SIZE)
810  throw std::runtime_error( rsutils::string::from()
811  << "Device memory read failed. max size: "
812  << int(ds_advanced_mode_base::HW_MONITOR_COMMAND_SIZE)
813  << ", requested: " << int( size ) );
814  command cmd(ds::fw_cmd::FRB, address, size);
815  return d400_device::_hw_monitor->send(cmd);
816  }
817 
818  std::vector< uint8_t > read_rgb_gold() const
819  {
820  command cmd(ds::fw_cmd::LOADINTCAL, 0x20, 0x1);
821  return d400_device::_hw_monitor->send(cmd);
822  }
823 
824  std::vector< uint8_t > restore_calib_factory_settings() const
825  {
826  command cmd(ds::fw_cmd::CAL_RESTORE_DFLT);
827  return d400_device::_hw_monitor->send(cmd);
828  }
829 
830  void restore_rgb_extrinsic(void)
831  {
832  bool res = false;
833  LOG_WARNING("invalid RGB extrinsic was identified, recovery routine was invoked");
834  try
835  {
836  if ((res = is_rgb_extrinsic_valid(read_rgb_gold())))
837  {
838  restore_calib_factory_settings();
839  }
840  else
841  {
842  if (_fw_version == firmware_version("5.11.6.200"))
843  {
844  const uint32_t gold_address = 0x17c49c;
845  const uint16_t bytes_to_read = 0x100;
846  auto alt_calib = read_sector(gold_address, bytes_to_read);
847  if ((res = is_rgb_extrinsic_valid(alt_calib)))
848  assign_rgb_stream_extrinsic(alt_calib);
849  else
850  res = false;
851  }
852  else
853  res = false;
854  }
855 
856  // Update device's internal state
857  if (res)
858  {
859  LOG_WARNING("RGB stream extrinsic successfully recovered");
860  _color_calib_table_raw.reset();
861  _color_extrinsic.get()->reset();
862  environment::get_instance().get_extrinsics_graph().register_extrinsics(*_color_stream, *_depth_stream, _color_extrinsic);
863  }
864  else
865  {
866  LOG_ERROR("RGB Extrinsic recovery routine failed");
867  _color_extrinsic.get()->reset();
868  }
869  }
870  catch (...)
871  {
872  LOG_ERROR("RGB Extrinsic recovery routine failed");
873  }
874  }
875  };
876 
877  class rs400_imu_device : public d400_motion,
878  public ds_advanced_mode_base,
879  public firmware_logger_device
880  {
881  public:
882  rs400_imu_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
883  : device( dev_info, register_device_notifications )
884  , backend_device( dev_info, register_device_notifications )
885  , d400_device( dev_info )
886  , d400_motion( dev_info )
887  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
888  , firmware_logger_device(
889  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
890  {
891  }
892 
893  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
894 
895  std::vector<tagged_profile> get_profiles_tags() const override
896  {
897  std::vector<tagged_profile> tags;
898  tags.push_back({RS2_STREAM_GYRO, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_200, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
899  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_63, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
900  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_100, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
901 
902  return tags;
903  };
904  };
905 
906  class rs405_device : public d400_color,
907  public d400_nonmonochrome,
908  public ds_advanced_mode_base,
909  public firmware_logger_device
910  {
911  public:
912  rs405_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
913  : device( dev_info, register_device_notifications )
914  , backend_device( dev_info, register_device_notifications )
915  , d400_device( dev_info )
916  , d400_color( dev_info )
917  , d400_nonmonochrome( dev_info )
918  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
919  , firmware_logger_device(
920  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
921  {
922  }
923 
924  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
925 
926  std::vector<tagged_profile> get_profiles_tags() const override
927  {
928  std::vector<tagged_profile> tags;
929  auto usb_spec = get_usb_spec();
930  bool usb3mode = (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined);
931 
932  int depth_width = 848;
933  int depth_height = 480;
934  int color_width = 848;
935  int color_height = 480;
936  int fps = usb3mode ? 30 : 10;
937 
938  auto format_conversion = get_format_conversion();
939 
940  tags.push_back( { RS2_STREAM_COLOR,
941  -1, // index
942  color_width, color_height,
943  ( format_conversion == format_conversion::full ) ? RS2_FORMAT_RGB8 : RS2_FORMAT_YUYV,
944  fps,
945  profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT } );
946  tags.push_back( { RS2_STREAM_DEPTH,
947  -1, // index
948  depth_width, depth_height,
949  RS2_FORMAT_Z16,
950  fps,
951  profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT } );
952  tags.push_back( { RS2_STREAM_INFRARED,
953  -1, // index
954  depth_width, depth_height,
955  ( format_conversion == format_conversion::raw ) ? RS2_FORMAT_Y8I : RS2_FORMAT_Y8,
956  fps,
957  profile_tag::PROFILE_TAG_SUPERSET } );
958 
959  return tags;
960  }
961 
962  bool compress_while_record() const override { return false; }
963 
964  bool contradicts(const stream_profile_interface* a, const std::vector<stream_profile>& others) const override
965  {
966  auto it = std::find_if(others.begin(), others.end(), [](const stream_profile& sp) {
967  return sp.format == RS2_FORMAT_Y16;
968  });
969  bool unrectified_ir_requested = (it != others.end());
970 
971  if (auto vid_a = dynamic_cast<const video_stream_profile_interface*>(a))
972  {
973  for (auto request : others)
974  {
975  if (a->get_framerate() != 0 && request.fps != 0 && (a->get_framerate() != request.fps))
976  return true;
977  if (!unrectified_ir_requested)
978  {
979  if (vid_a->get_width() != 0 && request.width != 0 && (vid_a->get_width() != request.width))
980  return true;
981  if (vid_a->get_height() != 0 && request.height != 0 && (vid_a->get_height() != request.height))
982  return true;
983  }
984  }
985  }
986  return false;
987  }
988  };
989 
990  class rs455_device : public d400_nonmonochrome,
991  public d400_active,
992  public d400_color,
993  public d400_motion,
994  public ds_advanced_mode_base,
995  public firmware_logger_device,
996  public d400_thermal_tracking
997  {
998  public:
999  rs455_device( std::shared_ptr< const d400_info > const & dev_info, bool register_device_notifications )
1000  : device( dev_info, register_device_notifications )
1001  , backend_device( dev_info, register_device_notifications )
1002  , d400_device( dev_info )
1003  , d400_nonmonochrome( dev_info )
1004  , d400_active( dev_info )
1005  , d400_color( dev_info )
1006  , d400_motion( dev_info )
1007  , ds_advanced_mode_base( d400_device::_hw_monitor, get_depth_sensor() )
1008  , firmware_logger_device(
1009  dev_info, d400_device::_hw_monitor, get_firmware_logs_command(), get_flash_logs_command() )
1010  , d400_thermal_tracking( d400_device::_thermal_monitor )
1011  {
1012  if( _fw_version >= firmware_version( 5, 16, 0, 0 ) )
1013  register_feature(
1014  std::make_shared< gyro_sensitivity_feature >( get_raw_motion_sensor(), get_motion_sensor() ) );
1015  }
1016 
1017  std::shared_ptr<matcher> create_matcher(const frame_holder& frame) const override;
1018 
1019  std::vector<tagged_profile> get_profiles_tags() const override
1020  {
1021  std::vector<tagged_profile> tags;
1022  auto usb_spec = get_usb_spec();
1023  bool usb3mode = (usb_spec >= platform::usb3_type || usb_spec == platform::usb_undefined);
1024 
1025  int depth_width = usb3mode ? 848 : 640;
1026  int depth_height = usb3mode ? 480 : 480;
1027  int color_width = usb3mode ? 1280 : 640;
1028  int color_height = usb3mode ? 720 : 480;
1029  int fps = usb3mode ? 30 : 15;
1030 
1031  tags.push_back({ RS2_STREAM_COLOR, -1, color_width, color_height, RS2_FORMAT_RGB8, fps, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
1032  tags.push_back({ RS2_STREAM_DEPTH, -1, depth_width, depth_height, RS2_FORMAT_Z16, fps, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
1033  tags.push_back({ RS2_STREAM_INFRARED, -1, depth_width, depth_height, RS2_FORMAT_Y8, fps, profile_tag::PROFILE_TAG_SUPERSET });
1034  tags.push_back({RS2_STREAM_GYRO, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_200, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
1035  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_63, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
1036  tags.push_back({RS2_STREAM_ACCEL, -1, 0, 0, RS2_FORMAT_MOTION_XYZ32F, (int)odr::IMU_FPS_100, profile_tag::PROFILE_TAG_SUPERSET | profile_tag::PROFILE_TAG_DEFAULT });
1037 
1038  return tags;
1039  }
1040 
1041  bool compress_while_record() const override { return false; }
1042 
1043  };
1044 
1045  std::shared_ptr< device_interface > d400_info::create_device()
1046  {
1047  using namespace ds;
1048 
1049  if( _group.uvc_devices.empty() )
1050  throw std::runtime_error("Depth Camera not found!");
1051 
1052  auto const dev_info = std::dynamic_pointer_cast< const d400_info >( shared_from_this() );
1053  bool const register_device_notifications = true;
1054 
1055  auto pid = _group.uvc_devices.front().pid;
1056  switch(pid)
1057  {
1058  case RS400_PID:
1059  return std::make_shared< rs400_device >( dev_info, register_device_notifications );
1060  case RS405U_PID:
1061  return std::make_shared< rs405u_device >( dev_info, register_device_notifications );
1062  case RS410_PID:
1063  case RS460_PID:
1064  return std::make_shared< rs410_device >( dev_info, register_device_notifications );
1065  case RS415_PID:
1066  return std::make_shared< rs415_device >( dev_info, register_device_notifications );
1067  case RS416_PID:
1068  return std::make_shared< rs416_device >( dev_info, register_device_notifications );
1069  case RS416_RGB_PID:
1070  return std::make_shared< rs416_rgb_device >( dev_info, register_device_notifications );
1071  case RS420_PID:
1072  return std::make_shared< rs420_device >( dev_info, register_device_notifications );
1073  case RS420_MM_PID:
1074  return std::make_shared< rs420_mm_device >( dev_info, register_device_notifications );
1075  case RS430_PID:
1076  return std::make_shared< rs430_device >( dev_info, register_device_notifications );
1077  case RS430I_PID:
1078  return std::make_shared< rs430i_device >( dev_info, register_device_notifications );
1079  case RS430_MM_PID:
1080  return std::make_shared< rs430_mm_device >( dev_info, register_device_notifications );
1081  case RS430_MM_RGB_PID:
1082  return std::make_shared< rs430_rgb_mm_device >( dev_info, register_device_notifications );
1083  case RS435_RGB_PID:
1084  return std::make_shared< rs435_device >( dev_info, register_device_notifications );
1085  case RS435I_PID:
1086  return std::make_shared< rs435i_device >( dev_info, register_device_notifications );
1087  case RS_USB2_PID:
1088  return std::make_shared< rs410_device >( dev_info, register_device_notifications );
1089  case RS400_IMU_PID:
1090  return std::make_shared< rs400_imu_device >( dev_info, register_device_notifications );
1091  case RS405_PID:
1092  return std::make_shared< rs405_device >( dev_info, register_device_notifications );
1093  case RS455_PID:
1094  return std::make_shared< rs455_device >( dev_info, register_device_notifications );
1095  case RS457_PID:
1096  return std::make_shared< rs457_device >( dev_info, register_device_notifications );
1097  default:
1098  throw std::runtime_error( rsutils::string::from() << "Unsupported RS400 model! 0x" << std::hex
1099  << std::setw( 4 ) << std::setfill( '0' ) << (int)pid );
1100  }
1101  }
1102 
1103  std::vector<std::shared_ptr<d400_info>> d400_info::pick_d400_devices(
1104  std::shared_ptr<context> ctx,
1105  platform::backend_device_group& group)
1106  {
1107  std::vector<platform::uvc_device_info> chosen;
1108  std::vector<std::shared_ptr<d400_info>> results;
1109 
1110  auto valid_pid = filter_by_product(group.uvc_devices, ds::rs400_sku_pid);
1111  auto group_devices = group_devices_and_hids_by_unique_id(group_devices_by_unique_id(valid_pid), group.hid_devices);
1112 
1113  for (auto& g : group_devices)
1114  {
1115  auto& devices = g.first;
1116  auto& hids = g.second;
1117 
1118  bool all_sensors_present = mi_present(devices, 0);
1119 
1120  // Device with multi sensors can be enabled only if all sensors (RGB + Depth) are present
1121  auto is_pid_of_multisensor_device = [](int pid) { return std::find(std::begin(ds::d400_multi_sensors_pid), std::end(ds::d400_multi_sensors_pid), pid) != std::end(ds::d400_multi_sensors_pid); };
1122  bool is_device_multisensor = false;
1123  for (auto&& uvc : devices)
1124  {
1125  if (is_pid_of_multisensor_device(uvc.pid))
1126  is_device_multisensor = true;
1127  }
1128 
1129  if(is_device_multisensor)
1130  {
1131  all_sensors_present = all_sensors_present && mi_present(devices, 3);
1132  // temp w/a
1133  all_sensors_present = true;
1134  }
1135 
1136 
1137 #if !defined(__APPLE__) // Not supported by macos
1138  auto is_pid_of_hid_sensor_device = [](int pid) { return std::find(std::begin(ds::d400_hid_sensors_pid),
1139  std::end(ds::d400_hid_sensors_pid), pid) != std::end(ds::d400_hid_sensors_pid); };
1140  bool is_device_hid_sensor = false;
1141  for (auto&& uvc : devices)
1142  {
1143  if (is_pid_of_hid_sensor_device(uvc.pid))
1144  is_device_hid_sensor = true;
1145  }
1146 
1147  // Device with hids can be enabled only if both hids (gyro and accelerometer) are present
1148  // Assuming that hids amount of 2 and above guarantee that gyro and accelerometer are present
1149  if (is_device_hid_sensor)
1150  {
1151  all_sensors_present &= (hids.size() >= 2);
1152  }
1153 #endif
1154 
1155  if (!devices.empty() && all_sensors_present)
1156  {
1157  platform::usb_device_info hwm;
1158 
1159  std::vector<platform::usb_device_info> hwm_devices;
1160  if (ds::d400_try_fetch_usb_device(group.usb_devices, devices.front(), hwm))
1161  {
1162  hwm_devices.push_back(hwm);
1163  }
1164 
1165  auto info = std::make_shared<d400_info>( ctx, std::move( devices ), std::move( hwm_devices ), std::move( hids ) );
1166  chosen.insert(chosen.end(), devices.begin(), devices.end());
1167  results.push_back(info);
1168 
1169  }
1170  }
1171 
1172  trim_device_list(group.uvc_devices, chosen);
1173 
1174  return results;
1175  }
1176 
1177 
1178  inline std::shared_ptr<matcher> create_composite_matcher(std::vector<std::shared_ptr<matcher>> matchers)
1179  {
1180  return std::make_shared<timestamp_composite_matcher>(matchers);
1181  }
1182 
1183  std::shared_ptr<matcher> rs400_device::create_matcher(const frame_holder& frame) const
1184  {
1185  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get()};
1186  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1187  }
1188 
1189  std::shared_ptr<matcher> rs405u_device::create_matcher(const frame_holder& frame) const
1190  {
1191  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get()};
1192  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1193  }
1194 
1195  std::shared_ptr<matcher> rs410_device::create_matcher(const frame_holder& frame) const
1196  {
1197  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get()};
1198  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1199  }
1200 
1201  std::shared_ptr<matcher> rs415_device::create_matcher(const frame_holder& frame) const
1202  {
1203  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1204  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1205  }
1206 
1207  std::shared_ptr<matcher> rs416_device::create_matcher(const frame_holder& frame) const
1208  {
1209  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get() };
1210  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1211  }
1212 
1213  std::shared_ptr<matcher> rs416_rgb_device::create_matcher(const frame_holder& frame) const
1214  {
1215  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1216  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1217  }
1218 
1219  std::shared_ptr<matcher> rs420_mm_device::create_matcher(const frame_holder& frame) const
1220  {
1221  //TODO: add matcher to mm
1222  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get()};
1223  std::vector<stream_interface*> mm_streams = {
1224  _ds_motion_common->get_fisheye_stream().get(),
1225  _ds_motion_common->get_accel_stream().get(),
1226  _ds_motion_common->get_gyro_stream().get()
1227  };
1228  streams.insert(streams.end(), mm_streams.begin(), mm_streams.end());
1229  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1230  }
1231 
1232  std::shared_ptr<matcher> rs420_device::create_matcher(const frame_holder& frame) const
1233  {
1234  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get()};
1235  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1236  }
1237 
1238  std::shared_ptr<matcher> rs430_device::create_matcher(const frame_holder& frame) const
1239  {
1240  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get() };
1241  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1242  }
1243 
1244  std::shared_ptr<matcher> rs430_mm_device::create_matcher(const frame_holder& frame) const
1245  {
1246  //TODO: add matcher to mm
1247  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get() };
1248  std::vector<stream_interface*> mm_streams = {
1249  _ds_motion_common->get_fisheye_stream().get(),
1250  _ds_motion_common->get_accel_stream().get(),
1251  _ds_motion_common->get_gyro_stream().get()
1252  };
1253  streams.insert(streams.end(), mm_streams.begin(), mm_streams.end());
1254  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1255  }
1256 
1257  std::shared_ptr<matcher> rs435_device::create_matcher(const frame_holder& frame) const
1258  {
1259  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1260  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1261  }
1262 
1263  std::shared_ptr<matcher> rs430_rgb_mm_device::create_matcher(const frame_holder& frame) const
1264  {
1265  //TODO: add matcher to mm
1266  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1267  std::vector<stream_interface*> mm_streams = {
1268  _ds_motion_common->get_fisheye_stream().get(),
1269  _ds_motion_common->get_accel_stream().get(),
1270  _ds_motion_common->get_gyro_stream().get()
1271  };
1272  streams.insert(streams.end(), mm_streams.begin(), mm_streams.end());
1273  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1274  }
1275 
1276  std::shared_ptr<matcher> rs430i_device::create_matcher(const frame_holder& frame) const
1277  {
1278  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get() };
1279  // TODO - A proper matcher for High-FPS sensor is required
1280  std::vector<stream_interface*> mm_streams = { _ds_motion_common->get_accel_stream().get(),
1281  _ds_motion_common->get_gyro_stream().get() };
1282  streams.insert(streams.end(), mm_streams.begin(), mm_streams.end());
1283  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1284  }
1285 
1286  std::shared_ptr<matcher> rs435i_device::create_matcher(const frame_holder& frame) const
1287  {
1288  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1289  // TODO - A proper matcher for High-FPS sensor is required
1290  std::vector<stream_interface*> mm_streams = { _ds_motion_common->get_accel_stream().get(),
1291  _ds_motion_common->get_gyro_stream().get()};
1292  streams.insert(streams.end(), mm_streams.begin(), mm_streams.end());
1293  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1294  }
1295 
1296 
1297  std::shared_ptr<matcher> rs457_device::create_matcher(const frame_holder& frame) const
1298  {
1299  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1300  std::vector<stream_interface*> mm_streams = { _accel_stream.get(), _gyro_stream.get()};
1301  streams.insert(streams.end(), mm_streams.begin(), mm_streams.end());
1302  if( frame.frame->find_metadata( RS2_FRAME_METADATA_FRAME_COUNTER, nullptr ) )
1303  {
1304  return matcher_factory::create(RS2_MATCHER_DLR_C, streams);
1305  }
1306  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1307  }
1308 
1309  std::shared_ptr<matcher> rs400_imu_device::create_matcher(const frame_holder& frame) const
1310  {
1311  // TODO - A proper matcher for High-FPS sensor is required
1312  std::vector<stream_interface*> mm_streams = { _ds_motion_common->get_accel_stream().get(),
1313  _ds_motion_common->get_gyro_stream().get()};
1314  return matcher_factory::create(RS2_MATCHER_DEFAULT, mm_streams);
1315  }
1316 
1317  std::shared_ptr<matcher> rs405_device::create_matcher(const frame_holder& frame) const
1318  {
1319  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1320  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1321  }
1322 
1323  std::shared_ptr<matcher> rs455_device::create_matcher(const frame_holder& frame) const
1324  {
1325  std::vector<stream_interface*> streams = { _depth_stream.get() , _left_ir_stream.get() , _right_ir_stream.get(), _color_stream.get() };
1326  std::vector<stream_interface*> mm_streams = { _ds_motion_common->get_accel_stream().get(),
1327  _ds_motion_common->get_gyro_stream().get()};
1328  streams.insert(streams.end(), mm_streams.begin(), mm_streams.end());
1329  return matcher_factory::create(RS2_MATCHER_DEFAULT, streams);
1330  }
1331 }
librealsense::rs435_device
Definition: d400-factory.cpp:538
librealsense::format_conversion
format_conversion
Definition: device.h:24
librealsense::rs430_device
Definition: d400-factory.cpp:405
d400-motion.h
RS2_FORMAT_RAW8
@ RS2_FORMAT_RAW8
Definition: rs_sensor.h:76
librealsense
Definition: algo.h:18
d400-private.h
librealsense::rs420_mm_device
Definition: d400-factory.cpp:319
test-fw-update.cmd
list cmd
Definition: test-fw-update.py:141
librealsense::rs400_device::rs400_device
rs400_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:46
librealsense::d400_motion::get_raw_motion_sensor
std::shared_ptr< hid_sensor > get_raw_motion_sensor()
Definition: d400-motion.cpp:148
platform-utils.h
librealsense::d400_device::get_flash_logs_command
command get_flash_logs_command() const
Definition: d400-device.cpp:1235
rmse.x1
int x1
Definition: rmse.py:50
librealsense::d400_device::_depth_stream
std::shared_ptr< stream_interface > _depth_stream
Definition: d400-device.h:99
librealsense::PROFILE_TAG_SUPERSET
@ PROFILE_TAG_SUPERSET
Definition: tagged-profile.h:14
librealsense::rs405_device
Definition: d400-factory.cpp:906
librealsense::ds::LOADINTCAL
@ LOADINTCAL
Definition: ds-private.h:96
librealsense::rs430_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:423
rspy.file.find
def find(dir, mask)
Definition: file.py:45
librealsense::rs400_device
Definition: d400-factory.cpp:41
librealsense::ds::RS457_PID
const uint16_t RS457_PID
Definition: d400-private.h:39
test-got-playback-frames.color_width
color_width
Definition: test-got-playback-frames.py:12
librealsense::rs430_rgb_mm_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1263
librealsense::ds_advanced_mode_base::_hw_monitor
std::shared_ptr< hw_monitor > _hw_monitor
Definition: advanced_mode.h:204
test-stream-sensor-bridge.streams
dictionary streams
Definition: test-stream-sensor-bridge.py:91
RS2_FORMAT_Y8I
@ RS2_FORMAT_Y8I
Definition: rs_sensor.h:86
uint16_t
unsigned short uint16_t
Definition: stdint.h:79
librealsense::format_conversion::full
@ full
librealsense::d400_device::_thermal_monitor
std::shared_ptr< d400_thermal_monitor > _thermal_monitor
Definition: d400-device.h:110
librealsense::rs435i_device::check_and_restore_rgb_stream_extrinsic
void check_and_restore_rgb_stream_extrinsic()
Definition: d400-factory.cpp:706
librealsense::rs435i_device::rs435i_device
rs435i_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:663
librealsense::stream_profile_interface
Definition: stream-profile-interface.h:18
sync.h
librealsense::ds::RS415_PID
const uint16_t RS415_PID
Definition: d400-private.h:18
librealsense::rs455_device::compress_while_record
bool compress_while_record() const override
Definition: d400-factory.cpp:1041
librealsense::rs435i_device::read_rgb_gold
std::vector< uint8_t > read_rgb_gold() const
Definition: d400-factory.cpp:818
librealsense::create_composite_matcher
std::shared_ptr< matcher > create_composite_matcher(std::vector< std::shared_ptr< matcher >> matchers)
Definition: d400-factory.cpp:1178
librealsense::rs405_device::contradicts
bool contradicts(const stream_profile_interface *a, const std::vector< stream_profile > &others) const override
Definition: d400-factory.cpp:964
librealsense::rs457_device::rs457_device
rs457_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:586
RS2_FORMAT_RGB8
@ RS2_FORMAT_RGB8
Definition: rs_sensor.h:68
librealsense::ds::table_header
Definition: ds-private.h:259
librealsense::rs400_imu_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1309
librealsense::rs416_device::contradicts
bool contradicts(const stream_profile_interface *a, const std::vector< stream_profile > &others) const override
Definition: d400-factory.cpp:247
librealsense::d400_thermal_tracking
Definition: d400-thermal-monitor.h:47
librealsense::platform::filter_by_product
std::vector< uvc_device_info > filter_by_product(const std::vector< uvc_device_info > &devices, const std::set< uint16_t > &pid_list)
Definition: platform-utils.cpp:15
device-calibration.h
devices
Definition: third-party/realdds/scripts/devices.py:1
librealsense::rs430_device::rs430_device
rs430_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:410
librealsense::ds::RS455_PID
const uint16_t RS455_PID
Definition: d400-private.h:38
LOG_DEBUG
#define LOG_DEBUG(...)
Definition: easyloggingpp.h:70
librealsense::rs416_device::rs416_device
rs416_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:216
librealsense::rs405_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1317
from.h
librealsense::d400_info::create_device
std::shared_ptr< device_interface > create_device() override
Definition: d400-factory.cpp:1045
librealsense::rs410_device::rs410_device
rs410_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:136
RS2_STREAM_FISHEYE
@ RS2_STREAM_FISHEYE
Definition: rs_sensor.h:49
librealsense::rs415_device::rs415_device
rs415_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:175
table
GLenum GLenum GLsizei void * table
Definition: glad/glad/glad.h:3584
librealsense::stream_profile
Definition: core/stream-profile.h:15
librealsense::d400_nonmonochrome
Definition: d400-nonmonochrome.h:10
librealsense::platform::usb_spec
usb_spec
Definition: usb-types.h:112
librealsense::rs420_mm_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1219
librealsense::rs435_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:558
librealsense::ds::RS460_PID
const uint16_t RS460_PID
Definition: d400-private.h:30
librealsense::ds::d400_rgb_calibration_table
Definition: d400-private.h:244
x2
GLdouble GLdouble x2
Definition: glad/glad/glad.h:1781
librealsense::platform::backend_device_group
Definition: backend-device-group.h:50
device.h
RS2_STREAM_COLOR
@ RS2_STREAM_COLOR
Definition: rs_sensor.h:47
librealsense::ds::RS416_RGB_PID
const uint16_t RS416_RGB_PID
Definition: d400-private.h:36
RS2_FRAME_METADATA_FRAME_COUNTER
@ RS2_FRAME_METADATA_FRAME_COUNTER
Definition: rs_frame.h:31
librealsense::d400_active
Definition: d400-active.h:12
test-got-playback-frames.depth_height
depth_height
Definition: test-got-playback-frames.py:53
librealsense::environment::get_instance
static environment & get_instance()
Definition: environment.cpp:247
librealsense::rs405u_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:96
librealsense::ds_advanced_mode_base::HW_MONITOR_COMMAND_SIZE
static const uint16_t HW_MONITOR_COMMAND_SIZE
Definition: advanced_mode.h:149
librealsense::rs430_rgb_mm_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:635
rsutils::lazy::reset
void reset() const
Definition: lazy.h:64
LOG_WARNING
#define LOG_WARNING(...)
Definition: easyloggingpp.h:72
librealsense::d400_device::_hw_monitor
std::shared_ptr< hw_monitor > _hw_monitor
Definition: d400-device.h:94
librealsense::rs420_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:384
librealsense::d400_device::get_depth_sensor
synthetic_sensor & get_depth_sensor()
Definition: d400-device.h:37
RS2_FORMAT_Z16
@ RS2_FORMAT_Z16
Definition: rs_sensor.h:64
size
GLsizeiptr size
Definition: glad/glad/glad.h:2734
convert_to_bag.rec
rec
Definition: convert_to_bag.py:69
test-d405-calibration-stream.pid
pid
Definition: test-d405-calibration-stream.py:12
librealsense::rs430_mm_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1244
librealsense::rs405u_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1189
librealsense::rs435i_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1286
librealsense::platform::backend_device_group::usb_devices
std::vector< usb_device_info > usb_devices
Definition: backend-device-group.h:76
librealsense::ds::FRB
@ FRB
Definition: ds-private.h:86
librealsense::ds::RS416_PID
const uint16_t RS416_PID
Definition: d400-private.h:34
test-got-playback-frames.depth_width
depth_width
Definition: test-got-playback-frames.py:52
RS2_FORMAT_YUYV
@ RS2_FORMAT_YUYV
Definition: rs_sensor.h:67
librealsense::ds::rs400_sku_pid
static const std::set< std::uint16_t > rs400_sku_pid
Definition: d400-private.h:42
librealsense::ds::RS420_PID
const uint16_t RS420_PID
Definition: d400-private.h:25
librealsense::platform::mi_present
bool mi_present(const std::vector< uvc_device_info > &devices, uint32_t mi)
Definition: platform-utils.cpp:114
librealsense::rs430i_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1276
librealsense::rs435i_device::compress_while_record
bool compress_while_record() const override
Definition: d400-factory.cpp:703
uint32_t
unsigned int uint32_t
Definition: stdint.h:80
matcher-factory.h
librealsense::d400_device::_fw_version
firmware_version _fw_version
Definition: d400-device.h:95
librealsense::ds::RS410_PID
const uint16_t RS410_PID
Definition: d400-private.h:17
librealsense::matcher_factory::create
static std::shared_ptr< matcher > create(rs2_matchers matcher, std::vector< stream_interface * > const &profiles)
Definition: matcher-factory.cpp:14
RS2_STREAM_GYRO
@ RS2_STREAM_GYRO
Definition: rs_sensor.h:50
librealsense::rs410_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1195
librealsense::rs416_rgb_device
Definition: d400-factory.cpp:261
librealsense::ds::RS420_MM_PID
const uint16_t RS420_MM_PID
Definition: d400-private.h:26
librealsense::rs455_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:1019
d400-options.h
d400-color.h
i
int i
Definition: rs-pcl-color.cpp:54
librealsense::rs416_rgb_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:285
librealsense::ds::RS435_RGB_PID
const uint16_t RS435_RGB_PID
Definition: d400-private.h:31
librealsense::ds::d400_multi_sensors_pid
static const std::set< std::uint16_t > d400_multi_sensors_pid
Definition: d400-private.h:67
librealsense::device::get_format_conversion
format_conversion get_format_conversion() const
Definition: device.cpp:200
librealsense::ds::CAL_RESTORE_DFLT
@ CAL_RESTORE_DFLT
Definition: ds-private.h:111
g
GLboolean GLboolean g
Definition: glad/glad/glad.h:3064
librealsense::ds::d400_try_fetch_usb_device
bool d400_try_fetch_usb_device(std::vector< platform::usb_device_info > &devices, const platform::uvc_device_info &info, platform::usb_device_info &result)
Definition: d400-private.cpp:13
j
GLint j
Definition: glad/glad/glad.h:2165
librealsense::ds::RS_USB2_PID
const uint16_t RS_USB2_PID
Definition: d400-private.h:21
librealsense::rs430_rgb_mm_device::rs430_rgb_mm_device
rs430_rgb_mm_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:620
librealsense::rs405_device::rs405_device
rs405_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:912
librealsense::ds::SETINTCALNEW
@ SETINTCALNEW
Definition: ds-private.h:112
librealsense::frame_holder
Definition: frame-holder.h:15
librealsense::ds5u_device
Definition: d400-device.h:120
rsutils::number::float3x3
Definition: third-party/rsutils/include/rsutils/number/float3.h:57
librealsense::rs405u_device::rs405u_device
rs405u_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:85
librealsense::features_container::register_feature
void register_feature(std::shared_ptr< feature_interface > feature)
Definition: features-container.h:38
librealsense::rs405u_device::contradicts
bool contradicts(const stream_profile_interface *a, const std::vector< stream_profile > &others) const override
Definition: d400-factory.cpp:115
librealsense::rs435_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1257
RS2_STREAM_DEPTH
@ RS2_STREAM_DEPTH
Definition: rs_sensor.h:46
d400-info.h
librealsense::firmware_version
rsutils::version firmware_version
Definition: src/firmware-version.h:11
librealsense::rs405u_device
Definition: d400-factory.cpp:80
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glad/glad/glad.h:3064
librealsense::ds::RS435I_PID
const uint16_t RS435I_PID
Definition: d400-private.h:33
librealsense::rs410_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:150
librealsense::rs430_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1238
librealsense::ds::RS405U_PID
const uint16_t RS405U_PID
Definition: d400-private.h:32
librealsense::rs415_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:190
librealsense::d400_color::_color_stream
std::shared_ptr< stream_interface > _color_stream
Definition: d400-color.h:36
librealsense::environment::get_extrinsics_graph
extrinsics_graph & get_extrinsics_graph()
Definition: environment.cpp:253
d400-thermal-monitor.h
librealsense::rs430_mm_device
Definition: d400-factory.cpp:487
image.h
librealsense::rs420_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1232
librealsense::d400_motion_uvc
Definition: d400-motion.h:72
librealsense::rs435i_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:683
librealsense::rs435i_device::assign_rgb_stream_extrinsic
void assign_rgb_stream_extrinsic(const std::vector< uint8_t > &calib)
Definition: d400-factory.cpp:799
librealsense::platform::backend_device_group::hid_devices
std::vector< hid_device_info > hid_devices
Definition: backend-device-group.h:77
librealsense::rs400_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:59
librealsense::d400_device::get_firmware_logs_command
command get_firmware_logs_command() const
Definition: d400-device.cpp:1230
fps
Definition: fps.py:1
librealsense::ds::RS400_IMU_PID
const uint16_t RS400_IMU_PID
Definition: d400-private.h:24
librealsense::rs420_mm_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:337
librealsense::rs405_device::compress_while_record
bool compress_while_record() const override
Definition: d400-factory.cpp:962
librealsense::platform::trim_device_list
void trim_device_list(std::vector< usb_device_info > &devices, const std::vector< usb_device_info > &chosen)
Definition: platform-utils.cpp:90
librealsense::frame
Definition: frame.h:19
fps.info
info
Definition: fps.py:50
librealsense::rs430i_device
Definition: d400-factory.cpp:443
librealsense::platform::backend_device_group::uvc_devices
std::vector< uvc_device_info > uvc_devices
Definition: backend-device-group.h:75
librealsense::rs415_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1201
d400-nonmonochrome.h
librealsense::d400_motion
Definition: d400-motion.h:42
librealsense::rs455_device::rs455_device
rs455_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:999
RS2_MATCHER_DEFAULT
@ RS2_MATCHER_DEFAULT
Definition: rs_types.h:218
librealsense::rs400_imu_device
Definition: d400-factory.cpp:877
librealsense::video_stream_profile_interface
Definition: video.h:17
librealsense::rs400_imu_device::rs400_imu_device
rs400_imu_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:882
librealsense::firmware_logger_device
Definition: firmware_logger_device.h:27
librealsense::d400_color
Definition: d400-color.h:17
librealsense::platform::usb_undefined
@ usb_undefined
Definition: usb-types.h:113
test-color_frame_frops.fps
int fps
Definition: test-color_frame_frops.py:16
librealsense::ds::RS405_PID
const uint16_t RS405_PID
Definition: d400-private.h:37
librealsense::rs435i_device::read_sector
std::vector< uint8_t > read_sector(const uint32_t address, const uint16_t size) const
Definition: d400-factory.cpp:807
librealsense::rs400_imu_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:895
librealsense::rs416_rgb_device::rs416_rgb_device
rs416_rgb_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:270
rsutils::string::from
Definition: from.h:19
RS2_STREAM_ACCEL
@ RS2_STREAM_ACCEL
Definition: rs_sensor.h:51
auto-exposure-limit-feature.h
librealsense::rs435i_device::is_rgb_extrinsic_valid
bool is_rgb_extrinsic_valid(const std::vector< uint8_t > &raw_data) const
Definition: d400-factory.cpp:729
gain-limit-feature.h
test-got-playback-frames.color_height
color_height
Definition: test-got-playback-frames.py:13
librealsense::platform::usb3_type
@ usb3_type
Definition: usb-types.h:119
test-fps.ds
ds
Definition: test-fps.py:77
RS2_FORMAT_Y16
@ RS2_FORMAT_Y16
Definition: rs_sensor.h:73
d400-active.h
librealsense::rs435i_device::restore_rgb_extrinsic
void restore_rgb_extrinsic(void)
Definition: d400-factory.cpp:830
librealsense::format_conversion::raw
@ raw
librealsense::ds_advanced_mode_base
Definition: advanced_mode.h:101
RS2_FORMAT_MOTION_XYZ32F
@ RS2_FORMAT_MOTION_XYZ32F
Definition: rs_sensor.h:79
librealsense::rs457_device
Definition: d400-factory.cpp:579
librealsense::platform::group_devices_and_hids_by_unique_id
std::vector< std::pair< std::vector< uvc_device_info >, std::vector< hid_device_info > > > group_devices_and_hids_by_unique_id(const std::vector< std::vector< uvc_device_info > > &devices, const std::vector< hid_device_info > &hids)
Definition: platform-utils.cpp:41
librealsense::rs457_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:601
librealsense::d400_info::pick_d400_devices
static std::vector< std::shared_ptr< d400_info > > pick_d400_devices(std::shared_ptr< context > ctx, platform::backend_device_group &gproup)
Definition: d400-factory.cpp:1103
librealsense::extrinsics_graph::register_extrinsics
void register_extrinsics(const stream_interface &from, const stream_interface &to, std::weak_ptr< rsutils::lazy< rs2_extrinsics > > extr)
Definition: environment.cpp:50
librealsense::frame::frame
frame()
Definition: frame.h:26
RS2_FORMAT_Y8
@ RS2_FORMAT_Y8
Definition: rs_sensor.h:72
librealsense::d400_color::_color_extrinsic
std::shared_ptr< rsutils::lazy< rs2_extrinsics > > _color_extrinsic
Definition: d400-color.h:59
librealsense::rs430_rgb_mm_device
Definition: d400-factory.cpp:613
librealsense::rs457_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1297
librealsense::rs420_mm_device::rs420_mm_device
rs420_mm_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:324
librealsense::rs416_rgb_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1213
librealsense::backend_device
Definition: backend-device.h:20
test-projection-from-recording.ctx
ctx
Definition: test-projection-from-recording.py:16
RS2_STREAM_INFRARED
@ RS2_STREAM_INFRARED
Definition: rs_sensor.h:48
librealsense::platform::platform_device_info::_group
platform::backend_device_group _group
Definition: platform-device-info.h:27
librealsense::rs455_device
Definition: d400-factory.cpp:990
librealsense::ds::RS430_PID
const uint16_t RS430_PID
Definition: d400-private.h:19
librealsense::ds::RS430_MM_RGB_PID
const uint16_t RS430_MM_RGB_PID
Definition: d400-private.h:29
librealsense::rs405_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:926
librealsense::rs430i_device::rs430i_device
rs430i_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:449
librealsense::rs430i_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:461
end
GLuint GLuint end
Definition: glad/glad/glad.h:2395
librealsense::rs400_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1183
it
static auto it
Definition: openvino-face-detection.cpp:375
RS2_MATCHER_DLR_C
@ RS2_MATCHER_DLR_C
Definition: rs_types.h:205
librealsense::ds::d400_hid_sensors_pid
static const std::set< std::uint16_t > d400_hid_sensors_pid
Definition: d400-private.h:80
librealsense::ds::RS400_PID
const uint16_t RS400_PID
Definition: d400-private.h:16
librealsense::rs420_device::rs420_device
rs420_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:372
gyro-sensitivity-feature.h
librealsense::ds::RS430I_PID
const uint16_t RS430I_PID
Definition: d400-private.h:35
librealsense::rs435i_device
Definition: d400-factory.cpp:656
librealsense::rs416_rgb_device::contradicts
bool contradicts(const stream_profile_interface *a, const std::vector< stream_profile > &others) const override
Definition: d400-factory.cpp:304
librealsense::device
Definition: device.h:35
librealsense::rs435i_device::restore_calib_factory_settings
std::vector< uint8_t > restore_calib_factory_settings() const
Definition: d400-factory.cpp:824
ds-timestamp.h
librealsense::rs416_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1207
librealsense::d400_device::get_usb_spec
platform::usb_spec get_usb_spec() const
Definition: d400-device.cpp:1194
librealsense::rs455_device::create_matcher
std::shared_ptr< matcher > create_matcher(const frame_holder &frame) const override
Definition: d400-factory.cpp:1323
librealsense::rs420_device
Definition: d400-factory.cpp:367
librealsense::rs416_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:230
rsutils::number::float3
Definition: third-party/rsutils/include/rsutils/number/float3.h:35
librealsense::ds::RS430_MM_PID
const uint16_t RS430_MM_PID
Definition: d400-private.h:20
firmware_logger_device.h
librealsense::platform::group_devices_by_unique_id
std::vector< std::vector< uvc_device_info > > group_devices_by_unique_id(const std::vector< uvc_device_info > &devices)
Definition: platform-utils.cpp:73
librealsense::rs416_device
Definition: d400-factory.cpp:210
librealsense::d400_color::_color_calib_table_raw
rsutils::lazy< std::vector< uint8_t > > _color_calib_table_raw
Definition: d400-color.h:58
librealsense::rs415_device
Definition: d400-factory.cpp:168
metadata-parser.h
librealsense::PROFILE_TAG_DEFAULT
@ PROFILE_TAG_DEFAULT
Definition: tagged-profile.h:15
librealsense::rs410_device
Definition: d400-factory.cpp:130
librealsense::command
Definition: hw-monitor.h:247
librealsense::rs430_mm_device::get_profiles_tags
std::vector< tagged_profile > get_profiles_tags() const override
Definition: d400-factory.cpp:507
librealsense::rs430_mm_device::rs430_mm_device
rs430_mm_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:493
librealsense::d400_motion::get_motion_sensor
ds_motion_sensor & get_motion_sensor()
Definition: d400-motion.cpp:143
librealsense::rs435_device::rs435_device
rs435_device(std::shared_ptr< const d400_info > const &dev_info, bool register_device_notifications)
Definition: d400-factory.cpp:544
librealsense::platform::usb_device_info
Definition: usb-types.h:146
LOG_ERROR
#define LOG_ERROR(...)
Definition: easyloggingpp.h:73
librealsense::d400_device
Definition: d400-device.h:26

librealsense2
Author(s): LibRealSense ROS Team
autogenerated on Fri Aug 2 2024 08:30:02