Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
backend-v4l2.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 "types.h"
8 
9 #include <cassert>
10 #include <cstdlib>
11 #include <cstdio>
12 #include <cstring>
13 
14 #include <algorithm>
15 #include <functional>
16 #include <string>
17 #include <sstream>
18 #include <fstream>
19 #include <regex>
20 #include <thread>
21 #include <utility> // for pair
22 #include <chrono>
23 #include <thread>
24 #include <atomic>
25 
26 #include <dirent.h>
27 #include <fcntl.h>
28 #include <unistd.h>
29 #include <limits.h>
30 #include <cmath>
31 #include <errno.h>
32 #include <sys/stat.h>
33 #include <sys/mman.h>
34 #include <sys/ioctl.h>
35 #include <linux/usb/video.h>
36 #include <linux/uvcvideo.h>
37 #include <linux/videodev2.h>
38 #include <fts.h>
39 #include <regex>
40 #include <list>
41 
42 #pragma GCC diagnostic ignored "-Wpedantic"
43 #include "../third-party/libusb/libusb/libusb.h"
44 #pragma GCC diagnostic pop
45 
46 namespace librealsense
47 {
48  namespace platform
49  {
51  {
52  public:
53  named_mutex(const std::string& device_path, unsigned timeout);
54 
55  named_mutex(const named_mutex&) = delete;
56 
57  void lock() { acquire(); }
58  void unlock() { release(); }
59 
60  bool try_lock();
61 
62  ~named_mutex();
63 
64  private:
65  void acquire();
66 
67  void release();
68 
69  void create_named_mutex(const std::string& cam_id);
70 
71  void destroy_named_mutex();
72 
73  std::string _device_path;
74  uint32_t _timeout;
75  int _fildes;
76  };
77 
78  static int xioctl(int fh, int request, void *arg);
79 
80  class buffer
81  {
82  public:
83  buffer(int fd, bool use_memory_map, int index);
84 
85  void prepare_for_streaming(int fd);
86 
87  ~buffer();
88 
89  void attach_buffer(const v4l2_buffer& buf);
90 
91  void detach_buffer();
92 
93  void request_next_frame(int fd);
94 
95  size_t get_full_length() const { return _length; }
96  size_t get_length_frame_only() const { return _original_length; }
97 
98  uint8_t* get_frame_start() const { return _start; }
99 
100  private:
101  uint8_t* _start;
102  size_t _length;
103  size_t _original_length;
104  bool _use_memory_map;
105  int _index;
106  v4l2_buffer _buf;
107  std::mutex _mutex;
108  bool _must_enqueue = false;
109  };
110 
111  class v4l_usb_device : public usb_device
112  {
113  public:
114  v4l_usb_device(const usb_device_info& info);
115 
116  ~v4l_usb_device();
117 
118  static void foreach_usb_device(libusb_context* usb_context, std::function<void(
119  const usb_device_info&,
120  libusb_device*)> action);
121 
122  std::vector<uint8_t> send_receive(
123  const std::vector<uint8_t>& data,
124  int timeout_ms = 5000,
125  bool require_response = true) override;
126 
127  private:
128  libusb_context* _usb_context;
129  libusb_device* _usb_device = nullptr;
130  int _mi;
131  };
132 
133  class v4l_uvc_device : public uvc_device
134  {
135  public:
136  static void foreach_uvc_device(
137  std::function<void(const uvc_device_info&,
138  const std::string&)> action);
139 
140  v4l_uvc_device(const uvc_device_info& info, bool use_memory_map = false);
141 
142  ~v4l_uvc_device();
143 
144  void probe_and_commit(stream_profile profile, frame_callback callback, int buffers) override;
145 
146  void stream_on(std::function<void(const notification& n)> error_handler) override;
147 
148  void start_callbacks() override;
149 
150  void stop_callbacks() override;
151 
152  void close(stream_profile) override;
153 
154  std::string fourcc_to_string(uint32_t id) const;
155 
156  void signal_stop();
157 
158  void poll();
159 
160  void set_power_state(power_state state) override;
161  power_state get_power_state() const override { return _state; }
162 
163  void init_xu(const extension_unit& xu) override {}
164  bool set_xu(const extension_unit& xu, uint8_t control, const uint8_t* data, int size) override;
165  bool get_xu(const extension_unit& xu, uint8_t control, uint8_t* data, int size) const override;
166  control_range get_xu_range(const extension_unit& xu, uint8_t control, int len) const override;
167 
168  bool get_pu(rs2_option opt, int32_t& value) const override;
169 
170  bool set_pu(rs2_option opt, int32_t value) override;
171 
172  control_range get_pu_range(rs2_option option) const override;
173 
174  std::vector<stream_profile> get_profiles() const override;
175 
176  void lock() const override;
177  void unlock() const override;
178 
179  std::string get_device_location() const override { return _device_path; }
180  usb_spec get_usb_specification() const override { return _device_usb_spec; }
181 
182  private:
183  static uint32_t get_cid(rs2_option option);
184 
185  void capture_loop();
186 
187  bool has_metadata();
188 
189  power_state _state = D3;
190  std::string _name = "";
191  std::string _device_path = "";
192  usb_spec _device_usb_spec = usb_undefined;
193  uvc_device_info _info;
194  int _fd = 0;
195  int _stop_pipe_fd[2]; // write to _stop_pipe_fd[1] and read from _stop_pipe_fd[0]
196 
197  std::vector<std::shared_ptr<buffer>> _buffers;
198  stream_profile _profile;
199  frame_callback _callback;
200  std::atomic<bool> _is_capturing;
201  std::atomic<bool> _is_alive;
202  std::atomic<bool> _is_started;
203  std::unique_ptr<std::thread> _thread;
204  std::unique_ptr<named_mutex> _named_mtx;
205  bool _use_memory_map;
206  };
207 
208  class v4l_backend : public backend
209  {
210  public:
211  std::shared_ptr<uvc_device> create_uvc_device(uvc_device_info info) const override;
212  std::vector<uvc_device_info> query_uvc_devices() const override;
213 
214  std::shared_ptr<usb_device> create_usb_device(usb_device_info info) const override;
215  std::vector<usb_device_info> query_usb_devices() const override;
216 
217  std::shared_ptr<hid_device> create_hid_device(hid_device_info info) const override;
218  std::vector<hid_device_info> query_hid_devices() const override;
219 
220  std::shared_ptr<time_service> create_time_service() const override;
221  std::shared_ptr<device_watcher> create_device_watcher() const;
222  };
223  }
224 }
Definition: backend-v4l2.h:111
void lock()
Definition: backend-v4l2.h:57
Definition: backend.h:378
Definition: backend.h:650
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls...
Definition: rs_option.h:22
Definition: options.h:20
size_t get_length_frame_only() const
Definition: backend-v4l2.h:96
usb_spec
Definition: backend.h:180
power_state get_power_state() const override
Definition: backend-v4l2.h:161
Definition: backend-v4l2.h:80
Definition: algo.h:16
void init_xu(const extension_unit &xu) override
Definition: backend-v4l2.h:163
Definition: backend-v4l2.h:50
power_state
Definition: backend.h:123
void unlock()
Definition: backend-v4l2.h:58
Definition: backend.h:126
std::function< void(stream_profile, frame_object, std::function< void()>)> frame_callback
Definition: backend.h:177
named_mutex(const std::string &device_path, unsigned timeout)
Definition: backend.h:572
Definition: backend.h:375
std::string get_device_location() const override
Definition: backend-v4l2.h:179
Definition: backend.h:411
Definition: types.h:896
usb_spec get_usb_specification() const override
Definition: backend-v4l2.h:180
size_t get_full_length() const
Definition: backend-v4l2.h:95
Definition: backend-v4l2.h:208
Definition: backend.h:181
uint8_t * get_frame_start() const
Definition: backend-v4l2.h:98
Definition: backend-v4l2.h:133