V217 branch pull request.

README.md

@@ -6,13 +6,14 @@ This repos is openFrameworks addon fo [Intel® RealSense™ SDK 2.0](https://git
 
 ## Version
 - Realsense 2.14.1 (released on 2018.7)
+	- linux : Realsense SDK 2.17.0
 - libusb 1.0.22
 - openFrameworks 0.10.0
 
 ## TODO
 - [x] OSX support
 - [x] Windows support
-- [ ] Linux support
+- [x] Linux support	- v2.17.0 updated
 - [x] add ci scripts
 - [ ] add postprocessing example
 - [ ] add bag file playback example
@@ -56,4 +57,4 @@ Unplug and plug camera again if you see strange data.
 
 ## Notice
 ### libusb in osx
-- libusb is NOT included in this repo. Should be installed to your system with 'brew install libusb' at first SDK install step.
+- libusb is NOT included in this repo. Should be installed to your system with 'brew install libusb' at first SDK install step.

addon_config.mk

@@ -26,6 +26,8 @@ vs:
 	ADDON_DLLS_TO_COPY  = dlls_to_copy
 
 linux64:
+	ADDON_LDFLAGS = ../../../addons/ofxRealsense2/libs/realsense2/lib/linux64/librealsense2.so
+
 linuxarmv6l:
 linuxarmv7l:
 msys2:

libs/realsense2/include/librealsense2/h/rs_config.h

@@ -0,0 +1,198 @@
+/* License: Apache 2.0. See LICENSE file in root directory.
+Copyright(c) 2017 Intel Corporation. All Rights Reserved. */
+
+/** \file rs_pipeline.h
+* \brief
+* Exposes RealSense processing-block functionality for C compilers
+*/
+
+
+#ifndef LIBREALSENSE_RS2_CONFIG_H
+#define LIBREALSENSE_RS2_CONFIG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "rs_types.h"
+#include "rs_sensor.h"
+
+    /**
+    * Create a config instance
+    * The config allows pipeline users to request filters for the pipeline streams and device selection and configuration.
+    * This is an optional step in pipeline creation, as the pipeline resolves its streaming device internally.
+    * Config provides its users a way to set the filters and test if there is no conflict with the pipeline requirements
+    * from the device. It also allows the user to find a matching device for the config filters and the pipeline, in order to
+    * select a device explicitly, and modify its controls before streaming starts.
+    *
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    * \return rs2_config*  A pointer to a new config instance
+    */
+    rs2_config* rs2_create_config(rs2_error** error);
+
+    /**
+    * Deletes an instance of a config
+    *
+    * \param[in] config    A pointer to an instance of a config
+    */
+    void rs2_delete_config(rs2_config* config);
+
+    /**
+    * Enable a device stream explicitly, with selected stream parameters.
+    * The method allows the application to request a stream with specific configuration. If no stream is explicitly enabled, the pipeline
+    * configures the device and its streams according to the attached computer vision modules and processing blocks requirements, or
+    * default configuration for the first available device.
+    * The application can configure any of the input stream parameters according to its requirement, or set to 0 for don't care value.
+    * The config accumulates the application calls for enable configuration methods, until the configuration is applied. Multiple enable
+    * stream calls for the same stream with conflicting parameters override each other, and the last call is maintained.
+    * Upon calling \c resolve(), the config checks for conflicts between the application configuration requests and the attached computer
+    * vision modules and processing blocks requirements, and fails if conflicts are found. Before \c resolve() is called, no conflict
+    * check is done.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] stream    Stream type to be enabled
+    * \param[in] index     Stream index, used for multiple streams of the same type. -1 indicates any.
+    * \param[in] width     Stream image width - for images streams. 0 indicates any.
+    * \param[in] height    Stream image height - for images streams. 0 indicates any.
+    * \param[in] format    Stream data format - pixel format for images streams, of data type for other streams. RS2_FORMAT_ANY indicates any.
+    * \param[in] framerate Stream frames per second. 0 indicates any.
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    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);
+
+    /**
+    * Enable all device streams explicitly.
+    * The conditions and behavior of this method are similar to those of \c enable_stream().
+    * This filter enables all raw streams of the selected device. The device is either selected explicitly by the application,
+    * or by the pipeline requirements or default. The list of streams is device dependent.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_enable_all_stream(rs2_config* config, rs2_error ** error);
+
+    /**
+    * Select a specific device explicitly by its serial number, to be used by the pipeline.
+    * The conditions and behavior of this method are similar to those of \c enable_stream().
+    * This method is required if the application needs to set device or sensor settings prior to pipeline streaming, to enforce
+    * the pipeline to use the configured device.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] serial device serial number, as returned by RS2_CAMERA_INFO_SERIAL_NUMBER
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_enable_device(rs2_config* config, const char* serial, rs2_error ** error);
+
+    /**
+    * Select a recorded device from a file, to be used by the pipeline through playback.
+    * The device available streams are as recorded to the file, and \c resolve() considers only this device and configuration
+    * as available.
+    * This request cannot be used if enable_record_to_file() is called for the current config, and vise versa
+    * By default, playback is repeated once the file ends. To control this, see 'rs2_config_enable_device_from_file_repeat_option'.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] file      The playback file of the device
+    * \param[out] error    if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_enable_device_from_file(rs2_config* config, const char* file, rs2_error ** error);
+
+    /**
+    * Select a recorded device from a file, to be used by the pipeline through playback.
+    * The device available streams are as recorded to the file, and \c resolve() considers only this device and configuration
+    * as available.
+    * This request cannot be used if enable_record_to_file() is called for the current config, and vise versa
+    *
+    * \param[in] config           A pointer to an instance of a config
+    * \param[in] file             The playback file of the device
+    * \param[in] repeat_playback  if true, when file ends the playback starts again, in an infinite loop;
+                                  if false, when file ends playback does not start again, and should by stopped manually by the user.
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_enable_device_from_file_repeat_option(rs2_config* config, const char* file, int repeat_playback, rs2_error ** error);
+
+    /**
+    * Requires that the resolved device would be recorded to file
+    * This request cannot be used if enable_device_from_file() is called for the current config, and vise versa
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] file      The desired file for the output record
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_enable_record_to_file(rs2_config* config, const char* file, rs2_error ** error);
+
+
+    /**
+    * Disable a device stream explicitly, to remove any requests on this stream type.
+    * The stream can still be enabled due to pipeline computer vision module request. This call removes any filter on the
+    * stream configuration.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] stream    Stream type, for which the filters are cleared
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_disable_stream(rs2_config* config, rs2_stream stream, rs2_error ** error);
+
+    /**
+    * Disable a device stream explicitly, to remove any requests on this stream profile.
+    * The stream can still be enabled due to pipeline computer vision module request. This call removes any filter on the
+    * stream configuration.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] stream    Stream type, for which the filters are cleared
+    * \param[in] index     Stream index, for which the filters are cleared
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_disable_indexed_stream(rs2_config* config, rs2_stream stream, int index, rs2_error ** error);
+
+    /**
+    * Disable all device stream explicitly, to remove any requests on the streams profiles.
+    * The streams can still be enabled due to pipeline computer vision module request. This call removes any filter on the
+    * streams configuration.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    */
+    void rs2_config_disable_all_streams(rs2_config* config, rs2_error ** error);
+
+    /**
+    * Resolve the configuration filters, to find a matching device and streams profiles.
+    * The method resolves the user configuration filters for the device and streams, and combines them with the requirements of
+    * the computer vision modules and processing blocks attached to the pipeline. If there are no conflicts of requests, it looks
+    * for an available device, which can satisfy all requests, and selects the first matching streams configuration. In the absence
+    * of any request, the rs2::config selects the first available device and the first color and depth streams configuration.
+    * The pipeline profile selection during \c start() follows the same method. Thus, the selected profile is the same, if no
+    * change occurs to the available devices occurs.
+    * Resolving the pipeline configuration provides the application access to the pipeline selected device for advanced control.
+    * The returned configuration is not applied to the device, so the application doesn't own the device sensors. However, the
+    * application can call \c enable_device(), to enforce the device returned by this method is selected by pipeline \c start(),
+    * and configure the device and sensors options or extensions before streaming starts.
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] pipe  The pipeline for which the selected filters are applied
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    * \return       A matching device and streams profile, which satisfies the filters and pipeline requests.
+    */
+    rs2_pipeline_profile* rs2_config_resolve(rs2_config* config, rs2_pipeline* pipe, rs2_error ** error);
+
+    /**
+    * Check if the config can resolve the configuration filters, to find a matching device and streams profiles.
+    * The resolution conditions are as described in \c resolve().
+    *
+    * \param[in] config    A pointer to an instance of a config
+    * \param[in] pipe  The pipeline for which the selected filters are applied
+    * \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+    * \return       True if a valid profile selection exists, false if no selection can be found under the config filters and the available devices.
+    */
+    int rs2_config_can_resolve(rs2_config* config, rs2_pipeline* pipe, rs2_error ** error);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

libs/realsense2/include/librealsense2/h/rs_context.h

@@ -71,6 +71,21 @@ void rs2_context_remove_device(rs2_context* ctx, const char* file, rs2_error** e
 */
 rs2_device_list* rs2_query_devices(const rs2_context* context, rs2_error** error);
 
+#define RS2_PRODUCT_LINE_ANY        0xff
+#define RS2_PRODUCT_LINE_ANY_INTEL  0xfe
+#define RS2_PRODUCT_LINE_NON_INTEL  0x01
+#define RS2_PRODUCT_LINE_D400       0x02
+#define RS2_PRODUCT_LINE_SR300      0x04
+
+/**
+* create a static snapshot of all connected devices at the time of the call
+* \param context     Object representing librealsense session
+* \param product_mask Controls what kind of devices will be returned
+* \param[out] error  if non-null, receives any error that occurs during this call, otherwise, errors are ignored
+* \return            the list of devices, should be released by rs2_delete_device_list
+*/
+rs2_device_list* rs2_query_devices_ex(const rs2_context* context, int product_mask, rs2_error** error);
+
 /**
 * \brief Creates RealSense device_hub .
 * \param[in] context The context for the device hub
@@ -93,7 +108,7 @@ void rs2_delete_device_hub(const rs2_device_hub* hub);
 * \param[out] error  If non-null, receives any error that occurs during this call, otherwise, errors are ignored.
 * \return            device object
 */
-rs2_device* rs2_device_hub_wait_for_device(rs2_context* ctx, const rs2_device_hub* hub, rs2_error** error);
+rs2_device* rs2_device_hub_wait_for_device(const rs2_device_hub* hub, rs2_error** error);
 
 /**
 * Checks if device is still connected

libs/realsense2/include/librealsense2/h/rs_frame.h

@@ -40,9 +40,9 @@ typedef enum rs2_frame_metadata_value
     RS2_FRAME_METADATA_BACKEND_TIMESTAMP                    , /**< Timestamp get from uvc driver. usec*/
     RS2_FRAME_METADATA_ACTUAL_FPS                           , /**< Actual fps */
     RS2_FRAME_METADATA_FRAME_LASER_POWER                    , /**< Laser power value 0-360. */
-    RS2_FRAME_METADATA_FRAME_LASER_POWER_MODE               , /**< Laser power mode. Zero corresponds to Laser power switched off and one for switched on. */    
+    RS2_FRAME_METADATA_FRAME_LASER_POWER_MODE               , /**< Laser power mode. Zero corresponds to Laser power switched off and one for switched on. */
     RS2_FRAME_METADATA_EXPOSURE_PRIORITY                    , /**< Exposure priority. */
-    RS2_FRAME_METADATA_EXPOSURE_ROI_LEFT                    , /**< Left region of interest for the auto exposure Algorithm. */          
+    RS2_FRAME_METADATA_EXPOSURE_ROI_LEFT                    , /**< Left region of interest for the auto exposure Algorithm. */
     RS2_FRAME_METADATA_EXPOSURE_ROI_RIGHT                   , /**< Right region of interest for the auto exposure Algorithm. */
     RS2_FRAME_METADATA_EXPOSURE_ROI_TOP                     , /**< Top region of interest for the auto exposure Algorithm. */
     RS2_FRAME_METADATA_EXPOSURE_ROI_BOTTOM                  , /**< Bottom region of interest for the auto exposure Algorithm. */
@@ -276,6 +276,17 @@ int rs2_is_frame_extendable_to(const rs2_frame* frame, rs2_extension extension_t
 rs2_frame* rs2_allocate_synthetic_video_frame(rs2_source* source, const rs2_stream_profile* new_stream, rs2_frame* original,
     int new_bpp, int new_width, int new_height, int new_stride, rs2_extension frame_type, rs2_error** error);
 
+/**
+* Allocate new points frame using a frame-source provided from a processing block
+* \param[in] source      Frame pool to allocate the frame from
+* \param[in] new_stream  New stream profile to assign to newly created frame
+* \param[in] original    A reference frame that can be used to fill in auxilary information like format, width, height, bpp, stride (if applicable)
+* \param[out] error      If non-null, receives any error that occurs during this call, otherwise, errors are ignored
+* \return                reference to a newly allocated frame, must be released with release_frame
+*                        memory for the frame is likely to be re-used from previous frame, but in lack of available frames in the pool will be allocated from the free store
+*/
+rs2_frame* rs2_allocate_points(rs2_source* source, const rs2_stream_profile* new_stream, rs2_frame* original, rs2_error** error);
+
 /**
 * Allocate new composite frame, aggregating a set of existing frames
 * \param[in] source      Frame pool to allocate the frame from
@@ -323,9 +334,6 @@ void rs2_synthetic_frame_ready(rs2_source* source, rs2_frame* frame, rs2_error**
 */
 void rs2_pose_frame_get_pose_data(const rs2_frame* frame, rs2_pose* pose, rs2_error** error);
 
-
-
-
 #ifdef __cplusplus
 }
 #endif