Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
sensor.h
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2015 Intel Corporation. All Rights Reserved.
3 
4 #pragma once
5 
6 #include "backend.h"
7 #include "archive.h"
8 
9 #include "core/streaming.h"
10 #include "core/roi.h"
11 #include "core/options.h"
12 #include "source.h"
13 
14 #include <chrono>
15 #include <memory>
16 #include <vector>
17 #include <unordered_set>
18 #include <limits.h>
19 #include <atomic>
20 #include <functional>
21 #include <core/debug.h>
22 
23 namespace librealsense
24 {
25  class device;
26  class option;
27 
28  typedef std::function<void(rs2_stream, frame_interface*, callback_invocation_holder)> on_before_frame_callback;
29  typedef std::function<void(std::vector<platform::stream_profile>)> on_open;
30 
31  class sensor_base : public std::enable_shared_from_this<sensor_base>,
32  public virtual sensor_interface, public options_container, public virtual info_container
33  {
34  public:
35  explicit sensor_base(std::string name,
36  device* device);
37 
39 
41  {
42  return *_profiles;
43  }
44 
45  virtual stream_profiles get_active_streams() const override;
48  int register_before_streaming_changes_callback(std::function<void(bool)> callback) override;
49  void unregister_before_start_callback(int token) override;
50  std::shared_ptr<notifications_processor> get_notifications_processor();
51  virtual frame_callback_ptr get_frames_callback() const override;
52  virtual void set_frames_callback(frame_callback_ptr callback) override;
53 
54  bool is_streaming() const override
55  {
56  return _is_streaming;
57  }
58 
59  virtual ~sensor_base() { _source.flush(); }
60 
61  void register_metadata(rs2_frame_metadata_value metadata, std::shared_ptr<md_attribute_parser_base> metadata_parser) const;
62 
63  void register_on_open(on_open callback)
64  {
65  _on_open = callback;
66  }
67 
68  void register_on_before_frame_callback(on_before_frame_callback callback)
69  {
70  _on_before_frame_callback = callback;
71  }
72 
73  const device_interface& get_device() override;
74 
77 
78  // Make sensor inherit its owning device info by default
79  const std::string& get_info(rs2_camera_info info) const override;
80  bool supports_info(rs2_camera_info info) const override;
81 
82  protected:
83  void raise_on_before_streaming_changes(bool streaming);
84  void set_active_streams(const stream_profiles& requests);
85  bool try_get_pf(const platform::stream_profile& p, native_pixel_format& result) const;
86 
87  void assign_stream(const std::shared_ptr<stream_interface>& stream,
88  std::shared_ptr<stream_profile_interface> target) const;
89 
90  std::vector<request_mapping> resolve_requests(stream_profiles requests);
91 
92  std::vector<platform::stream_profile> _internal_config;
93 
94  std::atomic<bool> _is_streaming;
95  std::atomic<bool> _is_opened;
96  std::shared_ptr<notifications_processor> _notifications_processor;
97  on_before_frame_callback _on_before_frame_callback;
99  std::shared_ptr<metadata_parser_map> _metadata_parsers = nullptr;
100 
102  device* _owner;
103  std::vector<platform::stream_profile> _uvc_profiles;
104 
105  private:
106  lazy<stream_profiles> _profiles;
107  stream_profiles _active_profiles;
108  std::vector<native_pixel_format> _pixel_formats;
109  signal<sensor_base, bool> on_before_streaming_changes;
110  };
111 
113  {
115 
116  virtual double get_frame_timestamp(const request_mapping& mode, const platform::frame_object& fo) = 0;
117  virtual unsigned long long get_frame_counter(const request_mapping& mode, const platform::frame_object& fo) const = 0;
118  virtual rs2_timestamp_domain get_frame_timestamp_domain(const request_mapping & mode, const platform::frame_object& fo) const = 0;
119  virtual void reset() = 0;
120  };
121 
122  class hid_sensor : public sensor_base
123  {
124  public:
125  explicit hid_sensor(std::shared_ptr<platform::hid_device> hid_device,
126  std::unique_ptr<frame_timestamp_reader> hid_iio_timestamp_reader,
127  std::unique_ptr<frame_timestamp_reader> custom_hid_timestamp_reader,
128  std::map<rs2_stream, std::map<unsigned, unsigned>> fps_and_sampling_frequency_per_rs2_stream,
129  std::vector<std::pair<std::string, stream_profile>> sensor_name_and_hid_profiles,
130  device* dev);
131 
132  ~hid_sensor();
133 
134  void open(const stream_profiles& requests) override;
135 
136  void close() override;
137 
138  void start(frame_callback_ptr callback) override;
139 
140  void stop() override;
141 
142  std::vector<uint8_t> get_custom_report_data(const std::string& custom_sensor_name,
143  const std::string& report_name,
144  platform::custom_sensor_report_field report_field) const;
145 
146  protected:
148 
149  private:
150  const std::map<rs2_stream, uint32_t> stream_and_fourcc = {{RS2_STREAM_GYRO, 'GYRO'},
151  {RS2_STREAM_ACCEL, 'ACCL'},
152  {RS2_STREAM_GPIO, 'GPIO'}};
153 
154  const std::vector<std::pair<std::string, stream_profile>> _sensor_name_and_hid_profiles;
155  std::map<rs2_stream, std::map<uint32_t, uint32_t>> _fps_and_sampling_frequency_per_rs2_stream;
156  std::shared_ptr<platform::hid_device> _hid_device;
157  std::mutex _configure_lock;
158  std::map<std::string, stream_profile> _configured_profiles;
159  std::vector<bool> _is_configured_stream;
160  std::vector<platform::hid_sensor> _hid_sensors;
161  std::map<std::string, request_mapping> _hid_mapping;
162  std::unique_ptr<frame_timestamp_reader> _hid_iio_timestamp_reader;
163  std::unique_ptr<frame_timestamp_reader> _custom_hid_timestamp_reader;
164 
165  stream_profiles get_sensor_profiles(std::string sensor_name) const;
166 
167  const std::string& rs2_stream_to_sensor_name(rs2_stream stream) const;
168 
169  uint32_t stream_to_fourcc(rs2_stream stream) const;
170 
171  uint32_t fps_to_sampling_frequency(rs2_stream stream, uint32_t fps) const;
172  };
173 
174  class uvc_sensor : public sensor_base,
175  public roi_sensor_interface
176  {
177  public:
178  explicit uvc_sensor(std::string name, std::shared_ptr<platform::uvc_device> uvc_device,
179  std::unique_ptr<frame_timestamp_reader> timestamp_reader, device* dev);
180 
181  ~uvc_sensor();
182 
183  region_of_interest_method& get_roi_method() const override;
184  void set_roi_method(std::shared_ptr<region_of_interest_method> roi_method) override;
185 
186  void open(const stream_profiles& requests) override;
187 
188  void close() override;
189 
190  std::vector<platform::stream_profile> get_configuration() const { return _internal_config; }
191 
192  void register_xu(platform::extension_unit xu);
193 
194  template<class T>
195  auto invoke_powered(T action)
196  -> decltype(action(*static_cast<platform::uvc_device*>(nullptr)))
197  {
198  power on(std::dynamic_pointer_cast<uvc_sensor>(shared_from_this()));
199  return action(*_device);
200  }
201 
202  void register_pu(rs2_option id);
203  void try_register_pu(rs2_option id);
204 
205  void start(frame_callback_ptr callback) override;
206 
207  void stop() override;
208 
209  platform::usb_spec get_usb_specification() const { return _device->get_usb_specification(); }
210  std::string get_device_path() const { return _device->get_device_location(); }
211 
212  protected:
214 
215  rs2_extension stream_to_frame_types(rs2_stream stream) const;
216 
217  private:
218  void acquire_power();
219 
220  void release_power();
221 
222  void reset_streaming();
223 
224  struct power
225  {
226  explicit power(std::weak_ptr<uvc_sensor> owner)
227  : _owner(owner)
228  {
229  auto strong = _owner.lock();
230  if (strong)
231  {
232  strong->acquire_power();
233  }
234  }
235 
236  ~power()
237  {
238  if (auto strong = _owner.lock())
239  {
240  try
241  {
242  strong->release_power();
243  }
244  catch (...) {}
245  }
246  }
247  private:
248  std::weak_ptr<uvc_sensor> _owner;
249  };
250 
251  std::shared_ptr<platform::uvc_device> _device;
252  std::atomic<int> _user_count;
253  std::mutex _power_lock;
254  std::mutex _configure_lock;
255  std::vector<platform::extension_unit> _xus;
256  std::unique_ptr<power> _power;
257  std::unique_ptr<frame_timestamp_reader> _timestamp_reader;
258  std::shared_ptr<region_of_interest_method> _roi_method = nullptr;
259  };
260 }
std::shared_ptr< notifications_processor > get_notifications_processor()
rs2_camera_info
Read-only strings that can be queried from the device. Not all information attributes are available o...
Definition: rs_sensor.h:22
Definition: options.h:48
bool is_streaming() const override
Definition: sensor.h:54
auto invoke_powered(T action) -> decltype(action(*static_cast< platform::uvc_device *>(nullptr)))
Definition: sensor.h:195
frame_source _source
Definition: sensor.h:101
notifications_callback_ptr get_notifications_callback() const override
void register_on_before_frame_callback(on_before_frame_callback callback)
Definition: sensor.h:68
void register_metadata(rs2_frame_metadata_value metadata, std::shared_ptr< md_attribute_parser_base > metadata_parser) const
std::atomic< bool > _is_opened
Definition: sensor.h:95
const device_interface & get_device() override
Definition: backend.h:374
std::vector< request_mapping > resolve_requests(stream_profiles requests)
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls...
Definition: rs_option.h:22
std::function< void(std::vector< platform::stream_profile >)> on_open
Definition: sensor.h:29
Definition: info.h:22
std::function< void(rs2_stream, frame_interface *, callback_invocation_holder)> on_before_frame_callback
Definition: sensor.h:26
std::shared_ptr< rs2_frame_callback > frame_callback_ptr
Definition: types.h:872
Definition: options.h:20
Definition: types.h:589
virtual void start(frame_callback_ptr callback)=0
std::vector< platform::stream_profile > get_configuration() const
Definition: sensor.h:190
bool supports_info(rs2_camera_info info) const override
sensor_base(std::string name, device *device)
Definition: rs_sensor.h:46
Definition: rs_sensor.h:44
Definition: streaming.h:131
Definition: types.h:1390
usb_spec
Definition: backend.h:180
on_open _on_open
Definition: sensor.h:98
void set_active_streams(const stream_profiles &requests)
Definition: algo.h:16
virtual stream_profiles init_stream_profiles()=0
device * _owner
Definition: sensor.h:102
void raise_on_before_streaming_changes(bool streaming)
Definition: backend.h:167
std::shared_ptr< rs2_notifications_callback > notifications_callback_ptr
Definition: types.h:874
platform::usb_spec get_usb_specification() const
Definition: sensor.h:209
virtual stream_profiles get_active_streams() const override
std::shared_ptr< notifications_processor > _notifications_processor
Definition: sensor.h:96
std::vector< platform::stream_profile > _uvc_profiles
Definition: sensor.h:103
virtual void open(const stream_profiles &requests)=0
on_before_frame_callback _on_before_frame_callback
Definition: sensor.h:97
std::vector< platform::stream_profile > _internal_config
Definition: sensor.h:92
virtual frame_callback_ptr get_frames_callback() const override
virtual ~frame_timestamp_reader()
Definition: sensor.h:114
std::vector< std::shared_ptr< stream_profile_interface >> stream_profiles
Definition: streaming.h:104
rs2_stream
Streams are different types of data provided by RealSense devices.
Definition: rs_sensor.h:37
custom_sensor_report_field
Definition: backend.h:371
Definition: rs_sensor.h:45
void unregister_before_start_callback(int token) override
rs2_extension
Specifies advanced interfaces (capabilities) objects may implement.
Definition: rs_types.h:93
Definition: stream.h:14
void remove_pixel_format(native_pixel_format pf)
std::shared_ptr< metadata_parser_map > _metadata_parsers
Definition: sensor.h:99
void register_on_open(on_open callback)
Definition: sensor.h:63
const std::string & get_info(rs2_camera_info info) const override
std::string get_device_path() const
Definition: sensor.h:210
Definition: streaming.h:106
void register_pixel_format(native_pixel_format pf)
int register_before_streaming_changes_callback(std::function< void(bool)> callback) override
void register_notifications_callback(notifications_callback_ptr callback) override
virtual ~sensor_base()
Definition: sensor.h:59
std::atomic< bool > _is_streaming
Definition: sensor.h:94
Definition: sensor.h:122
void assign_stream(const std::shared_ptr< stream_interface > &stream, std::shared_ptr< stream_profile_interface > target) const
Definition: sensor.h:112
bool try_get_pf(const platform::stream_profile &p, native_pixel_format &result) const
Definition: sensor.h:31
Definition: types.h:606
Definition: device.h:43
rs2_frame_metadata_value
Per-Frame-Metadata are set of read-only properties that might be exposed for each individual frame...
Definition: rs_frame.h:28
Definition: sensor.h:174
virtual void set_frames_callback(frame_callback_ptr callback) override
stream_profiles get_stream_profiles() const override
Definition: sensor.h:40
Definition: source.h:15
rs2_timestamp_domain
Specifies the clock in relation to which the frame timestamp was measured.
Definition: rs_frame.h:19