Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
Loading...
Searching...
No Matches
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
11namespace 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),
38
39 auto size = rs2_get_stream_profiles_count(list.get(), &e);
41
42 for (auto i = 0; i < size; i++)
43 {
44 stream_profile profile(rs2_get_stream_profile(list.get(), i, &e));
46 results.push_back(profile);
47 }
48
49 return results;
50 }
51
59
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
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>(
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
169 void enable_stream(rs2_stream stream_type, int stream_index = -1)
170 {
171 enable_stream(stream_type, stream_index, 0, 0, RS2_FORMAT_ANY, 0);
172 }
173
183 void enable_stream(rs2_stream stream_type, int width, int height, rs2_format format = RS2_FORMAT_ANY, int framerate = 0)
184 {
185 enable_stream(stream_type, -1, width, height, format, framerate);
186 }
187
195 void enable_stream(rs2_stream stream_type, rs2_format format, int framerate = 0)
196 {
197 enable_stream(stream_type, -1, 0, 0, format, framerate);
198 }
199
208 void enable_stream(rs2_stream stream_type, int stream_index, rs2_format format, int framerate = 0)
209 {
210 enable_stream(stream_type, stream_index, 0, 0, format, framerate);
211 }
212
220 {
221 rs2_error* e = nullptr;
222 rs2_config_enable_all_stream(_config.get(), &e);
223 error::handle(e);
224 }
225
234 void enable_device(const std::string& serial)
235 {
236 rs2_error* e = nullptr;
237 rs2_config_enable_device(_config.get(), serial.c_str(), &e);
238 error::handle(e);
239 }
240
249 void enable_device_from_file(const std::string& file_name, bool repeat_playback = true)
250 {
251 rs2_error* e = nullptr;
252 rs2_config_enable_device_from_file_repeat_option(_config.get(), file_name.c_str(), repeat_playback, &e);
253 error::handle(e);
254 }
255
263 void enable_record_to_file(const std::string& file_name)
264 {
265 rs2_error* e = nullptr;
266 rs2_config_enable_record_to_file(_config.get(), file_name.c_str(), &e);
267 error::handle(e);
268 }
269
277 void disable_stream(rs2_stream stream, int index = -1)
278 {
279 rs2_error* e = nullptr;
280 rs2_config_disable_indexed_stream(_config.get(), stream, index, &e);
281 error::handle(e);
282 }
283
290 {
291 rs2_error* e = nullptr;
292 rs2_config_disable_all_streams(_config.get(), &e);
293 error::handle(e);
294 }
295
314 pipeline_profile resolve(std::shared_ptr<rs2_pipeline> p) const
315 {
316 rs2_error* e = nullptr;
317 auto profile = std::shared_ptr<rs2_pipeline_profile>(
318 rs2_config_resolve(_config.get(), p.get(), &e),
320
321 error::handle(e);
322 return pipeline_profile(profile);
323 }
324
332 bool can_resolve(std::shared_ptr<rs2_pipeline> p) const
333 {
334 rs2_error* e = nullptr;
335 int res = rs2_config_can_resolve(_config.get(), p.get(), &e);
336 error::handle(e);
337 return res != 0;
338 }
339
340 std::shared_ptr<rs2_config> get() const
341 {
342 return _config;
343 }
344 explicit operator std::shared_ptr<rs2_config>() const
345 {
346 return _config;
347 }
348
349 config(std::shared_ptr<rs2_config> cfg) : _config(cfg) {}
350 private:
351 std::shared_ptr<rs2_config> _config;
352 };
353
363 {
364 public:
365
373 {
374 rs2_error* e = nullptr;
375 _pipeline = std::shared_ptr<rs2_pipeline>(
376 rs2_create_pipeline(ctx._context.get(), &e),
378 error::handle(e);
379 }
380
393 {
394 rs2_error* e = nullptr;
395 auto p = std::shared_ptr<rs2_pipeline_profile>(
396 rs2_pipeline_start(_pipeline.get(), &e),
398
399 error::handle(e);
400 return pipeline_profile(p);
401 }
402
422 {
423 rs2_error* e = nullptr;
424 auto p = std::shared_ptr<rs2_pipeline_profile>(
425 rs2_pipeline_start_with_config(_pipeline.get(), config.get().get(), &e),
427
428 error::handle(e);
429 return pipeline_profile(p);
430 }
431
441 template<class S>
443 {
444 rs2_error* e = nullptr;
445 auto p = std::shared_ptr<rs2_pipeline_profile>(
446 rs2_pipeline_start_with_callback_cpp(_pipeline.get(), new frame_callback<S>(callback), &e),
448
449 error::handle(e);
450 return pipeline_profile(p);
451 }
452
469 template<class S>
471 {
472 rs2_error* e = nullptr;
473 auto p = std::shared_ptr<rs2_pipeline_profile>(
474 rs2_pipeline_start_with_config_and_callback_cpp(_pipeline.get(), config.get().get(), new frame_callback<S>(callback), &e),
476
477 error::handle(e);
478 return pipeline_profile(p);
479 }
480
488 void stop()
489 {
490 rs2_error* e = nullptr;
491 rs2_pipeline_stop(_pipeline.get(), &e);
492 error::handle(e);
493 }
494
501 {
502 rs2_error * e = nullptr;
503 rs2_pipeline_set_device( _pipeline.get(), device->get().get(), &e );
504 error::handle( e );
505 }
506
522 frameset wait_for_frames(unsigned int timeout_ms = RS2_DEFAULT_TIMEOUT) const
523 {
524 rs2_error* e = nullptr;
525 frame f(rs2_pipeline_wait_for_frames(_pipeline.get(), timeout_ms, &e));
526 error::handle(e);
527
528 return frameset(f);
529 }
530
546 {
547 if (!f)
548 {
549 throw std::invalid_argument("null frameset");
550 }
551 rs2_error* e = nullptr;
552 rs2_frame* frame_ref = nullptr;
553 auto res = rs2_pipeline_poll_for_frames(_pipeline.get(), &frame_ref, &e);
554 error::handle(e);
555
556 if (res) *f = frameset(frame(frame_ref));
557 return res > 0;
558 }
559
560 bool try_wait_for_frames(frameset* f, unsigned int timeout_ms = RS2_DEFAULT_TIMEOUT) const
561 {
562 if (!f)
563 {
564 throw std::invalid_argument("null frameset");
565 }
566 rs2_error* e = nullptr;
567 rs2_frame* frame_ref = nullptr;
568 auto res = rs2_pipeline_try_wait_for_frames(_pipeline.get(), &frame_ref, timeout_ms, &e);
569 error::handle(e);
570 if (res) *f = frameset(frame(frame_ref));
571 return res > 0;
572 }
573
584 {
585 rs2_error* e = nullptr;
586 auto p = std::shared_ptr<rs2_pipeline_profile>(
587 rs2_pipeline_get_active_profile(_pipeline.get(), &e),
589
590 error::handle(e);
591 return pipeline_profile(p);
592 }
593
594 operator std::shared_ptr<rs2_pipeline>() const
595 {
596 return _pipeline;
597 }
598 explicit pipeline(std::shared_ptr<rs2_pipeline> ptr) : _pipeline(ptr) {}
599
600 private:
601 std::shared_ptr<rs2_pipeline> _pipeline;
602 friend class config;
603 };
604}
605#endif // LIBREALSENSE_RS2_PROCESSING_HPP
config(std::shared_ptr< rs2_config > cfg)
Definition rs_pipeline.hpp:349
std::shared_ptr< rs2_config > get() const
Definition rs_pipeline.hpp:340
bool can_resolve(std::shared_ptr< rs2_pipeline > p) const
Definition rs_pipeline.hpp:332
void enable_stream(rs2_stream stream_type, int stream_index=-1)
Definition rs_pipeline.hpp:169
void enable_device(const std::string &serial)
Definition rs_pipeline.hpp:234
void enable_device_from_file(const std::string &file_name, bool repeat_playback=true)
Definition rs_pipeline.hpp:249
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
void enable_stream(rs2_stream stream_type, rs2_format format, int framerate=0)
Definition rs_pipeline.hpp:195
void enable_record_to_file(const std::string &file_name)
Definition rs_pipeline.hpp:263
config()
Definition rs_pipeline.hpp:127
void disable_stream(rs2_stream stream, int index=-1)
Definition rs_pipeline.hpp:277
void disable_all_streams()
Definition rs_pipeline.hpp:289
void enable_stream(rs2_stream stream_type, int width, int height, rs2_format format=RS2_FORMAT_ANY, int framerate=0)
Definition rs_pipeline.hpp:183
void enable_all_streams()
Definition rs_pipeline.hpp:219
void enable_stream(rs2_stream stream_type, int stream_index, rs2_format format, int framerate=0)
Definition rs_pipeline.hpp:208
pipeline_profile resolve(std::shared_ptr< rs2_pipeline > p) const
Definition rs_pipeline.hpp:314
Definition rs_context.hpp:97
Definition rs_device.hpp:20
const std::shared_ptr< rs2_device > & get() const
Definition rs_device.hpp:162
static void handle(rs2_error *e)
Definition rs_types.hpp:162
Definition rs_frame.hpp:1181
Definition rs_frame.hpp:346
Definition rs_frame.hpp:958
Definition rs_pipeline.hpp:19
friend class config
Definition rs_pipeline.hpp:111
friend class pipeline
Definition rs_pipeline.hpp:112
pipeline_profile()
Definition rs_pipeline.hpp:22
std::vector< stream_profile > get_streams() const
Definition rs_pipeline.hpp:29
pipeline_profile(std::shared_ptr< rs2_pipeline_profile > profile)
Definition rs_pipeline.hpp:106
stream_profile get_stream(rs2_stream stream_type, int stream_index=-1) const
Definition rs_pipeline.hpp:60
device get_device() const
Definition rs_pipeline.hpp:83
Definition rs_pipeline.hpp:363
void set_device(rs2::device *device)
Definition rs_pipeline.hpp:500
void stop()
Definition rs_pipeline.hpp:488
pipeline(std::shared_ptr< rs2_pipeline > ptr)
Definition rs_pipeline.hpp:598
pipeline_profile start(const config &config, S callback)
Definition rs_pipeline.hpp:470
friend class config
Definition rs_pipeline.hpp:602
pipeline_profile get_active_profile() const
Definition rs_pipeline.hpp:583
pipeline_profile start()
Definition rs_pipeline.hpp:392
bool poll_for_frames(frameset *f) const
Definition rs_pipeline.hpp:545
pipeline_profile start(const config &config)
Definition rs_pipeline.hpp:421
pipeline(context ctx=context())
Definition rs_pipeline.hpp:372
bool try_wait_for_frames(frameset *f, unsigned int timeout_ms=RS2_DEFAULT_TIMEOUT) const
Definition rs_pipeline.hpp:560
frameset wait_for_frames(unsigned int timeout_ms=RS2_DEFAULT_TIMEOUT) const
Definition rs_pipeline.hpp:522
pipeline_profile start(S callback)
Definition rs_pipeline.hpp:442
Definition rs_frame.hpp:23
Definition rs_processing_gl.hpp:13
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)
void rs2_delete_config(rs2_config *config)
rs2_pipeline_profile * rs2_config_resolve(rs2_config *config, rs2_pipeline *pipe, rs2_error **error)
int rs2_config_can_resolve(rs2_config *config, rs2_pipeline *pipe, rs2_error **error)
void rs2_config_disable_indexed_stream(rs2_config *config, rs2_stream stream, int index, rs2_error **error)
void rs2_config_enable_device(rs2_config *config, const char *serial, rs2_error **error)
#define RS2_DEFAULT_TIMEOUT
Definition rs_config.h:13
void rs2_config_enable_device_from_file_repeat_option(rs2_config *config, const char *file, int repeat_playback, rs2_error **error)
void rs2_config_disable_all_streams(rs2_config *config, rs2_error **error)
rs2_config * rs2_create_config(rs2_error **error)
void rs2_config_enable_record_to_file(rs2_config *config, const char *file, rs2_error **error)
void rs2_config_enable_all_stream(rs2_config *config, rs2_error **error)
void rs2_delete_device(rs2_device *device)
rs2_pipeline_profile * rs2_pipeline_start_with_config_and_callback_cpp(rs2_pipeline *pipe, rs2_config *config, rs2_frame_callback *callback, rs2_error **error)
void rs2_delete_pipeline(rs2_pipeline *pipe)
void rs2_delete_pipeline_profile(rs2_pipeline_profile *profile)
rs2_pipeline_profile * rs2_pipeline_start_with_callback_cpp(rs2_pipeline *pipe, rs2_frame_callback *callback, rs2_error **error)
rs2_stream_profile_list * rs2_pipeline_profile_get_streams(rs2_pipeline_profile *profile, rs2_error **error)
rs2_pipeline_profile * rs2_pipeline_start(rs2_pipeline *pipe, rs2_error **error)
rs2_pipeline_profile * rs2_pipeline_start_with_config(rs2_pipeline *pipe, rs2_config *config, rs2_error **error)
void rs2_pipeline_set_device(rs2_pipeline *pipe, rs2_device *device, rs2_error **error)
rs2_pipeline * rs2_create_pipeline(rs2_context *ctx, rs2_error **error)
rs2_pipeline_profile * rs2_pipeline_get_active_profile(rs2_pipeline *pipe, rs2_error **error)
rs2_device * rs2_pipeline_profile_get_device(rs2_pipeline_profile *profile, rs2_error **error)
rs2_frame * rs2_pipeline_wait_for_frames(rs2_pipeline *pipe, unsigned int timeout_ms, rs2_error **error)
int rs2_pipeline_try_wait_for_frames(rs2_pipeline *pipe, rs2_frame **output_frame, unsigned int timeout_ms, rs2_error **error)
void rs2_pipeline_stop(rs2_pipeline *pipe, rs2_error **error)
int rs2_pipeline_poll_for_frames(rs2_pipeline *pipe, rs2_frame **output_frame, rs2_error **error)
rs2_stream
Streams are different types of data provided by RealSense devices.
Definition rs_sensor.h:44
const rs2_stream_profile * rs2_get_stream_profile(const rs2_stream_profile_list *list, int index, rs2_error **error)
void rs2_delete_stream_profiles_list(rs2_stream_profile_list *list)
int rs2_get_stream_profiles_count(const rs2_stream_profile_list *list, rs2_error **error)
rs2_format
A stream's format identifies how binary data is encoded within a frame.
Definition rs_sensor.h:62
@ RS2_FORMAT_ANY
Definition rs_sensor.h:63
struct rs2_error rs2_error
Definition rs_types.h:230
struct rs2_frame rs2_frame
Definition rs_types.h:233