l500-private.h
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2018 Intel Corporation. All Rights Reserved.
3 
4 #pragma once
5 
6 #include "backend.h"
7 #include "types.h"
8 #include "option.h"
9 #include "core/extension.h"
11 
12 static const int MAX_NUM_OF_RGB_RESOLUTIONS = 5;
13 static const int MAX_NUM_OF_DEPTH_RESOLUTIONS = 5;
14 
15 namespace librealsense
16 {
17  const uint16_t L500_RECOVERY_PID = 0x0b55;
18  const uint16_t L535_RECOVERY_PID = 0x0B72;
19  const uint16_t L500_USB2_RECOVERY_PID_OLD = 0x0adc; // Units with old DFU_PAYLAOD on USB2 report ds5 PID (RS_USB2_RECOVERY_PID)
20  const uint16_t L500_PID = 0x0b0d;
21  const uint16_t L515_PID_PRE_PRQ = 0x0b3d;
22  const uint16_t L515_PID = 0x0b64;
23  const uint16_t L535_PID = 0x0b68;
24 
25  class l500_device;
26 
27  namespace ivcam2
28  {
29  // L500 depth XU identifiers
31  const uint8_t L500_DIGITAL_GAIN = 2; // Renamed from L500_AMBIENT
33 
34  const uint32_t FLASH_SIZE = 0x00200000;
35  const uint32_t FLASH_SECTOR_SIZE = 0x1000;
36 
39  const uint32_t FLASH_INFO_HEADER_OFFSET = 0x001FFF00;
40 
41  flash_info get_flash_info(const std::vector<uint8_t>& flash_buffer);
42 
44  { 0xC9606CCB, 0x594C, 0x4D25,{ 0xaf, 0x47, 0xcc, 0xc4, 0x96, 0x43, 0x59, 0x95 } } };
45 
46  const int REGISTER_CLOCK_0 = 0x9003021c;
47 
48  const uint16_t L515_IMU_TABLE = 0x0243; // IMU calibration table on L515
49 
50  enum fw_cmd : uint8_t
51  {
52  IRB = 0x03, //"Read from i2c ( 8x8 )"
53  MRD = 0x01, //"Read Tensilica memory ( 32bit ). Output : 32bit dump"
54  FRB = 0x09, //"Read from flash"
55  FWB = 0x0A, //"Write to flash"
56  FES = 0x0B, //"Erase flash sector"
57  FEF = 0x0C, //"Erase flash full"
58  GLD = 0x0F, //"LoggerCoreGetDataParams"
59  GVD = 0x10, //"Get Version and Date"
60  DFU = 0x1E, //"Go to DFU"
61  HW_SYNC_EX_TRIGGER = 0x19, // Enable (not default) HW sync; will disable freefall
62  HW_RESET = 0x20, //"HW Reset"
63  AMCSET = 0x2B, // Set options (L515)
64  AMCGET = 0x2C, // Get options (L515)
65  DELETE_TABLE = 0x2E,
66  TPROC_TRB_THRSLD_SET = 0x35, // TPROC TRB threshold
67  TPROC_USB_GRAN_SET = 0x36, // TPROC USB granularity
68  PFD = 0x3B, // Disable power features <Parameter1 Name="0 - Disable, 1 - Enable" />
69  READ_TABLE = 0x43, // read table from flash, for example, read imu calibration table, read_table 0x243 0
70  WRITE_TABLE = 0x44,
76  FALL_DETECT_ENABLE = 0x9D, // Enable (by default) free-fall sensor shutoff (0=disable; 1=enable)
77  GET_SPECIAL_FRAME = 0xA0, // Request auto-calibration (0) special frames (#)
78  UNIT_AGE_SET = 0x5B // Sets the age of the unit in weeks
79  };
80 
81 #pragma pack(push, 1)
82  // Table header returned by READ_TABLE before the actual table data
83  struct table_header
84  {
88  uint32_t table_size; // full size including: TOC header + TOC + actual tables
89  uint32_t reserved; // 0xFFFFFFFF
90  uint32_t crc32; // crc of all the actual table data excluding header/CRC
91  };
92 #pragma pack(pop)
93 
94  static std::vector< byte >
95  read_fw_table_raw( const hw_monitor & hwm, int table_id, hwmon_response & response )
96  {
97  std::vector< byte > res;
98  command cmd( fw_cmd::READ_TABLE, table_id );
99  auto data = hwm.send( cmd, &response );
100 
101  res.assign( data.data(), data.data() + data.size() );
102 
103  return res;
104  }
105 
106  // Read a table from firmware and, if FW says the table is empty, optionally initialize it
107  // using your own code...
108  template< typename T >
110  int table_id, T * ptable,
111  table_header * pheader = nullptr,
112  std::function< void() > init = nullptr )
113  {
114  hwmon_response response;
115  std::vector< byte > data = read_fw_table_raw( hwm, table_id, response );
116  size_t expected_size = sizeof( table_header ) + sizeof( T );
117  switch( response )
118  {
119  case hwm_Success:
120  if( data.size() != expected_size )
121  throw std::runtime_error( to_string()
122  << "READ_TABLE (0x" << std::hex << table_id
123  << std::dec << ") data size received= " << data.size()
124  << " (expected " << expected_size << ")" );
125  if( pheader )
126  *pheader = *(table_header *)data.data();
127  if( ptable )
128  *ptable = *(T *)(data.data() + sizeof( table_header ));
129  break;
130 
131  case hwm_TableIsEmpty:
132  if( init )
133  {
134  // Initialize a new table
135  init();
136  break;
137  }
138  // fall-thru!
139 
140  default:
141  LOG_DEBUG( "Failed to read FW table 0x" << std::hex << table_id );
142  command cmd( fw_cmd::READ_TABLE, table_id );
143  throw invalid_value_exception( hwmon_error_string( cmd, response ) );
144  }
145  }
146 
147  // Write a table to firmware
148  template< typename T >
149  void write_fw_table( hw_monitor& hwm, uint16_t const table_id, T const & table, uint16_t const version = 0x0100 )
150  {
152  cmd.data.resize( sizeof( table_header ) + sizeof( table ) );
153 
154  table_header * h = (table_header *)cmd.data.data();
155  h->major = version >> 8;
156  h->minor = version & 0xFF;
157  h->table_id = table_id;
158  h->table_size = sizeof( T );
159  h->reserved = 0xFFFFFFFF;
160  h->crc32 = calc_crc32( (byte *)&table, sizeof( table ) );
161 
162  memcpy( cmd.data.data() + sizeof( table_header ), &table, sizeof( table ) );
163 
164  hwmon_response response;
165  hwm.send( cmd, &response );
166  switch( response )
167  {
168  case hwm_Success:
169  break;
170 
171  default:
172  LOG_DEBUG( "Failed to write FW table 0x" << std::hex << table_id << " " << sizeof( table ) << " bytes: " );
173  throw invalid_value_exception( to_string() << "Failed to write FW table 0x" << std::hex << table_id << ": " << hwmon_error_string( cmd, response ));
174  }
175  }
176 
177  template< typename T >
178  void read_fw_register(hw_monitor& hwm, T * preg, int const baseline_address )
179  {
180  command cmd( ivcam2::fw_cmd::MRD, baseline_address, baseline_address + sizeof( T ) );
181  auto res = hwm.send( cmd );
182  if( res.size() != sizeof( T ) )
183  throw std::runtime_error( to_string()
184  << "MRD data size received= " << res.size()
185  << " (expected " << sizeof( T ) << ")" );
186  if( preg )
187  *preg = *(T *)res.data();
188  }
189 
190 #pragma pack(push, 1)
191  struct ac_depth_results // aka "Algo_AutoCalibration" in FW
192  {
193  static const int table_id = 0x240;
194  static const uint16_t this_version = (RS2_API_MAJOR_VERSION << 12 | RS2_API_MINOR_VERSION << 4 | RS2_API_PATCH_VERSION);
195 
197 
199  ac_depth_results( rs2_dsm_params const & dsm_params ) : params( dsm_params ) {}
200  };
201 
203  {
204  static const uint16_t table_id = 0x310; // in flash
205  static const uint16_t eeprom_table_id = 0x10; // factory calibration - read-only
206 
214  struct /*intrinsics*/
215  {
216  float fx; // focal length in X, normalize by [-1 1]
217  float fy; // focal length in Y, normalize by [-1 1]
218  float px; // Principal point in x, normalize by [-1 1]
219  float py; // Principal point in x, normalize by [-1 1]
220  float sheer;
221  float d[5]; // RGB forward distortion parameters (k1, k2, p1, p2, k3), brown model
222  } intr;
225 
226  void set_intrinsics( rs2_intrinsics const & );
227  rs2_intrinsics get_intrinsics() const;
228  rs2_extrinsics const & get_extrinsics() const { return extr; }
229  void update_write_fields();
230  };
231 #pragma pack(pop)
232 
233  // <Command Name="GVD" Opcode="0x10" Description="Get Version and Date">
234  // See CommandsIVCAM2.xml for complete up-to-date fields
236  {
237  is_camera_locked_offset = 6, // "eyeSafety": encompasses eeprom, flash, & registers
238  fw_version_offset = 12, // "FunctionalPayloadVersion"
239  module_serial_offset = 60, // "OpticalHeadModuleSN" -> RS2_CAMERA_INFO_SERIAL_NUMBER
240  module_asic_serial_offset = 74 // "AsicModuleSerial" -> RS2_CAMERA_INFO_ASIC_SERIAL_NUMBER & RS2_CAMERA_INFO_FIRMWARE_UPDATE_ID
241  };
242 
244  {
245  // Keep sorted
248  };
249 
250  static const std::map<std::uint16_t, std::string> rs500_sku_names = {
251  { L500_RECOVERY_PID, "Intel RealSense L5xx Recovery"},
252  { L535_RECOVERY_PID, "Intel RealSense L5xx Recovery"},
253  { L500_USB2_RECOVERY_PID_OLD, "Intel RealSense L5xx Recovery"},
254  { L500_PID, "Intel RealSense L500"},
255  { L515_PID_PRE_PRQ, "Intel RealSense L515 (pre-PRQ)"},
256  { L515_PID, "Intel RealSense L515"},
257  { L535_PID, "Intel RealSense L535"},
258 
259  };
260 
261  // Known FW error codes, if we poll for errors (RS2_OPTION_ERROR_POLLING_ENABLED)
263  {
264  success = 0,
275  ld_alarm = 14,
286  };
287 
288  // Each of the above is mapped to a string -- but only for those we identify as errors: warnings are
289  // listed below as comments and are treated as unknown warnings...
290  // NOTE: a unit-test in func/hw-errors/ directly uses this map and tests it
291  const std::map< uint8_t, std::string > l500_fw_error_report = {
292  { success, "Success" },
293  { depth_not_available, "Fatal error occur and device is unable \nto run depth stream" },
294  { overflow_infrared, "Overflow occur on infrared stream" },
295  { overflow_depth, "Overflow occur on depth stream" },
296  { overflow_confidence, "Overflow occur on confidence stream" },
297  { depth_stream_hard_error, "Receiver light saturation, stream stopped for 1 sec" },
298  { depth_stream_soft_error, "Error that may be overcome in few sec. \nStream stoped. May be recoverable" },
299  { temp_warning, "Warning, temperature close to critical" },
300  { temp_critical, "Critical temperature reached" },
301  { DFU_error, "DFU error" },
302  //{10 , "L500 HW report - unresolved type 10"},
303  //{11 , "L500 HW report - unresolved type 11"},
304  { fall_detected, "Fall detected stream stopped" },
305  //{13 , "L500 HW report - unresolved type 13"},
306  { ld_alarm, "Fatal error occurred (14)" },
307  { hard_error, "Fatal error occurred (15)" },
308  { ld_alarm_hard_error, "Fatal error occurred (16)" },
309  { pzr_vbias_exceed_limit, "Fatal error occurred (17)" },
310  { eye_safety_general_critical_error, "Fatal error occurred (18)" },
311  { eye_safety_stuck_at_ld_error, "Fatal error occurred (19)" },
312  { eye_safety_stuck_at_mode_sign_error, "Fatal error occurred (20)" },
313  { eye_safety_stuck_at_vbst_error, "Fatal error occurred (21)" },
314  { eye_safety_stuck_at_msafe_error, "Fatal error occurred (22)" },
315  { eye_safety_stuck_at_ldd_snubber_error, "Fatal error occurred (23)" },
316  { eye_safety_stuck_at_flash_otp_error, "Fatal error occurred (24)" }
317  };
318 
319 #pragma pack(push, 1)
321  {
324  };
325 
326  struct distortion
327  {
328  float radial_k1;
329  float radial_k2;
332  float radial_k3;
333  };
334 
336  {
341  };
342 
344  {
345  pinhole_camera_model pinhole_cam_model; //(Same as standard intrinsic)
347  float znorm;
348  };
349 
351  {
354  };
355 
357  {
361  intrinsic_per_resolution intrinsic_resolution[MAX_NUM_OF_DEPTH_RESOLUTIONS]; //Dynamic number of entries according to num of resolutions
362  };
363 
364  struct orientation
365  {
371  };
372 
374  {
377  };
378 
380  {
384  pinhole_camera_model intrinsic_resolution[MAX_NUM_OF_RGB_RESOLUTIONS]; //Dynamic number of entries according to num of resolutions
385  };
386 
387  struct rgb_common
388  {
389  float sheer;
391  };
392 
394  {
397  };
398 
399  struct temperatures {
400  double LDD_temperature; // Laser Diode Driver
406 
408  : LDD_temperature(0.)
409  , MC_temperature(0.)
410  , MA_temperature(0.)
411  , APD_temperature(0.)
412  , HUM_temperature(0.)
413  , AlgoTermalLddAvg_temperature(0.) { }
414  };
415 
416  //FW versions >= 1.5.0.0 added to the response vector the nest AVG value
418  {
419  double nest_avg; // NEST = Noise Estimation
420 
421  extended_temperatures() : temperatures(), nest_avg(.0) {}
422  };
423 #pragma pack( pop )
424 
425  rs2_extrinsics get_color_stream_extrinsic(const std::vector<uint8_t>& raw_data);
426 
427  bool try_fetch_usb_device(std::vector<platform::usb_device_info>& devices,
429 
431  {
432  public:
433  float query() const override;
434 
435  option_range get_range() const override { return option_range{ 0, 100, 0, 0 }; }
436 
437  bool is_enabled() const override { return true; }
438 
439  const char * get_description() const override { return _description.c_str(); }
440 
441  explicit l500_temperature_options(l500_device *l500_depth_dev,
442  rs2_option opt,
443  const std::string& description );
444 
445  private:
449  };
450 
451  // Noise estimation option
453  {
454  public:
455  float query() const override;
456 
457  option_range get_range() const override { return option_range{ 0, 4100, 0, 0 }; }
458 
459  bool is_enabled() const override { return true; }
460 
461  const char * get_description() const override { return _description.c_str(); }
462 
463  explicit nest_option(l500_device * l500_depth_dev, const std::string & description)
464  : _l500_depth_dev(l500_depth_dev)
465  , _description(description) {};
466 
467  private:
470  };
471 
473  {
474  static const int pins = 3;
475  mutable std::vector<size_t> counter;
476  std::shared_ptr<platform::time_service> _ts;
477  mutable std::recursive_mutex _mtx;
478  public:
479  l500_timestamp_reader(std::shared_ptr<platform::time_service> ts)
480  : counter(pins), _ts(ts)
481  {
482  reset();
483  }
484 
485  void reset() override
486  {
487  std::lock_guard<std::recursive_mutex> lock(_mtx);
488  for (size_t i = 0; i < pins; ++i)
489  {
490  counter[i] = 0;
491  }
492  }
493 
494  rs2_time_t get_frame_timestamp(const std::shared_ptr<frame_interface>&) override
495  {
496  std::lock_guard<std::recursive_mutex> lock(_mtx);
497  return _ts->get_time();
498  }
499 
500  unsigned long long get_frame_counter(const std::shared_ptr<frame_interface>& frame) const override
501  {
502  std::lock_guard<std::recursive_mutex> lock(_mtx);
503  size_t pin_index = 0;
504  if (frame->get_stream()->get_format() == RS2_FORMAT_Z16)
505  pin_index = 1;
506  else if (frame->get_stream()->get_stream_type() == RS2_STREAM_CONFIDENCE)
507  pin_index = 2;
508 
509  return ++counter[pin_index];
510  }
511 
512  rs2_timestamp_domain get_frame_timestamp_domain(const std::shared_ptr<frame_interface>&) const override
513  {
515  }
516  };
517 
519  {
520  std::unique_ptr<l500_timestamp_reader> _backup_timestamp_reader;
522  mutable std::recursive_mutex _mtx;
524 
525  protected:
526 
527  bool has_metadata_ts(const std::shared_ptr<frame_interface>& frame) const
528  {
529  // Metadata support for a specific stream is immutable
530  auto f = std::dynamic_pointer_cast<librealsense::frame>(frame);
531  const bool has_md_ts = [&] { std::lock_guard<std::recursive_mutex> lock(_mtx);
532  return ((f->additional_data.metadata_size >= platform::uvc_header_size) && ((byte*)f->additional_data.metadata_blob.data())[0] >= platform::uvc_header_size);
533  }();
534 
535  return has_md_ts;
536  }
537 
538  bool has_metadata_fc(const std::shared_ptr<frame_interface>& frame) const
539  {
540  // Metadata support for a specific stream is immutable
541  auto f = std::dynamic_pointer_cast<librealsense::frame>(frame);
542  const bool has_md_frame_counter = [&] { std::lock_guard<std::recursive_mutex> lock(_mtx);
543  return ((f->additional_data.metadata_size > platform::uvc_header_size) && ((byte*)f->additional_data.metadata_blob.data())[0] > platform::uvc_header_size);
544  }();
545 
546  return has_md_frame_counter;
547  }
548 
549  public:
550  l500_timestamp_reader_from_metadata(std::shared_ptr<platform::time_service> ts) :_backup_timestamp_reader(nullptr), one_time_note(false)
551  {
552  _backup_timestamp_reader = std::unique_ptr<l500_timestamp_reader>(new l500_timestamp_reader(ts));
553  reset();
554  }
555 
556  rs2_time_t get_frame_timestamp(const std::shared_ptr<frame_interface>& frame) override;
557 
558  unsigned long long get_frame_counter(const std::shared_ptr<frame_interface>& frame) const override;
559 
560  void reset() override;
561 
562  rs2_timestamp_domain get_frame_timestamp_domain(const std::shared_ptr<frame_interface>& frame) const override;
563  };
564 
565  /* For RS2_OPTION_FREEFALL_DETECTION_ENABLED */
567  {
568  public:
569  freefall_option( hw_monitor& hwm, bool enabled = true );
570 
571  bool is_enabled() const override { return _enabled; }
572  virtual void enable( bool = true );
573 
574  virtual void set( float value ) override;
575  virtual const char * get_description() const override
576  {
577  return "When enabled (default), the sensor will turn off if a free-fall is detected";
578  }
579  virtual void enable_recording( std::function<void( const option& )> record_action ) override { _record_action = record_action; }
580 
581  private:
582  std::function<void( const option& )> _record_action = []( const option& ) {};
584  bool _enabled;
585  };
586 
587  /* For RS2_OPTION_INTER_CAM_SYNC_MODE
588  Not an advanced control: always off after camera startup (reset).
589  When enabled, the freefall control should turn off.
590  */
592  {
593  public:
594  hw_sync_option( hw_monitor& hwm, std::shared_ptr< freefall_option > freefall_opt );
595 
596  virtual void set( float value ) override;
597  virtual const char* get_description() const override
598  {
599  return "Enable multi-camera hardware synchronization mode (disabled on startup); not compatible with free-fall detection";
600  }
601  virtual void enable_recording( std::function<void( const option& )> record_action ) override { _record_action = record_action; }
602 
603  private:
604  std::function<void( const option& )> _record_action = []( const option& ) {};
606  std::shared_ptr< freefall_option > _freefall_opt;
607  };
608 
610 
611  // Helper function that should be used when multiple FW calls needs to be made.
612  // This function change the USB power to D0 (Operational) using the invoke_power function
613  // activate the received function and power down the state to D3 (Idle)
614  template<class T>
616  -> decltype(action())
617  {
618  auto &us = dynamic_cast<uvc_sensor&>(*s.get_raw_sensor());
619 
620  return us.invoke_powered([&](platform::uvc_device& dev) { return action(); });
621  }
622 
623  class ac_trigger;
624  } // librealsense::ivcam2
625 } // namespace librealsense
virtual void enable_recording(std::function< void(const option &)> record_action) override
Definition: l500-private.h:579
rs2_sensor_mode get_resolution_from_width_height(int width, int height)
static const textual_icon lock
Definition: model-views.h:218
const uint8_t L500_ERROR_REPORTING
Definition: l500-private.h:32
rs2_time_t get_frame_timestamp(const std::shared_ptr< frame_interface > &) override
Definition: l500-private.h:494
static const std::map< std::uint16_t, std::string > rs500_sku_names
Definition: l500-private.h:250
nest_option(l500_device *l500_depth_dev, const std::string &description)
Definition: l500-private.h:463
const uint32_t FLASH_RW_TABLE_OF_CONTENT_OFFSET
Definition: l500-private.h:37
#define RS2_API_MAJOR_VERSION
Definition: rs.h:25
auto invoke_powered(T action) -> decltype(action(*static_cast< platform::uvc_device * >(nullptr)))
Definition: sensor.h:343
std::shared_ptr< freefall_option > _freefall_opt
Definition: l500-private.h:606
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls...
Definition: rs_option.h:22
GLdouble s
unsigned long long get_frame_counter(const std::shared_ptr< frame_interface > &frame) const override
Definition: l500-private.h:500
GLboolean reset
constexpr uint8_t uvc_header_size
Definition: backend.h:165
Video DSM (Digital Sync Module) parameters for calibration (same layout as in FW ac_depth_params) Thi...
Definition: rs_types.h:74
GLfloat value
const uint8_t L500_DIGITAL_GAIN
Definition: l500-private.h:31
bool try_fetch_usb_device(std::vector< platform::usb_device_info > &devices, const platform::uvc_device_info &info, platform::usb_device_info &result)
const uint32_t FLASH_SIZE
Definition: l500-private.h:34
unsigned short uint16_t
Definition: stdint.h:79
GLsizei const GLchar *const * string
d
Definition: rmse.py:171
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:1960
unsigned char uint8_t
Definition: stdint.h:78
#define RS2_API_MINOR_VERSION
Definition: rs.h:26
virtual const char * get_description() const override
Definition: l500-private.h:597
#define RS2_API_PATCH_VERSION
Definition: rs.h:27
const uint32_t FLASH_RO_TABLE_OF_CONTENT_OFFSET
Definition: l500-private.h:38
def info(name, value, persistent=False)
Definition: test.py:301
GLdouble f
virtual const char * get_description() const override
Definition: l500-private.h:575
bool is_enabled() const override
Definition: l500-private.h:459
const uint32_t FLASH_SECTOR_SIZE
Definition: l500-private.h:35
std::vector< uint8_t > send(std::vector< uint8_t > const &data) const
Definition: hw-monitor.cpp:115
unsigned int uint32_t
Definition: stdint.h:80
devices
Definition: test-fg.py:9
const std::map< uint8_t, std::string > l500_fw_error_report
Definition: l500-private.h:291
rs2_timestamp_domain get_frame_timestamp_domain(const std::shared_ptr< frame_interface > &) const override
Definition: l500-private.h:512
GLint GLsizei GLsizei height
const uint16_t L535_RECOVERY_PID
Definition: l500-private.h:18
std::vector< uint8_t > data
Definition: hw-monitor.h:240
static std::vector< byte > read_fw_table_raw(const hw_monitor &hwm, int table_id, hwmon_response &response)
Definition: l500-private.h:95
GLenum GLenum GLsizei const GLuint GLboolean enabled
void init(void)
Definition: boing.c:180
flash_info get_flash_info(const std::vector< uint8_t > &flash_buffer)
void write_fw_table(hw_monitor &hwm, uint16_t const table_id, T const &table, uint16_t const version=0x0100)
Definition: l500-private.h:149
l500_timestamp_reader(std::shared_ptr< platform::time_service > ts)
Definition: l500-private.h:479
const uint8_t L500_HWMONITOR
Definition: l500-private.h:30
std::string hwmon_error_string(command const &cmd, hwmon_response e)
Definition: hw-monitor.cpp:177
const char * get_description() const override
Definition: l500-private.h:461
const uint16_t L515_IMU_TABLE
Definition: l500-private.h:48
action
Definition: enums.py:62
std::unique_ptr< l500_timestamp_reader > _backup_timestamp_reader
Definition: l500-private.h:520
arithmetic_wraparound< uint32_t, uint64_t > ts_wrap
Definition: l500-private.h:523
option_range get_range() const override
Definition: l500-private.h:435
rs2_sensor_mode
For setting the camera_mode option.
Definition: rs_option.h:165
GLenum GLenum GLsizei void * table
Cross-stream extrinsics: encodes the topology describing how the different devices are oriented...
Definition: rs_sensor.h:96
const uint16_t L500_USB2_RECOVERY_PID_OLD
Definition: l500-private.h:19
unsigned char byte
Definition: src/types.h:52
const uint32_t FLASH_INFO_HEADER_OFFSET
Definition: l500-private.h:39
GLboolean enable
Definition: glext.h:5688
ac_depth_results(rs2_dsm_params const &dsm_params)
Definition: l500-private.h:199
GLenum query
bool has_metadata_ts(const std::shared_ptr< frame_interface > &frame) const
Definition: l500-private.h:527
virtual void enable_recording(std::function< void(const option &)> record_action) override
Definition: l500-private.h:601
rs2_extrinsics extr
Definition: test-pose.cpp:258
static const int MAX_NUM_OF_RGB_RESOLUTIONS
Definition: l500-private.h:12
const char * get_description() const override
Definition: l500-private.h:439
l500_timestamp_reader_from_metadata(std::shared_ptr< platform::time_service > ts)
Definition: l500-private.h:550
Video stream intrinsics.
Definition: rs_types.h:58
const uint16_t L515_PID
Definition: l500-private.h:22
std::shared_ptr< platform::time_service > _ts
Definition: l500-private.h:476
void read_fw_table(hw_monitor &hwm, int table_id, T *ptable, table_header *pheader=nullptr, std::function< void() > init=nullptr)
Definition: l500-private.h:109
const uint16_t L535_PID
Definition: l500-private.h:23
auto group_multiple_fw_calls(synthetic_sensor &s, T action) -> decltype(action())
Definition: l500-private.h:615
const int REGISTER_CLOCK_0
Definition: l500-private.h:46
int i
GLuint res
Definition: glext.h:8856
option_range get_range() const override
Definition: l500-private.h:457
const platform::extension_unit depth_xu
Definition: l500-private.h:43
#define LOG_DEBUG(...)
Definition: src/types.h:239
static const int MAX_NUM_OF_DEPTH_RESOLUTIONS
Definition: l500-private.h:13
rs2_extrinsics get_color_stream_extrinsic(const std::vector< uint8_t > &raw_data)
const uint16_t L500_RECOVERY_PID
Definition: l500-private.h:17
double rs2_time_t
Definition: rs_types.h:300
void read_fw_register(hw_monitor &hwm, T *preg, int const baseline_address)
Definition: l500-private.h:178
const uint16_t L515_PID_PRE_PRQ
Definition: l500-private.h:21
pinhole_camera_model pinhole_cam_model
Definition: l500-private.h:345
GLuint64EXT * result
Definition: glext.h:10921
const uint16_t L500_PID
Definition: l500-private.h:20
Definition: parser.hpp:150
GLint GLsizei width
rs2_extrinsics const & get_extrinsics() const
Definition: l500-private.h:228
uint32_t calc_crc32(const uint8_t *buf, size_t bufsize)
Calculate CRC code for arbitrary characters buffer.
Definition: types.cpp:803
bool has_metadata_fc(const std::shared_ptr< frame_interface > &frame) const
Definition: l500-private.h:538
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:47:21