d400-color.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 <cstddef>
5 #include "metadata.h"
6 
7 #include "ds/ds-timestamp.h"
8 #include "d400-thermal-monitor.h"
10 #include "d400-color.h"
11 #include "d400-info.h"
12 #include <src/backend.h>
14 #include <src/fourcc.h>
15 #include <src/metadata-parser.h>
16 
18 
19 #include <rsutils/string/from.h>
20 
21 namespace librealsense
22 {
23  std::map<uint32_t, rs2_format> d400_color_fourcc_to_rs2_format = {
24  {rs_fourcc('Y','U','Y','2'), RS2_FORMAT_YUYV},
25  {rs_fourcc('Y','U','Y','V'), RS2_FORMAT_YUYV},
26  {rs_fourcc('U','Y','V','Y'), RS2_FORMAT_UYVY},
27  {rs_fourcc('M','J','P','G'), RS2_FORMAT_MJPEG},
28  {rs_fourcc('B','Y','R','2'), RS2_FORMAT_RAW16}
29  };
30  std::map<uint32_t, rs2_stream> d400_color_fourcc_to_rs2_stream = {
31  {rs_fourcc('Y','U','Y','2'), RS2_STREAM_COLOR},
32  {rs_fourcc('Y','U','Y','V'), RS2_STREAM_COLOR},
33  {rs_fourcc('U','Y','V','Y'), RS2_STREAM_COLOR},
34  {rs_fourcc('B','Y','R','2'), RS2_STREAM_COLOR},
35  {rs_fourcc('M','J','P','G'), RS2_STREAM_COLOR}
36  };
37 
38  d400_color::d400_color( std::shared_ptr< const d400_info > const & dev_info )
39  : d400_device(dev_info), device(dev_info),
40  _color_stream(new stream(RS2_STREAM_COLOR)),
41  _separate_color(true)
42  {
43  create_color_device( dev_info->get_context(), dev_info->get_group() );
44  init();
45  }
46 
47  void d400_color::create_color_device(std::shared_ptr<context> ctx, const platform::backend_device_group& group)
48  {
49  using namespace ds;
50 
51  _color_calib_table_raw = [this]()
52  {
53  return get_d400_raw_calibration_table(d400_calibration_table_id::rgb_calibration_id);
54  };
55 
56  _color_extrinsic = std::make_shared< rsutils::lazy< rs2_extrinsics > >(
60 
61  std::vector<platform::uvc_device_info> color_devs_info;
62  // end point 3 is used for color sensor
63  // except for D405, in which the color is part of the depth unit
64  // and it will then been found in end point 0 (the depth's one)
65  auto color_devs_info_mi3 = filter_by_mi(group.uvc_devices, 3);
66  if (color_devs_info_mi3.size() == 1 || ds::RS457_PID == _pid)
67  {
68  // means color end point in part of a separate color sensor (e.g. D435)
69  if (ds::RS457_PID == _pid)
70  color_devs_info = group.uvc_devices;
71  else
72  color_devs_info = color_devs_info_mi3;
73  std::unique_ptr< frame_timestamp_reader > d400_timestamp_reader_backup( new ds_timestamp_reader() );
74  frame_timestamp_reader* timestamp_reader_from_metadata;
75  if (ds::RS457_PID != _pid)
76  timestamp_reader_from_metadata = new ds_timestamp_reader_from_metadata(std::move(d400_timestamp_reader_backup));
77  else
78  timestamp_reader_from_metadata = new ds_timestamp_reader_from_metadata_mipi_color(std::move(d400_timestamp_reader_backup));
79 
80  std::unique_ptr<frame_timestamp_reader> ds_timestamp_reader_metadata(timestamp_reader_from_metadata);
81 
82  auto enable_global_time_option = std::shared_ptr<global_time_option>(new global_time_option());
84  if (ds::RS457_PID == _pid)
85  info = color_devs_info[1];
86  else
87  info = color_devs_info.front();
88  auto uvcd = get_backend()->create_uvc_device( info );
89  //auto ftr = std::unique_ptr<frame_timestamp_reader>(new global_timestamp_reader(std::move(d400_timestamp_reader_metadata), _tf_keeper, enable_global_time_option));
90  auto raw_color_ep = std::make_shared<uvc_sensor>("Raw RGB Camera",
91  uvcd,
92  std::unique_ptr<frame_timestamp_reader>(new global_timestamp_reader(std::move(ds_timestamp_reader_metadata), _tf_keeper, enable_global_time_option)),
93  this);
94 
95  auto color_ep = std::make_shared<d400_color_sensor>(this,
96  raw_color_ep,
99 
100  color_ep->register_option(RS2_OPTION_GLOBAL_TIME_ENABLED, enable_global_time_option);
101 
102  color_ep->register_info(RS2_CAMERA_INFO_PHYSICAL_PORT, color_devs_info.front().device_path);
103 
104  _color_device_idx = add_sensor(color_ep);
105  }
106  else
107  {
108  auto color_devs_info_mi0 = filter_by_mi(group.uvc_devices, 0);
109  // one uvc device is seen over Windows and 3 uvc devices are seen over linux
110  if (color_devs_info_mi0.size() == 1 || color_devs_info_mi0.size() == 3)
111  {
112  // means color end point is part of the depth sensor (e.g. D405)
113  color_devs_info = color_devs_info_mi0;
116  _separate_color = false;
117  }
118  else
119  throw invalid_value_exception( rsutils::string::from() << "RS4XX: RGB modules inconsistency - "
120  << color_devs_info_mi0.size() << " found" );
121  }
122  }
123 
125  {
127 
128  if( fw_ver >= firmware_version( 5, 10, 9, 0 ) )
129  register_feature( std::make_shared< auto_exposure_roi_feature >( get_color_sensor(), _hw_monitor, true ) );
130  }
131 
133  {
134  auto& color_ep = get_color_sensor();
135  auto raw_color_ep = get_raw_color_sensor();
136 
137  _ds_color_common = std::make_shared<ds_color_common>(raw_color_ep, color_ep, _fw_version, _hw_monitor, this);
138 
141 
142  if (_pid != ds::RS457_PID)
143  {
144  register_metadata(color_ep);
145  }
146  else
147  {
148  register_metadata_mipi(color_ep);
149  }
151  }
152 
154  {
155  auto& color_ep = get_color_sensor();
156 
157  if (!val_in_range(_pid, { ds::RS457_PID }))
158  {
159  _ds_color_common->register_color_options();
160  color_ep.register_pu(RS2_OPTION_BACKLIGHT_COMPENSATION);
161 
162  auto raw_color_ep = get_raw_color_sensor();
163  color_ep.register_option(RS2_OPTION_POWER_LINE_FREQUENCY,
164  std::make_shared<uvc_pu_option>(raw_color_ep, RS2_OPTION_POWER_LINE_FREQUENCY,
165  std::map<float, std::string>{ { 0.f, "Disabled"},
166  { 1.f, "50Hz" },
167  { 2.f, "60Hz" },
168  { 3.f, "Auto" }, }));
169  }
170 
171  if (_separate_color)
172  {
173  // Currently disabled for certain sensors
174  if (!val_in_range(_pid, { ds::RS457_PID}))
175  {
176  color_ep.register_pu(RS2_OPTION_AUTO_EXPOSURE_PRIORITY);
177  }
178 
179  _ds_color_common->register_standard_options();
180 
181  // Register for tracking of thermal compensation changes
182  if (val_in_range(_pid, { ds::RS455_PID }))
183  {
184  if (_thermal_monitor)
185  _thermal_monitor->add_observer([&](float) {
187  }
188  }
189 
190  // Currently disabled for certain sensors
191  if (!val_in_range(_pid, { ds::RS457_PID }))
192  {
193  color_ep.register_pu(RS2_OPTION_HUE);
194  }
195  }
196 
198  {
199  if (_separate_color)
200  {
201  auto md_prop_offset = metadata_raw_mode_offset +
202  offsetof(md_rgb_mode, rgb_mode) +
203  offsetof(md_rgb_normal_mode, intel_rgb_control);
204 
206  [](rs2_metadata_type param) { return (param != 1); })); // OFF value via UVC is 1 (ON is 8)
207  }
208  else
209  {
210  // attributes of md_rgb_control
211  auto md_prop_offset = metadata_raw_mode_offset +
212  offsetof(md_rgb_mode, rgb_mode) +
213  offsetof(md_rgb_normal_mode, intel_rgb_control);
214 
216  }
217 
218  _ds_color_common->register_metadata();
219  }
220 
222  {
223  // attributes of md_capture_stats
224  auto& color_ep = get_color_sensor();
225  // attributes of md_rgb_control
226  auto raw_color_ep = get_raw_color_sensor();
227 
228  if (_pid != ds::RS457_PID)
229  {
230  color_ep.register_processing_block(processing_block_factory::create_pbf_vector<yuy2_converter>(RS2_FORMAT_YUYV, map_supported_color_formats(RS2_FORMAT_YUYV), RS2_STREAM_COLOR));
231  color_ep.register_processing_block(processing_block_factory::create_id_pbf(RS2_FORMAT_RAW16, RS2_STREAM_COLOR));
232  }
233  else
234  {
235  auto uvc_dev = raw_color_ep->get_uvc_device();
236  if (uvc_dev->is_platform_jetson())
237  {
238  // Work-around for discrepancy between the RGB YUYV descriptor and the parser . Use UYUV parser instead
239  color_ep.register_processing_block(processing_block_factory::create_pbf_vector<uyvy_converter>(RS2_FORMAT_YUYV, map_supported_color_formats(RS2_FORMAT_YUYV), RS2_STREAM_COLOR));
240  }
241  else
242  {
243  color_ep.register_processing_block(processing_block_factory::create_pbf_vector<yuy2_converter>(RS2_FORMAT_YUYV, map_supported_color_formats(RS2_FORMAT_YUYV), RS2_STREAM_COLOR));
244  }
245  }
246  }
247 
249  {
250  // for mipi device
252 
253  // frame counter
255 
256  // attributes of md_mipi_rgb_control structure
257  auto md_prop_offset = offsetof(metadata_mipi_rgb_raw, rgb_mode);
258 
259  // to be checked
263  md_prop_offset));
264 
268  md_prop_offset));
272  md_prop_offset));
276  md_prop_offset));
280  md_prop_offset));
284  md_prop_offset));
288  md_prop_offset));
292  md_prop_offset));
296  md_prop_offset));
300  md_prop_offset));
304  md_prop_offset));
308  md_prop_offset));
312  md_prop_offset));
316  md_prop_offset));
320  md_prop_offset));
324  md_prop_offset));
328  md_prop_offset));
332  md_prop_offset));
336  md_prop_offset));
337  }
338 
340  {
342  }
343 
345  {
347  *_owner->_color_calib_table_raw,
350  }
351 
353  {
355  auto&& results = synthetic_sensor::init_stream_profiles();
356 
357  for (auto&& p : results)
358  {
359  // Register stream types
360  if (p->get_stream_type() == RS2_STREAM_COLOR)
361  {
362  assign_stream(_owner->_color_stream, p);
363  }
364 
365  auto&& video = dynamic_cast<video_stream_profile_interface*>(p.get());
366  const auto&& profile = to_profile(p.get());
367 
368  std::weak_ptr<d400_color_sensor> wp =
369  std::dynamic_pointer_cast<d400_color_sensor>(this->shared_from_this());
370  video->set_intrinsics([profile, wp]()
371  {
372  auto sp = wp.lock();
373  if (sp)
374  return sp->get_intrinsics(profile);
375  else
376  return rs2_intrinsics{};
377  });
378  }
379 
380  return results;
381  }
382 
384  {
386  }
387 }
librealsense::md_mipi_rgb_control_attributes::saturation_attribute
@ saturation_attribute
RS2_FRAME_METADATA_POWER_LINE_FREQUENCY
@ RS2_FRAME_METADATA_POWER_LINE_FREQUENCY
Definition: rs_frame.h:59
librealsense::md_mipi_rgb_control_attributes::gamma_attribute
@ gamma_attribute
RS2_CAMERA_INFO_PHYSICAL_PORT
@ RS2_CAMERA_INFO_PHYSICAL_PORT
Definition: rs_sensor.h:27
librealsense::get_color_recommended_proccesing_blocks
processing_blocks get_color_recommended_proccesing_blocks()
Definition: sensor.cpp:239
librealsense
Definition: algo.h:18
librealsense::ds::d400_calibration_table_id::rgb_calibration_id
@ rgb_calibration_id
RS2_FRAME_METADATA_CONTRAST
@ RS2_FRAME_METADATA_CONTRAST
Definition: rs_frame.h:51
RS2_FRAME_METADATA_FRAME_TIMESTAMP
@ RS2_FRAME_METADATA_FRAME_TIMESTAMP
Definition: rs_frame.h:32
librealsense::d400_color_sensor::get_intrinsics
rs2_intrinsics get_intrinsics(const stream_profile &profile) const override
Definition: d400-color.cpp:344
platform-utils.h
librealsense::md_mipi_rgb_mode::contrast
uint8_t contrast
Definition: src/metadata.h:328
rsutils::version
Definition: version.h:20
librealsense::d400_device::_depth_stream
std::shared_ptr< stream_interface > _depth_stream
Definition: d400-device.h:99
librealsense::d400_color::_ds_color_common
std::shared_ptr< ds_color_common > _ds_color_common
Definition: d400-color.h:37
RS2_FRAME_METADATA_SATURATION
@ RS2_FRAME_METADATA_SATURATION
Definition: rs_frame.h:52
librealsense::md_mipi_rgb_mode::power_line_frequency
uint8_t power_line_frequency
Definition: src/metadata.h:339
RS2_FRAME_METADATA_SENSOR_TIMESTAMP
@ RS2_FRAME_METADATA_SENSOR_TIMESTAMP
Definition: rs_frame.h:33
librealsense::invalid_value_exception
Definition: librealsense-exception.h:114
librealsense::d400_color_fourcc_to_rs2_format
std::map< uint32_t, rs2_format > d400_color_fourcc_to_rs2_format
Definition: d400-color.cpp:23
RS2_FRAME_METADATA_MANUAL_WHITE_BALANCE
@ RS2_FRAME_METADATA_MANUAL_WHITE_BALANCE
Definition: rs_frame.h:58
librealsense::ds::RS457_PID
const uint16_t RS457_PID
Definition: d400-private.h:39
librealsense::d400_color::_color_device_idx
uint8_t _color_device_idx
Definition: d400-color.h:56
librealsense::md_mipi_rgb_control_attributes::backlight_compensation_attribute
@ backlight_compensation_attribute
librealsense::d400_device::_thermal_monitor
std::shared_ptr< d400_thermal_monitor > _thermal_monitor
Definition: d400-device.h:110
librealsense::md_mipi_rgb_mode::hw_timestamp
uint32_t hw_timestamp
Definition: src/metadata.h:326
librealsense::d400_device::_depth_device_idx
uint8_t _depth_device_idx
Definition: d400-device.h:104
librealsense::md_mipi_rgb_mode::sharpness
uint8_t sharpness
Definition: src/metadata.h:330
librealsense::md_mipi_rgb_mode::auto_exposure_mode
uint8_t auto_exposure_mode
Definition: src/metadata.h:335
librealsense::md_mipi_rgb_mode::crc
uint32_t crc
Definition: src/metadata.h:344
rs2_intrinsics
Video stream intrinsics.
Definition: rs_types.h:58
librealsense::md_mipi_rgb_control_attributes::manual_exposure_attribute
@ manual_exposure_attribute
librealsense::md_mipi_rgb_mode::brightness
uint8_t brightness
Definition: src/metadata.h:327
librealsense::d400_color::register_stream_to_extrinsic_group
void register_stream_to_extrinsic_group(const stream_interface &stream, uint32_t group_index)
Definition: d400-color.cpp:339
librealsense::md_mipi_rgb_mode::manual_exposure
uint16_t manual_exposure
Definition: src/metadata.h:333
librealsense::metadata_raw_mode_offset
constexpr int metadata_raw_mode_offset
Definition: src/metadata.h:712
librealsense::d400_color::register_metadata
void register_metadata(const synthetic_sensor &color_ep) const
Definition: d400-color.cpp:197
RS2_OPTION_BACKLIGHT_COMPENSATION
@ RS2_OPTION_BACKLIGHT_COMPENSATION
Definition: rs_option.h:28
RS2_OPTION_GLOBAL_TIME_ENABLED
@ RS2_OPTION_GLOBAL_TIME_ENABLED
Definition: rs_option.h:81
RS2_FRAME_METADATA_AUTO_WHITE_BALANCE_TEMPERATURE
@ RS2_FRAME_METADATA_AUTO_WHITE_BALANCE_TEMPERATURE
Definition: rs_frame.h:54
librealsense::synthetic_sensor::register_metadata
void register_metadata(rs2_frame_metadata_value metadata, std::shared_ptr< md_attribute_parser_base > metadata_parser) const override
Definition: sensor.cpp:705
librealsense::md_mipi_rgb_mode::manual_white_balance
uint16_t manual_white_balance
Definition: src/metadata.h:334
librealsense::ds::RS455_PID
const uint16_t RS455_PID
Definition: d400-private.h:38
librealsense::d400_color::register_options
void register_options()
Definition: d400-color.cpp:153
librealsense::md_mipi_rgb_control_attributes::contrast_attribute
@ contrast_attribute
RS2_FRAME_METADATA_CRC
@ RS2_FRAME_METADATA_CRC
Definition: rs_frame.h:76
from.h
librealsense::md_mipi_rgb_mode::gamma
uint16_t gamma
Definition: src/metadata.h:332
librealsense::d400_device::_color_stream
std::shared_ptr< stream_interface > _color_stream
Definition: d400-device.h:102
librealsense::device::register_stream_to_extrinsic_group
void register_stream_to_extrinsic_group(const stream_interface &stream, uint32_t groupd_index)
Definition: device.cpp:163
librealsense::processing_block_factory::create_id_pbf
static processing_block_factory create_id_pbf(rs2_format format, rs2_stream stream, int idx=0)
Definition: processing-blocks-factory.cpp:19
param
GLenum GLfloat param
Definition: glad/glad/glad.h:1400
librealsense::stream_profile
Definition: core/stream-profile.h:15
profile::width
int width
Definition: unit-tests-common.h:62
librealsense::d400_color::register_processing_blocks
void register_processing_blocks()
Definition: d400-color.cpp:221
librealsense::platform::backend_device_group
Definition: backend-device-group.h:50
librealsense::md_mipi_rgb_mode::hue
uint8_t hue
Definition: src/metadata.h:338
RS2_STREAM_COLOR
@ RS2_STREAM_COLOR
Definition: rs_sensor.h:47
RS2_FRAME_METADATA_FRAME_COUNTER
@ RS2_FRAME_METADATA_FRAME_COUNTER
Definition: rs_frame.h:31
librealsense::md_mipi_rgb_mode::low_light_compensation
uint8_t low_light_compensation
Definition: src/metadata.h:340
librealsense::environment::get_instance
static environment & get_instance()
Definition: environment.cpp:247
librealsense::rs_fourcc
uint32_t rs_fourcc(const T a, const T b, const T c, const T d)
Definition: fourcc.h:13
librealsense::d400_color_sensor::get_recommended_processing_blocks
processing_blocks get_recommended_processing_blocks() const override
Definition: d400-color.cpp:383
rsutils::lazy::reset
void reset() const
Definition: lazy.h:64
librealsense::md_mipi_rgb_mode::saturation
uint8_t saturation
Definition: src/metadata.h:329
librealsense::d400_device::_hw_monitor
std::shared_ptr< hw_monitor > _hw_monitor
Definition: d400-device.h:94
RS2_FRAME_METADATA_HUE
@ RS2_FRAME_METADATA_HUE
Definition: rs_frame.h:56
librealsense::d400_color::_separate_color
bool _separate_color
Definition: d400-color.h:57
librealsense::make_attribute_parser
std::shared_ptr< md_attribute_parser_base > make_attribute_parser(Attribute S::*attribute, Flag flag, unsigned long long offset, attrib_modifyer mod=nullptr)
A helper function to create a specialized attribute parser. Return it as a pointer to a base-class.
Definition: metadata-parser.h:181
librealsense::platform::filter_by_mi
std::vector< uvc_device_info > filter_by_mi(const std::vector< uvc_device_info > &devices, uint32_t mi)
Definition: platform-utils.cpp:134
librealsense::md_mipi_rgb_control_attributes::hw_timestamp_attribute
@ hw_timestamp_attribute
profile::height
int height
Definition: unit-tests-common.h:63
librealsense::md_rgb_normal_mode
Definition: src/metadata.h:654
RS2_FORMAT_YUYV
@ RS2_FORMAT_YUYV
Definition: rs_sensor.h:67
librealsense::ds_timestamp_reader_from_metadata_mipi_color
Definition: ds-timestamp.h:46
librealsense::md_mipi_rgb_control_attributes::low_light_compensation_attribute
@ low_light_compensation_attribute
librealsense::device::add_sensor
int add_sensor(const std::shared_ptr< sensor_interface > &sensor_base)
Definition: device.cpp:76
RS2_FRAME_METADATA_LOW_LIGHT_COMPENSATION
@ RS2_FRAME_METADATA_LOW_LIGHT_COMPENSATION
Definition: rs_frame.h:60
RS2_FRAME_METADATA_BRIGHTNESS
@ RS2_FRAME_METADATA_BRIGHTNESS
Definition: rs_frame.h:50
uint32_t
unsigned int uint32_t
Definition: stdint.h:80
librealsense::val_in_range
bool val_in_range(const T &val, const std::initializer_list< T > &list)
Definition: src/types.h:66
librealsense::d400_color_fourcc_to_rs2_stream
std::map< uint32_t, rs2_stream > d400_color_fourcc_to_rs2_stream
Definition: d400-color.cpp:30
RS2_CAMERA_INFO_FIRMWARE_VERSION
@ RS2_CAMERA_INFO_FIRMWARE_VERSION
Definition: rs_sensor.h:25
librealsense::md_mipi_rgb_control_attributes::hue_attribute
@ hue_attribute
librealsense::md_mipi_rgb_mode::input_width
uint16_t input_width
Definition: src/metadata.h:341
RS2_FRAME_METADATA_BACKLIGHT_COMPENSATION
@ RS2_FRAME_METADATA_BACKLIGHT_COMPENSATION
Definition: rs_frame.h:55
librealsense::d400_device::_fw_version
firmware_version _fw_version
Definition: d400-device.h:95
librealsense::d400_color::d400_color
d400_color(std::shared_ptr< const d400_info > const &)
Definition: d400-color.cpp:38
librealsense::platform::uvc_header::timestamp
uint32_t timestamp
Definition: platform/uvc-device.h:66
librealsense::stream_interface
Definition: stream-interface.h:13
librealsense::d400_device::get_d400_raw_calibration_table
std::vector< uint8_t > get_d400_raw_calibration_table(ds::d400_calibration_table_id table_id) const
Definition: d400-device.cpp:414
d400-color.h
librealsense::md_mipi_rgb_control_attributes::input_height_attribute
@ input_height_attribute
RS2_OPTION_HUE
@ RS2_OPTION_HUE
Definition: rs_option.h:34
librealsense::ds_timestamp_reader_from_metadata
Definition: ds-timestamp.h:13
librealsense::md_mipi_rgb_control_attributes::input_width_attribute
@ input_width_attribute
librealsense::md_rgb_control_attributes::ae_mode_attribute
@ ae_mode_attribute
librealsense::global_time_interface::_tf_keeper
std::shared_ptr< time_diff_keeper > _tf_keeper
Definition: global_timestamp_reader.h:114
RS2_FORMAT_RAW16
@ RS2_FORMAT_RAW16
Definition: rs_sensor.h:75
RS2_FRAME_METADATA_GAMMA
@ RS2_FRAME_METADATA_GAMMA
Definition: rs_frame.h:57
librealsense::md_mipi_rgb_control_attributes::auto_exposure_mode_attribute
@ auto_exposure_mode_attribute
rs2_metadata_type
long long rs2_metadata_type
Definition: rs_types.h:272
librealsense::md_mipi_rgb_control_attributes::gain_attribute
@ gain_attribute
librealsense::md_mipi_rgb_mode::gain
uint8_t gain
Definition: src/metadata.h:336
librealsense::features_container::register_feature
void register_feature(std::shared_ptr< feature_interface > feature)
Definition: features-container.h:38
librealsense::md_mipi_rgb_control_attributes::crc_attribute
@ crc_attribute
RS2_FORMAT_MJPEG
@ RS2_FORMAT_MJPEG
Definition: rs_sensor.h:85
librealsense::ds::get_d400_intrinsic_by_resolution
rs2_intrinsics get_d400_intrinsic_by_resolution(const vector< uint8_t > &raw_data, d400_calibration_table_id table_id, uint32_t width, uint32_t height)
Definition: d400-private.cpp:105
d400-info.h
librealsense::firmware_version
rsutils::version firmware_version
Definition: src/firmware-version.h:11
librealsense::md_mipi_rgb_control_attributes::sharpness_attribute
@ sharpness_attribute
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
backend.h
librealsense::md_mipi_rgb_control_attributes::brightness_attribute
@ brightness_attribute
librealsense::d400_color::create_color_device
void create_color_device(std::shared_ptr< context > ctx, const platform::backend_device_group &group)
Definition: d400-color.cpp:47
librealsense::to_profile
stream_profile to_profile(const stream_profile_interface *sp)
Definition: src/stream.h:222
RS2_FRAME_METADATA_SHARPNESS
@ RS2_FRAME_METADATA_SHARPNESS
Definition: rs_frame.h:53
color-formats-converter.h
librealsense::md_mipi_rgb_control_attributes::auto_white_balance_temp_attribute
@ auto_white_balance_temp_attribute
librealsense::synthetic_sensor
Definition: sensor.h:208
RS2_FRAME_METADATA_AUTO_EXPOSURE
@ RS2_FRAME_METADATA_AUTO_EXPOSURE
Definition: rs_frame.h:37
librealsense::stream
Definition: src/stream.h:30
fps.info
info
Definition: fps.py:50
librealsense::platform::backend_device_group::uvc_devices
std::vector< uvc_device_info > uvc_devices
Definition: backend-device-group.h:75
librealsense::from_pose
rs2_extrinsics from_pose(pose a)
Definition: src/pose.h:44
librealsense::sensor_interface::stream_profiles
std::vector< std::shared_ptr< stream_profile_interface > > stream_profiles
Definition: sensor-interface.h:38
RS2_OPTION_POWER_LINE_FREQUENCY
@ RS2_OPTION_POWER_LINE_FREQUENCY
Definition: rs_option.h:50
librealsense::video_stream_profile_interface
Definition: video.h:17
librealsense::backend_device::_pid
uint16_t _pid
Definition: backend-device.h:37
rsutils::string::from
Definition: from.h:19
librealsense::md_mipi_rgb_control_attributes::power_line_frequency_attribute
@ power_line_frequency_attribute
librealsense::d400_color::init
void init()
Definition: d400-color.cpp:132
RS2_FRAME_METADATA_GAIN_LEVEL
@ RS2_FRAME_METADATA_GAIN_LEVEL
Definition: rs_frame.h:35
RS2_FORMAT_UYVY
@ RS2_FORMAT_UYVY
Definition: rs_sensor.h:77
librealsense::d400_color::get_raw_color_sensor
std::shared_ptr< uvc_sensor > get_raw_color_sensor()
Definition: d400-color.h:27
p
double p[GRIDW][GRIDH]
Definition: wave.c:109
processing_blocks
Definition: rs-benchmark.cpp:165
librealsense::make_uvc_header_parser
std::shared_ptr< md_attribute_parser_base > make_uvc_header_parser(Attribute St::*attribute, attrib_modifyer mod=nullptr)
A utility function to create UVC metadata header parser.
Definition: metadata-parser.h:222
test-fps.ds
ds
Definition: test-fps.py:77
librealsense::ds::get_d400_color_stream_extrinsic
pose get_d400_color_stream_extrinsic(const std::vector< uint8_t > &raw_data)
Definition: d400-private.cpp:226
RS2_OPTION_AUTO_EXPOSURE_PRIORITY
@ RS2_OPTION_AUTO_EXPOSURE_PRIORITY
Definition: rs_option.h:58
librealsense::ds_timestamp_reader
Definition: ds-timestamp.h:68
librealsense::frame_timestamp_reader
Definition: sensor.h:39
librealsense::md_mipi_rgb_mode::auto_white_balance_temp
uint16_t auto_white_balance_temp
Definition: src/metadata.h:331
RS2_FRAME_METADATA_ACTUAL_EXPOSURE
@ RS2_FRAME_METADATA_ACTUAL_EXPOSURE
Definition: rs_frame.h:34
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::backend_device::get_backend
std::shared_ptr< platform::backend > get_backend()
Definition: backend-device-factory.cpp:118
librealsense::synthetic_sensor::init_stream_profiles
virtual stream_profiles init_stream_profiles() override
Definition: sensor.cpp:560
librealsense::d400_color::_color_extrinsic
std::shared_ptr< rsutils::lazy< rs2_extrinsics > > _color_extrinsic
Definition: d400-color.h:59
test-projection-from-recording.ctx
ctx
Definition: test-projection-from-recording.py:16
librealsense::d400_color::register_color_features
void register_color_features()
Definition: d400-color.cpp:124
librealsense::global_time_option
Definition: global_timestamp_reader.h:13
rs2::textual_icons::lock
static const textual_icon lock
Definition: device-model.h:186
auto-exposure-roi-feature.h
librealsense::d400_color::register_metadata_mipi
void register_metadata_mipi(const synthetic_sensor &color_ep) const
Definition: d400-color.cpp:248
librealsense::global_timestamp_reader
Definition: global_timestamp_reader.h:91
librealsense::d400_color_sensor::init_stream_profiles
stream_profiles init_stream_profiles() override
Definition: d400-color.cpp:352
librealsense::metadata_mipi_rgb_raw
Definition: src/metadata.h:730
librealsense::device
Definition: device.h:35
ds-timestamp.h
librealsense::info_container::get_info
const std::string & get_info(rs2_camera_info info) const override
Definition: sensor.cpp:360
librealsense::md_mipi_rgb_mode::backlight_compensation
uint8_t backlight_compensation
Definition: src/metadata.h:337
librealsense::md_mipi_rgb_control_attributes::manual_white_balance_attribute
@ manual_white_balance_attribute
librealsense::platform::uvc_device_info
Definition: uvc-device-info.h:15
RS2_FRAME_METADATA_INPUT_WIDTH
@ RS2_FRAME_METADATA_INPUT_WIDTH
Definition: rs_frame.h:72
librealsense::d400_color::_color_calib_table_raw
rsutils::lazy< std::vector< uint8_t > > _color_calib_table_raw
Definition: d400-color.h:58
metadata-parser.h
librealsense::md_rgb_mode
Definition: src/metadata.h:690
RS2_FRAME_METADATA_INPUT_HEIGHT
@ RS2_FRAME_METADATA_INPUT_HEIGHT
Definition: rs_frame.h:73
profile
Definition: unit-tests-common.h:58
librealsense::device::map_supported_color_formats
std::vector< rs2_format > map_supported_color_formats(rs2_format source_format)
Definition: device.cpp:180
librealsense::extrinsics_graph::lock
extrinsics_lock lock()
Definition: environment.cpp:21
librealsense::md_rgb_control::ae_mode
uint32_t ae_mode
Definition: src/metadata.h:465
librealsense::d400_color::get_color_sensor
synthetic_sensor & get_color_sensor()
Definition: d400-color.h:22
fourcc.h
librealsense::md_mipi_rgb_mode::input_height
uint16_t input_height
Definition: src/metadata.h:342
librealsense::platform::uvc_header_mipi::frame_counter
uint32_t frame_counter
Definition: platform/uvc-device.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