/** * Return the active device and streams profiles, used by the pipeline. * The pipeline streams profiles are selected during \c start(). The method returns a valid result only when the pipeline is active - * between calls to \c start() and \c stop(). * After \c stop() is called, the pipeline doesn't own the device, thus, the pipeline selected device may change in * subsequent activations. * * \return The actual pipeline device and streams profile, which was successfully configured to the streaming device on start. */ pipeline_profile get_active_profile() const { rs2_error* e = nullptr; auto p = std::shared_ptr<rs2_pipeline_profile>( rs2_pipeline_get_active_profile(_pipeline.get(), &e), rs2_delete_pipeline_profile); error::handle(e); return pipeline_profile(p); }
/** * Start the pipeline streaming according to the configuraion. * The pipeline streaming loop captures samples from the device, and delivers them to the attached computer vision modules * and processing blocks, according to each module requirements and threading model. * During the loop execution, the application can access the camera streams by calling \c wait_for_frames() or * \c poll_for_frames(). * The streaming loop runs until the pipeline is stopped. * Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised. * The pipeline selects and activates the device upon start, according to configuration or a default configuration. * When the rs2::config is provided to the method, the pipeline tries to activate the config \c resolve() result. * If the application requests are conflicting with pipeline computer vision modules or no matching device is available on * the platform, the method fails. * Available configurations and devices may change between config \c resolve() call and pipeline start, in case devices * are connected or disconnected, or another application acquires ownership of a device. * * \param[in] config A rs2::config with requested filters on the pipeline configuration. By default no filters are applied. * \return The actual pipeline device and streams profile, which was successfully configured to the streaming device. */ pipeline_profile start(const config& config) { rs2_error* e = nullptr; auto p = std::shared_ptr<rs2_pipeline_profile>( rs2_pipeline_start_with_config(_pipeline.get(), config.get().get(), &e), rs2_delete_pipeline_profile); error::handle(e); return pipeline_profile(p); }
/** * 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. * 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] p The pipeline for which the selected filters are applied * \return A matching device and streams profile, which satisfies the filters and pipeline requests. */ pipeline_profile resolve(std::shared_ptr<rs2_pipeline> p) const { rs2_error* e = nullptr; auto profile = std::shared_ptr<rs2_pipeline_profile>( rs2_config_resolve(_config.get(), p.get(), &e), rs2_delete_pipeline_profile); error::handle(e); return pipeline_profile(profile); }
/** * Start the pipeline streaming with its default configuration. * The pipeline streaming loop captures samples from the device, and delivers them to the attached computer vision * modules and processing blocks, according to each module requirements and threading model. * During the loop execution, the application can access the camera streams by calling \c wait_for_frames() or * \c poll_for_frames(). * The streaming loop runs until the pipeline is stopped. * Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised. * * \return The actual pipeline device and streams profile, which was successfully configured to the streaming device. */ pipeline_profile start() { rs2_error* e = nullptr; auto p = std::shared_ptr<rs2_pipeline_profile>( rs2_pipeline_start(_pipeline.get(), &e), rs2_delete_pipeline_profile); error::handle(e); return pipeline_profile(p); }
pipeline_profile start(const config& config, S callback) { rs2_error* e = nullptr; auto p = std::shared_ptr<rs2_pipeline_profile>( rs2_pipeline_start_with_config_and_callback_cpp(_pipeline.get(), config.get().get(), new frame_callback<S>(callback), &e), rs2_delete_pipeline_profile); error::handle(e); return pipeline_profile(p); }