Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
rs_pipeline.hpp
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2017 Intel Corporation. All Rights Reserved.
3 
4 #ifndef LIBREALSENSE_RS2_PIPELINE_HPP
5 #define LIBREALSENSE_RS2_PIPELINE_HPP
6 
7 #include "rs_types.hpp"
8 #include "rs_frame.hpp"
9 #include "rs_context.hpp"
10 
11 namespace rs2
12 {
19  {
20  public:
21 
22  pipeline_profile() : _pipeline_profile(nullptr) {}
23 
29  std::vector<stream_profile> get_streams() const
30  {
31  std::vector<stream_profile> results;
32 
33  rs2_error* e = nullptr;
34  std::shared_ptr<rs2_stream_profile_list> list(
35  rs2_pipeline_profile_get_streams(_pipeline_profile.get(), &e),
37  error::handle(e);
38 
39  auto size = rs2_get_stream_profiles_count(list.get(), &e);
40  error::handle(e);
41 
42  for (auto i = 0; i < size; i++)
43  {
44  stream_profile profile(rs2_get_stream_profile(list.get(), i, &e));
45  error::handle(e);
46  results.push_back(profile);
47  }
48 
49  return results;
50  }
51 
60  stream_profile get_stream(rs2_stream stream_type, int stream_index = -1) const
61  {
62  for (auto&& s : get_streams())
63  {
64  if (s.stream_type() == stream_type && (stream_index == -1 || s.stream_index() == stream_index))
65  {
66  return s;
67  }
68  }
69  throw std::runtime_error("Profile does not contain the requested stream");
70  }
71 
84  {
85  rs2_error* e = nullptr;
86  std::shared_ptr<rs2_device> dev(
87  rs2_pipeline_profile_get_device(_pipeline_profile.get(), &e),
89 
90  error::handle(e);
91 
92  return device(dev);
93  }
94 
100  operator bool() const
101  {
102  return _pipeline_profile != nullptr;
103  }
104 
105  explicit operator std::shared_ptr<rs2_pipeline_profile>() { return _pipeline_profile; }
106  pipeline_profile(std::shared_ptr<rs2_pipeline_profile> profile) :
107  _pipeline_profile(profile){}
108  private:
109 
110  std::shared_ptr<rs2_pipeline_profile> _pipeline_profile;
111  friend class config;
112  friend class pipeline;
113  };
114 
115  class pipeline;
116 
124  class config
125  {
126  public:
128  {
129  rs2_error* e = nullptr;
130  _config = std::shared_ptr<rs2_config>(
131  rs2_create_config(&e),
133  error::handle(e);
134  }
135 
156  void enable_stream(rs2_stream stream_type, int stream_index, int width, int height, rs2_format format = RS2_FORMAT_ANY, int framerate = 0)
157  {
158  rs2_error* e = nullptr;
159  rs2_config_enable_stream(_config.get(), stream_type, stream_index, width, height, format, framerate, &e);
160  error::handle(e);
161  }
162 
163  //Stream type and possibly also stream index
164  void enable_stream(rs2_stream stream_type, int stream_index = -1)
165  {
166  enable_stream(stream_type, stream_index, 0, 0, RS2_FORMAT_ANY, 0);
167  }
168 
169  //Stream type and resolution, and possibly format and frame rate
170  void enable_stream(rs2_stream stream_type, int width, int height, rs2_format format = RS2_FORMAT_ANY, int framerate = 0)
171  {
172  enable_stream(stream_type, -1, width, height, format, framerate);
173  }
174 
175  //Stream type and format
176  void enable_stream(rs2_stream stream_type, rs2_format format, int framerate = 0)
177  {
178  enable_stream(stream_type, -1, 0, 0, format, framerate);
179  }
180 
181  //Stream type and format
182  void enable_stream(rs2_stream stream_type, int stream_index, rs2_format format, int framerate = 0)
183  {
184  enable_stream(stream_type, stream_index, 0, 0, format, framerate);
185  }
186 
194  {
195  rs2_error* e = nullptr;
196  rs2_config_enable_all_stream(_config.get(), &e);
197  error::handle(e);
198  }
199 
208  void enable_device(const std::string& serial)
209  {
210  rs2_error* e = nullptr;
211  rs2_config_enable_device(_config.get(), serial.c_str(), &e);
212  error::handle(e);
213  }
214 
223  void enable_device_from_file(const std::string& file_name, bool repeat_playback = true)
224  {
225  rs2_error* e = nullptr;
226  rs2_config_enable_device_from_file_repeat_option(_config.get(), file_name.c_str(), repeat_playback, &e);
227  error::handle(e);
228  }
229 
237  void enable_record_to_file(const std::string& file_name)
238  {
239  rs2_error* e = nullptr;
240  rs2_config_enable_record_to_file(_config.get(), file_name.c_str(), &e);
241  error::handle(e);
242  }
243 
251  void disable_stream(rs2_stream stream, int index = -1)
252  {
253  rs2_error* e = nullptr;
254  rs2_config_disable_indexed_stream(_config.get(), stream, index, &e);
255  error::handle(e);
256  }
257 
264  {
265  rs2_error* e = nullptr;
266  rs2_config_disable_all_streams(_config.get(), &e);
267  error::handle(e);
268  }
269 
288  pipeline_profile resolve(std::shared_ptr<rs2_pipeline> p) const
289  {
290  rs2_error* e = nullptr;
291  auto profile = std::shared_ptr<rs2_pipeline_profile>(
292  rs2_config_resolve(_config.get(), p.get(), &e),
294 
295  error::handle(e);
296  return pipeline_profile(profile);
297  }
298 
306  bool can_resolve(std::shared_ptr<rs2_pipeline> p) const
307  {
308  rs2_error* e = nullptr;
309  int res = rs2_config_can_resolve(_config.get(), p.get(), &e);
310  error::handle(e);
311  return res != 0;
312  }
313 
314  std::shared_ptr<rs2_config> get() const
315  {
316  return _config;
317  }
318  explicit operator std::shared_ptr<rs2_config>() const
319  {
320  return _config;
321  }
322 
323  config(std::shared_ptr<rs2_config> cfg) : _config(cfg) {}
324  private:
325  std::shared_ptr<rs2_config> _config;
326  };
327 
336  class pipeline
337  {
338  public:
339 
347  {
348  rs2_error* e = nullptr;
349  _pipeline = std::shared_ptr<rs2_pipeline>(
350  rs2_create_pipeline(ctx._context.get(), &e),
352  error::handle(e);
353  }
354 
367  {
368  rs2_error* e = nullptr;
369  auto p = std::shared_ptr<rs2_pipeline_profile>(
370  rs2_pipeline_start(_pipeline.get(), &e),
372 
373  error::handle(e);
374  return pipeline_profile(p);
375  }
376 
396  {
397  rs2_error* e = nullptr;
398  auto p = std::shared_ptr<rs2_pipeline_profile>(
399  rs2_pipeline_start_with_config(_pipeline.get(), config.get().get(), &e),
401 
402  error::handle(e);
403  return pipeline_profile(p);
404  }
405 
415  template<class S>
417  {
418  rs2_error* e = nullptr;
419  auto p = std::shared_ptr<rs2_pipeline_profile>(
420  rs2_pipeline_start_with_callback_cpp(_pipeline.get(), new frame_callback<S>(callback), &e),
422 
423  error::handle(e);
424  return pipeline_profile(p);
425  }
426 
443  template<class S>
444  pipeline_profile start(const config& config, S callback)
445  {
446  rs2_error* e = nullptr;
447  auto p = std::shared_ptr<rs2_pipeline_profile>(
448  rs2_pipeline_start_with_config_and_callback_cpp(_pipeline.get(), config.get().get(), new frame_callback<S>(callback), &e),
450 
451  error::handle(e);
452  return pipeline_profile(p);
453  }
454 
462  void stop()
463  {
464  rs2_error* e = nullptr;
465  rs2_pipeline_stop(_pipeline.get(), &e);
466  error::handle(e);
467  }
468 
484  frameset wait_for_frames(unsigned int timeout_ms = RS2_DEFAULT_TIMEOUT) const
485  {
486  rs2_error* e = nullptr;
487  frame f(rs2_pipeline_wait_for_frames(_pipeline.get(), timeout_ms, &e));
488  error::handle(e);
489 
490  return frameset(f);
491  }
492 
507  bool poll_for_frames(frameset* f) const
508  {
509  if (!f)
510  {
511  throw std::invalid_argument("null frameset");
512  }
513  rs2_error* e = nullptr;
514  rs2_frame* frame_ref = nullptr;
515  auto res = rs2_pipeline_poll_for_frames(_pipeline.get(), &frame_ref, &e);
516  error::handle(e);
517 
518  if (res) *f = frameset(frame(frame_ref));
519  return res > 0;
520  }
521 
522  bool try_wait_for_frames(frameset* f, unsigned int timeout_ms = RS2_DEFAULT_TIMEOUT) const
523  {
524  if (!f)
525  {
526  throw std::invalid_argument("null frameset");
527  }
528  rs2_error* e = nullptr;
529  rs2_frame* frame_ref = nullptr;
530  auto res = rs2_pipeline_try_wait_for_frames(_pipeline.get(), &frame_ref, timeout_ms, &e);
531  error::handle(e);
532  if (res) *f = frameset(frame(frame_ref));
533  return res > 0;
534  }
535 
546  {
547  rs2_error* e = nullptr;
548  auto p = std::shared_ptr<rs2_pipeline_profile>(
549  rs2_pipeline_get_active_profile(_pipeline.get(), &e),
551 
552  error::handle(e);
553  return pipeline_profile(p);
554  }
555 
556  operator std::shared_ptr<rs2_pipeline>() const
557  {
558  return _pipeline;
559  }
560  explicit pipeline(std::shared_ptr<rs2_pipeline> ptr) : _pipeline(ptr) {}
561 
562  private:
563  std::shared_ptr<rs2_pipeline> _pipeline;
564  friend class config;
565  };
566 }
567 #endif // LIBREALSENSE_RS2_PROCESSING_HPP
config(std::shared_ptr< rs2_config > cfg)
Definition: rs_pipeline.hpp:323
Definition: rs_frame.hpp:21
stream_profile get_stream(rs2_stream stream_type, int stream_index=-1) const
Definition: rs_pipeline.hpp:60
int rs2_pipeline_poll_for_frames(rs2_pipeline *pipe, rs2_frame **output_frame, rs2_error **error)
void rs2_config_enable_stream(rs2_config *config, rs2_stream stream, int index, int width, int height, rs2_format format, int framerate, rs2_error **error)
Definition: rs_pipeline.hpp:124
Definition: rs_frame.hpp:295
int rs2_pipeline_try_wait_for_frames(rs2_pipeline *pipe, rs2_frame **output_frame, unsigned int timeout_ms, rs2_error **error)
void stop()
Definition: rs_pipeline.hpp:462
rs2_pipeline_profile * rs2_config_resolve(rs2_config *config, rs2_pipeline *pipe, rs2_error **error)
pipeline_profile resolve(std::shared_ptr< rs2_pipeline > p) const
Definition: rs_pipeline.hpp:288
rs2_pipeline_profile * rs2_pipeline_start_with_callback_cpp(rs2_pipeline *pipe, rs2_frame_callback *callback, rs2_error **error)
bool poll_for_frames(frameset *f) const
Definition: rs_pipeline.hpp:507
pipeline_profile start(const config &config)
Definition: rs_pipeline.hpp:395
Definition: rs_pipeline.hpp:18
rs2_pipeline_profile * rs2_pipeline_start(rs2_pipeline *pipe, rs2_error **error)
void rs2_delete_device(rs2_device *device)
void rs2_config_disable_indexed_stream(rs2_config *config, rs2_stream stream, int index, rs2_error **error)
rs2_config * rs2_create_config(rs2_error **error)
rs2_pipeline * rs2_create_pipeline(rs2_context *ctx, rs2_error **error)
pipeline(std::shared_ptr< rs2_pipeline > ptr)
Definition: rs_pipeline.hpp:560
pipeline_profile start(const config &config, S callback)
Definition: rs_pipeline.hpp:444
void rs2_config_enable_record_to_file(rs2_config *config, const char *file, rs2_error **error)
pipeline(context ctx=context())
Definition: rs_pipeline.hpp:346
Definition: rs_frame.hpp:830
Definition: rs_context.hpp:11
void enable_device(const std::string &serial)
Definition: rs_pipeline.hpp:208
rs2_pipeline_profile * rs2_pipeline_get_active_profile(rs2_pipeline *pipe, rs2_error **error)
std::shared_ptr< rs2_config > get() const
Definition: rs_pipeline.hpp:314
Definition: rs_context.hpp:96
void rs2_config_enable_all_stream(rs2_config *config, rs2_error **error)
void enable_stream(rs2_stream stream_type, int stream_index, rs2_format format, int framerate=0)
Definition: rs_pipeline.hpp:182
rs2_device * rs2_pipeline_profile_get_device(rs2_pipeline_profile *profile, rs2_error **error)
rs2_pipeline_profile * rs2_pipeline_start_with_config_and_callback_cpp(rs2_pipeline *pipe, rs2_config *config, rs2_frame_callback *callback, rs2_error **error)
pipeline_profile start(S callback)
Definition: rs_pipeline.hpp:416
Definition: rs_frame.hpp:1045
rs2_stream_profile_list * rs2_pipeline_profile_get_streams(rs2_pipeline_profile *profile, rs2_error **error)
rs2_frame * rs2_pipeline_wait_for_frames(rs2_pipeline *pipe, unsigned int timeout_ms, rs2_error **error)
frameset wait_for_frames(unsigned int timeout_ms=RS2_DEFAULT_TIMEOUT) const
Definition: rs_pipeline.hpp:484
void rs2_config_disable_all_streams(rs2_config *config, rs2_error **error)
void disable_all_streams()
Definition: rs_pipeline.hpp:263
std::vector< stream_profile > get_streams() const
Definition: rs_pipeline.hpp:29
int rs2_config_can_resolve(rs2_config *config, rs2_pipeline *pipe, rs2_error **error)
device get_device() const
Definition: rs_pipeline.hpp:83
const rs2_stream_profile * rs2_get_stream_profile(const rs2_stream_profile_list *list, int index, rs2_error **error)
void disable_stream(rs2_stream stream, int index=-1)
Definition: rs_pipeline.hpp:251
Definition: rs_sensor.h:57
rs2_format
Format identifies how binary data is encoded within a frame.
Definition: rs_sensor.h:55
#define RS2_DEFAULT_TIMEOUT
Definition: rs_config.h:13
pipeline_profile get_active_profile() const
Definition: rs_pipeline.hpp:545
pipeline_profile(std::shared_ptr< rs2_pipeline_profile > profile)
Definition: rs_pipeline.hpp:106
void rs2_config_enable_device_from_file_repeat_option(rs2_config *config, const char *file, int repeat_playback, rs2_error **error)
void enable_all_streams()
Definition: rs_pipeline.hpp:193
void enable_stream(rs2_stream stream_type, int stream_index, int width, int height, rs2_format format=RS2_FORMAT_ANY, int framerate=0)
Definition: rs_pipeline.hpp:156
static void handle(rs2_error *e)
Definition: rs_types.hpp:121
rs2_stream
Streams are different types of data provided by RealSense devices.
Definition: rs_sensor.h:38
rs2_pipeline_profile * rs2_pipeline_start_with_config(rs2_pipeline *pipe, rs2_config *config, rs2_error **error)
config()
Definition: rs_pipeline.hpp:127
Definition: rs_pipeline.hpp:336
void enable_stream(rs2_stream stream_type, int width, int height, rs2_format format=RS2_FORMAT_ANY, int framerate=0)
Definition: rs_pipeline.hpp:170
void enable_record_to_file(const std::string &file_name)
Definition: rs_pipeline.hpp:237
void rs2_delete_stream_profiles_list(rs2_stream_profile_list *list)
void rs2_pipeline_stop(rs2_pipeline *pipe, rs2_error **error)
void enable_stream(rs2_stream stream_type, int stream_index=-1)
Definition: rs_pipeline.hpp:164
void rs2_delete_config(rs2_config *config)
void enable_device_from_file(const std::string &file_name, bool repeat_playback=true)
Definition: rs_pipeline.hpp:223
void rs2_config_enable_device(rs2_config *config, const char *serial, rs2_error **error)
pipeline_profile start()
Definition: rs_pipeline.hpp:366
int rs2_get_stream_profiles_count(const rs2_stream_profile_list *list, rs2_error **error)
bool can_resolve(std::shared_ptr< rs2_pipeline > p) const
Definition: rs_pipeline.hpp:306
struct rs2_error rs2_error
Definition: rs_types.h:204
Definition: rs_device.hpp:18
void rs2_delete_pipeline_profile(rs2_pipeline_profile *profile)
bool try_wait_for_frames(frameset *f, unsigned int timeout_ms=RS2_DEFAULT_TIMEOUT) const
Definition: rs_pipeline.hpp:522
void rs2_delete_pipeline(rs2_pipeline *pipe)
struct rs2_frame rs2_frame
Definition: rs_types.h:206
pipeline_profile()
Definition: rs_pipeline.hpp:22
void enable_stream(rs2_stream stream_type, rs2_format format, int framerate=0)
Definition: rs_pipeline.hpp:176