Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
Loading...
Searching...
No Matches
rs_internal.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_INTERNAL_HPP
5#define LIBREALSENSE_RS2_INTERNAL_HPP
6
7#include "rs_types.hpp"
8#include "rs_device.hpp"
9#include "rs_context.hpp"
10#include "../h/rs_internal.h"
11
12namespace rs2
13{
15 {
16 public:
21 recording_context(const std::string& filename,
22 const std::string& section = "",
24 {
25 rs2_error* e = nullptr;
26 _context = std::shared_ptr<rs2_context>(
27 rs2_create_recording_context(RS2_API_VERSION, filename.c_str(), section.c_str(), mode, &e),
30 }
31
33 };
34
35 class mock_context : public context
36 {
37 public:
43 mock_context(const std::string& filename,
44 const std::string& section = "",
45 const std::string& min_api_version = "0.0.0")
46 {
47 rs2_error* e = nullptr;
48 _context = std::shared_ptr<rs2_context>(
49 rs2_create_mock_context_versioned(RS2_API_VERSION, filename.c_str(), section.c_str(), min_api_version.c_str(), &e),
52 }
53
54 mock_context() = delete;
55 };
56
57 namespace internal
58 {
62 inline double get_time()
63 {
64 rs2_error* e = nullptr;
65 auto time = rs2_get_time( &e);
66
68
69 return time;
70 }
71 }
72
73 template<class T>
75 {
76 T on_destruction_function;
77 public:
78 explicit software_device_destruction_callback(T on_destruction) : on_destruction_function(on_destruction) {}
79
80 void on_destruction() override
81 {
82 on_destruction_function();
83 }
84
85 void release() override { delete this; }
86 };
87
88 class software_sensor : public sensor
89 {
90 public:
96 stream_profile add_video_stream(rs2_video_stream video_stream, bool is_default=false)
97 {
98 rs2_error* e = nullptr;
99
100 auto profile = rs2_software_sensor_add_video_stream_ex(_sensor.get(), video_stream, is_default, &e);
101 error::handle(e);
102
103 stream_profile stream(profile);
104 return stream;
105 }
106
112 stream_profile add_motion_stream(rs2_motion_stream motion_stream, bool is_default=false)
113 {
114 rs2_error* e = nullptr;
115
116 auto profile = rs2_software_sensor_add_motion_stream_ex(_sensor.get(), motion_stream, is_default, &e);
117 error::handle(e);
118
119 stream_profile stream(profile);
120 return stream;
121 }
122
128 stream_profile add_pose_stream(rs2_pose_stream pose_stream, bool is_default=false)
129 {
130 rs2_error* e = nullptr;
131
132 auto profile = rs2_software_sensor_add_pose_stream_ex(_sensor.get(), pose_stream, is_default, &e);
133 error::handle(e);
134
135 stream_profile stream(profile);
136 return stream;
137 }
138
145 {
146 rs2_error* e = nullptr;
148 error::handle(e);
149 }
150
157 {
158 rs2_error* e = nullptr;
160 error::handle(e);
161 }
162
169 {
170 rs2_error* e = nullptr;
172 error::handle(e);
173 }
174
181 {
182 rs2_error* e = nullptr;
183 rs2_software_sensor_set_metadata(_sensor.get(), value, type, &e);
184 error::handle(e);
185 }
186
193 void add_read_only_option(rs2_option option, float val)
194 {
195 rs2_error* e = nullptr;
197 error::handle(e);
198 }
199
206 void set_read_only_option(rs2_option option, float val)
207 {
208 rs2_error* e = nullptr;
210 error::handle(e);
211 }
218 void add_option(rs2_option option, const option_range& range, bool is_writable=true)
219 {
220 rs2_error* e = nullptr;
221 rs2_software_sensor_add_option(_sensor.get(), option, range.min,
222 range.max, range.step, range.def, is_writable, &e);
223 error::handle(e);
224 }
225
227 {
228 rs2_error * e = nullptr;
230 error::handle(e);
231 }
237 void detach()
238 {
239 rs2_error * e = nullptr;
241 error::handle(e);
242 }
243
244 private:
245 friend class software_device;
246
247 software_sensor(std::shared_ptr<rs2_sensor> s)
248 : rs2::sensor(s)
249 {
250 rs2_error* e = nullptr;
252 {
253 _sensor = nullptr;
254 }
256 }
257 };
258
259
260 class software_device : public device
261 {
262 std::shared_ptr<rs2_device> create_device_ptr(std::function<void(rs2_device*)> deleter)
263 {
264 rs2_error* e = nullptr;
265 std::shared_ptr<rs2_device> dev(
267 deleter);
268 error::handle(e);
269 return dev;
270 }
271
272 public:
273 software_device(std::function<void(rs2_device*)> deleter = &rs2_delete_device)
274 : device(create_device_ptr(deleter))
275 {
276 this->set_destruction_callback([]{});
277 }
278
279 software_device(std::string name)
280 : device(create_device_ptr(&rs2_delete_device))
281 {
283 }
284
290 software_sensor add_sensor(std::string name)
291 {
292 rs2_error* e = nullptr;
293 std::shared_ptr<rs2_sensor> sensor(
294 rs2_software_device_add_sensor(_dev.get(), name.c_str(), &e),
296 error::handle(e);
297
298 return software_sensor(sensor);
299 }
300
305 template<class T>
306 void set_destruction_callback(T callback) const
307 {
308 rs2_error* e = nullptr;
310 new software_device_destruction_callback<T>(std::move(callback)), &e);
311 error::handle(e);
312 }
313
321 void add_to(context& ctx)
322 {
323 rs2_error* e = nullptr;
324 rs2_context_add_software_device(ctx._context.get(), _dev.get(), &e);
325 error::handle(e);
326 }
327
334 void register_info(rs2_camera_info info, const std::string& val)
335 {
336 rs2_error* e = nullptr;
337 rs2_software_device_register_info(_dev.get(), info, val.c_str(), &e);
338 error::handle(e);
339 }
340
347 void update_info(rs2_camera_info info, const std::string& val)
348 {
349 rs2_error* e = nullptr;
350 rs2_software_device_update_info(_dev.get(), info, val.c_str(), &e);
351 error::handle(e);
352 }
353
359 {
360 rs2_error* e = nullptr;
361 rs2_software_device_create_matcher(_dev.get(), matcher, &e);
362 error::handle(e);
363 }
364 };
365
367 {
368 public:
369 explicit firmware_log_message(std::shared_ptr<rs2_firmware_log_message> msg) :
370 _fw_log_message(msg) {}
371
373 rs2_error* e = nullptr;
374 rs2_log_severity severity = rs2_fw_log_message_severity(_fw_log_message.get(), &e);
375 error::handle(e);
376 return severity;
377 }
378 std::string get_severity_str() const {
380 }
381
382 uint32_t get_timestamp() const
383 {
384 rs2_error* e = nullptr;
385 uint32_t timestamp = rs2_fw_log_message_timestamp(_fw_log_message.get(), &e);
386 error::handle(e);
387 return timestamp;
388 }
389
390 int size() const
391 {
392 rs2_error* e = nullptr;
393 int size = rs2_fw_log_message_size(_fw_log_message.get(), &e);
394 error::handle(e);
395 return size;
396 }
397
398 std::vector<uint8_t> data() const
399 {
400 rs2_error* e = nullptr;
401 auto size = rs2_fw_log_message_size(_fw_log_message.get(), &e);
402 error::handle(e);
403 std::vector<uint8_t> result;
404 if (size > 0)
405 {
406 auto start = rs2_fw_log_message_data(_fw_log_message.get(), &e);
407 error::handle(e);
408 result.insert(result.begin(), start, start + size);
409 }
410 return result;
411 }
412
413 const std::shared_ptr<rs2_firmware_log_message> get_message() const { return _fw_log_message; }
414
415 private:
416 std::shared_ptr<rs2_firmware_log_message> _fw_log_message;
417 };
418
420 {
421 public:
422 explicit firmware_log_parsed_message(std::shared_ptr<rs2_firmware_log_parsed_message> msg) :
423 _parsed_fw_log(msg) {}
424
425 std::string message() const
426 {
427 rs2_error* e = nullptr;
428 std::string msg(rs2_get_fw_log_parsed_message(_parsed_fw_log.get(), &e));
429 error::handle(e);
430 return msg;
431 }
432 std::string file_name() const
433 {
434 rs2_error* e = nullptr;
435 std::string file_name(rs2_get_fw_log_parsed_file_name(_parsed_fw_log.get(), &e));
436 error::handle(e);
437 return file_name;
438 }
439 std::string thread_name() const
440 {
441 rs2_error* e = nullptr;
442 std::string thread_name(rs2_get_fw_log_parsed_thread_name(_parsed_fw_log.get(), &e));
443 error::handle(e);
444 return thread_name;
445 }
446 std::string severity() const
447 {
448 rs2_error* e = nullptr;
449 rs2_log_severity sev = rs2_get_fw_log_parsed_severity(_parsed_fw_log.get(), &e);
450 error::handle(e);
451 return std::string(rs2_log_severity_to_string(sev));
452 }
453 uint32_t line() const
454 {
455 rs2_error* e = nullptr;
456 uint32_t line(rs2_get_fw_log_parsed_line(_parsed_fw_log.get(), &e));
457 error::handle(e);
458 return line;
459 }
460 uint32_t timestamp() const
461 {
462 rs2_error* e = nullptr;
463 uint32_t timestamp(rs2_get_fw_log_parsed_timestamp(_parsed_fw_log.get(), &e));
464 error::handle(e);
465 return timestamp;
466 }
467
468 uint32_t sequence_id() const
469 {
470 rs2_error* e = nullptr;
471 uint32_t sequence(rs2_get_fw_log_parsed_sequence_id(_parsed_fw_log.get(), &e));
472 error::handle(e);
473 return sequence;
474 }
475
476 const std::shared_ptr<rs2_firmware_log_parsed_message> get_message() const { return _parsed_fw_log; }
477
478 private:
479 std::shared_ptr<rs2_firmware_log_parsed_message> _parsed_fw_log;
480 };
481
482 class firmware_logger : public device
483 {
484 public:
486 : device(d.get())
487 {
488 rs2_error* e = nullptr;
490 {
491 _dev.reset();
492 }
493 error::handle(e);
494 }
495
497 {
498 rs2_error* e = nullptr;
499 std::shared_ptr<rs2_firmware_log_message> msg(
502 error::handle(e);
503
504 return firmware_log_message(msg);
505 }
506
508 {
509 rs2_error* e = nullptr;
510 std::shared_ptr<rs2_firmware_log_parsed_message> msg(
513 error::handle(e);
514
515 return firmware_log_parsed_message(msg);
516 }
517
519 {
520 rs2_error* e = nullptr;
521 rs2_firmware_log_message* m = msg.get_message().get();
522 bool fw_log_pulling_status =
523 !!rs2_get_fw_log(_dev.get(), m, &e);
524
525 error::handle(e);
526
527 return fw_log_pulling_status;
528 }
529
531 {
532 rs2_error* e = nullptr;
533 rs2_firmware_log_message* m = msg.get_message().get();
534 bool flash_log_pulling_status =
535 !!rs2_get_flash_log(_dev.get(), m, &e);
536
537 error::handle(e);
538
539 return flash_log_pulling_status;
540 }
541
542 bool init_parser(const std::string& xml_content)
543 {
544 rs2_error* e = nullptr;
545
546 bool parser_initialized = !!rs2_init_fw_log_parser(_dev.get(), xml_content.c_str(), &e);
547 error::handle(e);
548
549 return parser_initialized;
550 }
551
553 {
554 rs2_error* e = nullptr;
555
556 bool parsingResult = !!rs2_parse_firmware_log(_dev.get(), msg.get_message().get(), parsed_msg.get_message().get(), &e);
557 error::handle(e);
558
559 return parsingResult;
560 }
561
562 unsigned int get_number_of_fw_logs() const
563 {
564 rs2_error* e = nullptr;
565 unsigned int num_of_fw_logs = rs2_get_number_of_fw_logs(_dev.get(), &e);
566 error::handle(e);
567
568 return num_of_fw_logs;
569 }
570 };
571
573 {
574 public:
575 terminal_parser(const std::string& xml_content)
576 {
577 rs2_error* e = nullptr;
578
579 _terminal_parser = std::shared_ptr<rs2_terminal_parser>(
580 rs2_create_terminal_parser(xml_content.c_str(), &e),
582 error::handle(e);
583 }
584
585 std::vector<uint8_t> parse_command(const std::string& command)
586 {
587 rs2_error* e = nullptr;
588
589 std::shared_ptr<const rs2_raw_data_buffer> list(
590 rs2_terminal_parse_command(_terminal_parser.get(), command.c_str(), (unsigned int)command.size(), &e),
592 error::handle(e);
593
594 auto size = rs2_get_raw_data_size(list.get(), &e);
595 error::handle(e);
596
597 auto start = rs2_get_raw_data(list.get(), &e);
598
599 std::vector<uint8_t> results;
600 results.insert(results.begin(), start, start + size);
601
602 return results;
603 }
604
605 std::string parse_response(const std::string& command, const std::vector<uint8_t>& response)
606 {
607 rs2_error* e = nullptr;
608
609 std::shared_ptr<const rs2_raw_data_buffer> list(
610 rs2_terminal_parse_response(_terminal_parser.get(), command.c_str(), (unsigned int)command.size(),
611 (void*)response.data(), (unsigned int)response.size(), &e),
613 error::handle(e);
614
615 auto size = rs2_get_raw_data_size(list.get(), &e);
616 error::handle(e);
617
618 auto start = rs2_get_raw_data(list.get(), &e);
619
620 std::string results;
621 results.insert(results.begin(), start, start + size);
622
623 return results;
624 }
625
626 private:
627 std::shared_ptr<rs2_terminal_parser> _terminal_parser;
628 };
629
630}
631#endif // LIBREALSENSE_RS2_INTERNAL_HPP
Definition: rs_context.hpp:97
std::shared_ptr< rs2_context > _context
Definition: rs_context.hpp:218
Definition: rs_device.hpp:19
const std::shared_ptr< rs2_device > & get() const
Definition: rs_device.hpp:116
std::shared_ptr< rs2_device > _dev
Definition: rs_device.hpp:146
static void handle(rs2_error *e)
Definition: rs_types.hpp:144
Definition: rs_internal.hpp:367
uint32_t get_timestamp() const
Definition: rs_internal.hpp:382
std::vector< uint8_t > data() const
Definition: rs_internal.hpp:398
rs2_log_severity get_severity() const
Definition: rs_internal.hpp:372
std::string get_severity_str() const
Definition: rs_internal.hpp:378
int size() const
Definition: rs_internal.hpp:390
firmware_log_message(std::shared_ptr< rs2_firmware_log_message > msg)
Definition: rs_internal.hpp:369
const std::shared_ptr< rs2_firmware_log_message > get_message() const
Definition: rs_internal.hpp:413
Definition: rs_internal.hpp:420
std::string file_name() const
Definition: rs_internal.hpp:432
std::string thread_name() const
Definition: rs_internal.hpp:439
firmware_log_parsed_message(std::shared_ptr< rs2_firmware_log_parsed_message > msg)
Definition: rs_internal.hpp:422
uint32_t timestamp() const
Definition: rs_internal.hpp:460
std::string message() const
Definition: rs_internal.hpp:425
std::string severity() const
Definition: rs_internal.hpp:446
uint32_t sequence_id() const
Definition: rs_internal.hpp:468
const std::shared_ptr< rs2_firmware_log_parsed_message > get_message() const
Definition: rs_internal.hpp:476
uint32_t line() const
Definition: rs_internal.hpp:453
Definition: rs_internal.hpp:483
rs2::firmware_log_message create_message()
Definition: rs_internal.hpp:496
firmware_logger(device d)
Definition: rs_internal.hpp:485
bool get_firmware_log(rs2::firmware_log_message &msg) const
Definition: rs_internal.hpp:518
rs2::firmware_log_parsed_message create_parsed_message()
Definition: rs_internal.hpp:507
bool init_parser(const std::string &xml_content)
Definition: rs_internal.hpp:542
bool parse_log(const rs2::firmware_log_message &msg, const rs2::firmware_log_parsed_message &parsed_msg)
Definition: rs_internal.hpp:552
bool get_flash_log(rs2::firmware_log_message &msg) const
Definition: rs_internal.hpp:530
unsigned int get_number_of_fw_logs() const
Definition: rs_internal.hpp:562
Definition: rs_frame.hpp:346
Definition: rs_internal.hpp:36
mock_context()=delete
mock_context(const std::string &filename, const std::string &section="", const std::string &min_api_version="0.0.0")
Definition: rs_internal.hpp:43
Definition: rs_internal.hpp:15
recording_context(const std::string &filename, const std::string &section="", rs2_recording_mode mode=RS2_RECORDING_MODE_BLANK_FRAMES)
Definition: rs_internal.hpp:21
Definition: rs_sensor.hpp:103
std::shared_ptr< rs2_sensor > _sensor
Definition: rs_sensor.hpp:352
Definition: rs_internal.hpp:75
software_device_destruction_callback(T on_destruction)
Definition: rs_internal.hpp:78
void on_destruction() override
Definition: rs_internal.hpp:80
void release() override
Definition: rs_internal.hpp:85
Definition: rs_internal.hpp:261
software_device(std::function< void(rs2_device *)> deleter=&rs2_delete_device)
Definition: rs_internal.hpp:273
software_sensor add_sensor(std::string name)
Definition: rs_internal.hpp:290
void set_destruction_callback(T callback) const
Definition: rs_internal.hpp:306
software_device(std::string name)
Definition: rs_internal.hpp:279
void add_to(context &ctx)
Definition: rs_internal.hpp:321
void register_info(rs2_camera_info info, const std::string &val)
Definition: rs_internal.hpp:334
void update_info(rs2_camera_info info, const std::string &val)
Definition: rs_internal.hpp:347
void create_matcher(rs2_matchers matcher)
Definition: rs_internal.hpp:358
Definition: rs_internal.hpp:89
void on_pose_frame(rs2_software_pose_frame frame)
Definition: rs_internal.hpp:168
stream_profile add_pose_stream(rs2_pose_stream pose_stream, bool is_default=false)
Definition: rs_internal.hpp:128
void set_metadata(rs2_frame_metadata_value value, rs2_metadata_type type)
Definition: rs_internal.hpp:180
void add_option(rs2_option option, const option_range &range, bool is_writable=true)
Definition: rs_internal.hpp:218
void set_read_only_option(rs2_option option, float val)
Definition: rs_internal.hpp:206
stream_profile add_video_stream(rs2_video_stream video_stream, bool is_default=false)
Definition: rs_internal.hpp:96
void add_read_only_option(rs2_option option, float val)
Definition: rs_internal.hpp:193
void detach()
Definition: rs_internal.hpp:237
void on_video_frame(rs2_software_video_frame frame)
Definition: rs_internal.hpp:144
void on_notification(rs2_software_notification notif)
Definition: rs_internal.hpp:226
void on_motion_frame(rs2_software_motion_frame frame)
Definition: rs_internal.hpp:156
stream_profile add_motion_stream(rs2_motion_stream motion_stream, bool is_default=false)
Definition: rs_internal.hpp:112
Definition: rs_frame.hpp:23
Definition: rs_internal.hpp:573
std::vector< uint8_t > parse_command(const std::string &command)
Definition: rs_internal.hpp:585
std::string parse_response(const std::string &command, const std::vector< uint8_t > &response)
Definition: rs_internal.hpp:605
terminal_parser(const std::string &xml_content)
Definition: rs_internal.hpp:575
double get_time()
Definition: rs_internal.hpp:62
Definition: rs_processing_gl.hpp:13
const unsigned char * rs2_get_raw_data(const rs2_raw_data_buffer *buffer, rs2_error **error)
rs2_time_t rs2_get_time(rs2_error **error)
int rs2_get_raw_data_size(const rs2_raw_data_buffer *buffer, rs2_error **error)
void rs2_delete_raw_data(const rs2_raw_data_buffer *buffer)
#define RS2_API_VERSION
Definition: rs.h:42
void rs2_delete_context(rs2_context *context)
Frees the relevant context object.
void rs2_context_add_software_device(rs2_context *ctx, rs2_device *dev, rs2_error **error)
void rs2_delete_device(rs2_device *device)
int rs2_is_device_extendable_to(const rs2_device *device, rs2_extension extension, rs2_error **error)
rs2_frame_metadata_value
Per-Frame-Metadata is the set of read-only properties that might be exposed for each individual frame...
Definition: rs_frame.h:30
rs2_firmware_log_message * rs2_create_fw_log_message(rs2_device *dev, rs2_error **error)
Creates RealSense firmware log message.
rs2_log_severity rs2_get_fw_log_parsed_severity(rs2_firmware_log_parsed_message *fw_log_parsed_msg, rs2_error **error)
Gets RealSense firmware log parsed message severity.
void rs2_software_device_update_info(rs2_device *dev, rs2_camera_info info, const char *val, rs2_error **error)
rs2_context * rs2_create_mock_context_versioned(int api_version, const char *filename, const char *section, const char *min_api_version, rs2_error **error)
rs2_stream_profile * rs2_software_sensor_add_pose_stream_ex(rs2_sensor *sensor, rs2_pose_stream pose_stream, int is_default, rs2_error **error)
unsigned int rs2_fw_log_message_timestamp(rs2_firmware_log_message *msg, rs2_error **error)
Gets RealSense firmware log message timestamp.
void rs2_delete_fw_log_parsed_message(rs2_firmware_log_parsed_message *fw_log_parsed_msg)
Deletes RealSense firmware log parsed message.
void rs2_software_sensor_set_metadata(rs2_sensor *sensor, rs2_frame_metadata_value value, rs2_metadata_type type, rs2_error **error)
void rs2_software_sensor_add_option(rs2_sensor *sensor, rs2_option option, float min, float max, float step, float def, int is_writable, rs2_error **error)
rs2_firmware_log_parsed_message * rs2_create_fw_log_parsed_message(rs2_device *dev, rs2_error **error)
Creates RealSense firmware log parsed message.
void rs2_software_sensor_on_pose_frame(rs2_sensor *sensor, rs2_software_pose_frame frame, rs2_error **error)
unsigned int rs2_get_number_of_fw_logs(rs2_device *dev, rs2_error **error)
Returns number of fw logs already polled from device but not by user yet.
unsigned int rs2_get_fw_log_parsed_sequence_id(rs2_firmware_log_parsed_message *fw_log_parsed_msg, rs2_error **error)
Gets RealSense firmware log parsed message sequence id - cyclic number of FW log with [0....
void rs2_software_sensor_on_notification(rs2_sensor *sensor, rs2_software_notification notif, rs2_error **error)
rs2_recording_mode
Definition: rs_internal.h:35
@ RS2_RECORDING_MODE_BLANK_FRAMES
Definition: rs_internal.h:36
void rs2_software_device_create_matcher(rs2_device *dev, rs2_matchers matcher, rs2_error **error)
void rs2_software_device_set_destruction_callback_cpp(const rs2_device *dev, rs2_software_device_destruction_callback *callback, rs2_error **error)
int rs2_parse_firmware_log(rs2_device *dev, rs2_firmware_log_message *fw_log_msg, rs2_firmware_log_parsed_message *parsed_msg, rs2_error **error)
Gets RealSense firmware log parser.
rs2_device * rs2_create_software_device(rs2_error **error)
const char * rs2_get_fw_log_parsed_file_name(rs2_firmware_log_parsed_message *fw_log_parsed_msg, rs2_error **error)
Gets RealSense firmware log parsed message file name.
rs2_context * rs2_create_recording_context(int api_version, const char *filename, const char *section, rs2_recording_mode mode, rs2_error **error)
rs2_raw_data_buffer * rs2_terminal_parse_response(rs2_terminal_parser *terminal_parser, const char *command, unsigned int size_of_command, const void *response, unsigned int size_of_response, rs2_error **error)
Parses terminal response via RealSense terminal parser.
void rs2_software_sensor_detach(rs2_sensor *sensor, rs2_error **error)
void rs2_software_sensor_update_read_only_option(rs2_sensor *sensor, rs2_option option, float val, rs2_error **error)
unsigned int rs2_get_fw_log_parsed_line(rs2_firmware_log_parsed_message *fw_log_parsed_msg, rs2_error **error)
Gets RealSense firmware log parsed message relevant line (in the file that is returned by rs2_get_fw_...
int rs2_get_fw_log(rs2_device *dev, rs2_firmware_log_message *fw_log_msg, rs2_error **error)
Gets RealSense firmware log.
rs2_stream_profile * rs2_software_sensor_add_motion_stream_ex(rs2_sensor *sensor, rs2_motion_stream motion_stream, int is_default, rs2_error **error)
void rs2_software_sensor_on_video_frame(rs2_sensor *sensor, rs2_software_video_frame frame, rs2_error **error)
int rs2_init_fw_log_parser(rs2_device *dev, const char *xml_content, rs2_error **error)
Initializes RealSense firmware logs parser in device.
int rs2_fw_log_message_size(rs2_firmware_log_message *msg, rs2_error **error)
Gets RealSense firmware log message size.
void rs2_software_sensor_add_read_only_option(rs2_sensor *sensor, rs2_option option, float val, rs2_error **error)
rs2_sensor * rs2_software_device_add_sensor(rs2_device *dev, const char *sensor_name, rs2_error **error)
int rs2_get_flash_log(rs2_device *dev, rs2_firmware_log_message *fw_log_msg, rs2_error **error)
Gets RealSense flash log - this is a fw log that has been written in the device during the previous s...
void rs2_delete_fw_log_message(rs2_firmware_log_message *msg)
rs2_stream_profile * rs2_software_sensor_add_video_stream_ex(rs2_sensor *sensor, rs2_video_stream video_stream, int is_default, rs2_error **error)
const char * rs2_get_fw_log_parsed_thread_name(rs2_firmware_log_parsed_message *fw_log_parsed_msg, rs2_error **error)
Gets RealSense firmware log parsed message thread name.
const char * rs2_get_fw_log_parsed_message(rs2_firmware_log_parsed_message *fw_log_parsed_msg, rs2_error **error)
Gets RealSense firmware log parsed message.
rs2_terminal_parser * rs2_create_terminal_parser(const char *xml_content, rs2_error **error)
Creates RealSense terminal parser.
void rs2_delete_terminal_parser(rs2_terminal_parser *terminal_parser)
Deletes RealSense terminal parser.
rs2_log_severity rs2_fw_log_message_severity(const rs2_firmware_log_message *msg, rs2_error **error)
Gets RealSense firmware log message severity.
const unsigned char * rs2_fw_log_message_data(rs2_firmware_log_message *msg, rs2_error **error)
Gets RealSense firmware log message data.
void rs2_software_device_register_info(rs2_device *dev, rs2_camera_info info, const char *val, rs2_error **error)
unsigned int rs2_get_fw_log_parsed_timestamp(rs2_firmware_log_parsed_message *fw_log_parsed_msg, rs2_error **error)
Gets RealSense firmware log parsed message timestamp.
rs2_raw_data_buffer * rs2_terminal_parse_command(rs2_terminal_parser *terminal_parser, const char *command, unsigned int size_of_command, rs2_error **error)
Parses terminal command via RealSense terminal parser.
void rs2_software_sensor_on_motion_frame(rs2_sensor *sensor, rs2_software_motion_frame frame, rs2_error **error)
rs2_option
Defines general configuration controls. These can generally be mapped to camera UVC controls,...
Definition: rs_option.h:23
int rs2_is_sensor_extendable_to(const rs2_sensor *sensor, rs2_extension extension, rs2_error **error)
void rs2_delete_sensor(rs2_sensor *sensor)
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
@ RS2_CAMERA_INFO_NAME
Definition: rs_sensor.h:23
rs2_log_severity
Severity of the librealsense logger.
Definition: rs_types.h:153
struct rs2_device rs2_device
Definition: rs_types.h:258
struct rs2_firmware_log_message rs2_firmware_log_message
Definition: rs_types.h:289
@ RS2_EXTENSION_FW_LOGGER
Definition: rs_types.h:215
@ RS2_EXTENSION_SOFTWARE_SENSOR
Definition: rs_types.h:192
const char * rs2_log_severity_to_string(rs2_log_severity info)
struct rs2_error rs2_error
Definition: rs_types.h:259
rs2_matchers
Specifies types of different matchers.
Definition: rs_types.h:231
long long rs2_metadata_type
Definition: rs_types.h:302
Definition: rs_types.hpp:177
float def
Definition: rs_types.hpp:180
float step
Definition: rs_types.hpp:181
float max
Definition: rs_types.hpp:179
float min
Definition: rs_types.hpp:178
All the parameters required to define a motion stream.
Definition: rs_internal.h:58
All the parameters required to define a pose stream.
Definition: rs_internal.h:69
Definition: rs_types.hpp:49
All the parameters required to define a motion frame.
Definition: rs_internal.h:93
All the parameters required to define a sensor notification.
Definition: rs_internal.h:126
All the parameters required to define a pose frame.
Definition: rs_internal.h:104
All the parameters required to define a video frame.
Definition: rs_internal.h:79
All the parameters required to define a video stream.
Definition: rs_internal.h:44