Pipeline.hpp

Go to the documentation of this file.

// Copyright (c) Orbbec Inc. All Rights Reserved.
// Licensed under the MIT License.

#pragma once
 
#include "Frame.hpp"
#include "Device.hpp"
#include "StreamProfile.hpp"
 
#include "libobsensor/h/Pipeline.h"
#include "libobsensor/hpp/Types.hpp"
#include "libobsensor/hpp/TypeHelper.hpp"
 
#include <memory>
#include <functional>
namespace ob {

class Config {
private:
    ob_config_t *impl_;
 
public:
    Config() {
        ob_error *error = nullptr;
        impl_           = ob_create_config(&error);
        Error::handle(&error);
    }
 
    explicit Config(ob_config_t *impl) : impl_(impl) {}

    ~Config() noexcept {
        ob_error *error = nullptr;
        ob_delete_config(impl_, &error);
        Error::handle(&error, false);
    }
 
    ob_config_t *getImpl() const {
        return impl_;
    }

    void enableStream(OBStreamType streamType) const {
        ob_error *error = nullptr;
        ob_config_enable_stream(impl_, streamType, &error);
        Error::handle(&error);
    }

    void enableStream(OBSensorType sensorType) const {
        auto streamType = ob::TypeHelper::convertSensorTypeToStreamType(sensorType);
        enableStream(streamType);
    }

    void enableStream(std::shared_ptr<const StreamProfile> streamProfile) const {
        ob_error *error            = nullptr;
        auto      c_stream_profile = streamProfile->getImpl();
        ob_config_enable_stream_with_stream_profile(impl_, c_stream_profile, &error);
        Error::handle(&error);
    }

    void enableVideoStream(OBStreamType streamType, uint32_t width = OB_WIDTH_ANY, uint32_t height = OB_HEIGHT_ANY, uint32_t fps = OB_FPS_ANY,
                           OBFormat format = OB_FORMAT_ANY) const {
        ob_error *error = nullptr;
        ob_config_enable_video_stream(impl_, streamType, width, height, fps, format, &error);
        Error::handle(&error);
    }

    void enableVideoStream(OBSensorType sensorType, uint32_t width = OB_WIDTH_ANY, uint32_t height = OB_HEIGHT_ANY, uint32_t fps = OB_FPS_ANY,
                           OBFormat format = OB_FORMAT_ANY) const {
        auto streamType = ob::TypeHelper::convertSensorTypeToStreamType(sensorType);
        enableVideoStream(streamType, width, height, fps, format);
    }

    void enableVideoStream(OBSensorType sensorType, OBHardwareDecimationConfig decimationConfig, uint32_t fps = OB_FPS_ANY,
                           OBFormat format = OB_FORMAT_ANY) const {
        auto      streamType = ob::TypeHelper::convertSensorTypeToStreamType(sensorType);
        ob_error *error      = nullptr;
        ob_config_enable_video_stream_by_decimation_config(impl_, streamType, decimationConfig, fps, format, &error);
        Error::handle(&error);
    }

    void enableAccelStream(OBAccelFullScaleRange fullScaleRange = OB_ACCEL_FULL_SCALE_RANGE_ANY,
                           OBAccelSampleRate     sampleRate     = OB_ACCEL_SAMPLE_RATE_ANY) const {
        ob_error *error = nullptr;
        ob_config_enable_accel_stream(impl_, fullScaleRange, sampleRate, &error);
        Error::handle(&error);
    }

    void enableGyroStream(OBGyroFullScaleRange fullScaleRange = OB_GYRO_FULL_SCALE_RANGE_ANY, OBGyroSampleRate sampleRate = OB_GYRO_SAMPLE_RATE_ANY) const {
        ob_error *error = nullptr;
        ob_config_enable_gyro_stream(impl_, fullScaleRange, sampleRate, &error);
        Error::handle(&error);
    }

    void enableLiDARStream(OBLiDARScanRate scanRate = OB_LIDAR_SCAN_ANY, OBFormat format = OB_FORMAT_ANY) const {
        ob_error *error = nullptr;
        ob_config_enable_lidar_stream(impl_, scanRate, format, &error);
        Error::handle(&error);
    }

    void enableAllStream() {
        ob_error *error = nullptr;
        ob_config_enable_all_stream(impl_, &error);
        Error::handle(&error);
    }

    void disableStream(OBStreamType streamType) const {
        ob_error *error = nullptr;
        ob_config_disable_stream(impl_, streamType, &error);
        Error::handle(&error);
    }

    void disableStream(OBSensorType sensorType) const {
        auto streamType = ob::TypeHelper::convertSensorTypeToStreamType(sensorType);
        disableStream(streamType);
    }

    void disableAllStream() const {
        ob_error *error = nullptr;
        ob_config_disable_all_stream(impl_, &error);
        Error::handle(&error);
    }

    std::shared_ptr<StreamProfileList> getEnabledStreamProfileList() const {
        ob_error *error = nullptr;
        auto      list  = ob_config_get_enabled_stream_profile_list(impl_, &error);
        Error::handle(&error);
        return std::make_shared<StreamProfileList>(list);
    }

    void setAlignMode(OBAlignMode mode) const {
        ob_error *error = nullptr;
        ob_config_set_align_mode(impl_, mode, &error);
        Error::handle(&error);
    }

    void setDepthScaleRequire(bool enable) const {
        ob_error *error = nullptr;
        ob_config_set_depth_scale_after_align_require(impl_, enable, &error);
        Error::handle(&error);
    }

    void setFrameAggregateOutputMode(OBFrameAggregateOutputMode mode) const {
        ob_error *error = nullptr;
        ob_config_set_frame_aggregate_output_mode(impl_, mode, &error);
        Error::handle(&error);
    }
};
 
class Pipeline {
public:
    typedef std::function<void(std::shared_ptr<FrameSet> frame)> FrameSetCallback;
 
private:
    ob_pipeline_t                               *impl_;
    FrameSetCallback                             callback_;
    std::function<void(OBPipelineStatus status)> statusCallback_;
 
public:
    Pipeline() {
        ob_error *error = nullptr;
        impl_           = ob_create_pipeline(&error);
        Error::handle(&error);
    }

    explicit Pipeline(std::shared_ptr<Device> device) {
        ob_error *error = nullptr;
        impl_           = ob_create_pipeline_with_device(device->getImpl(), &error);
        Error::handle(&error);
    }

    ~Pipeline() noexcept {
        ob_error *error = nullptr;
        ob_delete_pipeline(impl_, &error);
        Error::handle(&error, false);
    }

    void start(std::shared_ptr<Config> config = nullptr) const {
        ob_error    *error       = nullptr;
        ob_config_t *config_impl = config == nullptr ? nullptr : config->getImpl();
        ob_pipeline_start_with_config(impl_, config_impl, &error);
        Error::handle(&error);
    }

    void start(std::shared_ptr<Config> config, FrameSetCallback callback) {
        callback_       = callback;
        ob_error *error = nullptr;
        ob_pipeline_start_with_callback(impl_, config ? config->getImpl() : nullptr, &Pipeline::frameSetCallback, this, &error);
        Error::handle(&error);
    }
 
    static void frameSetCallback(ob_frame_t *frameSet, void *userData) {
        auto pipeline = static_cast<Pipeline *>(userData);
        pipeline->callback_(std::make_shared<FrameSet>(frameSet));
    }
 
    static void healthMonitorCallback(ob_pipeline_status status, void *userData) {
        auto pipeline = static_cast<Pipeline *>(userData);
        if(pipeline->statusCallback_) {
            pipeline->statusCallback_(status);
        }
    }

    void stop() const {
        ob_error *error = nullptr;
        ob_pipeline_stop(impl_, &error);
        Error::handle(&error);
    }

    std::shared_ptr<Config> getConfig() const {
        ob_error *error  = nullptr;
        auto      config = ob_pipeline_get_config(impl_, &error);
        Error::handle(&error);
        return std::make_shared<Config>(config);
    }

    std::shared_ptr<FrameSet> waitForFrameset(uint32_t timeoutMs = 1000) const {
        ob_error *error    = nullptr;
        auto      frameSet = ob_pipeline_wait_for_frameset(impl_, timeoutMs, &error);
        if(frameSet == nullptr) {
            return nullptr;
        }
        Error::handle(&error);
        return std::make_shared<FrameSet>(frameSet);
    }

    std::shared_ptr<Device> getDevice() const {
        ob_error *error  = nullptr;
        auto      device = ob_pipeline_get_device(impl_, &error);
        Error::handle(&error);
        return std::make_shared<Device>(device);
    }

    std::shared_ptr<StreamProfileList> getStreamProfileList(OBSensorType sensorType) const {
        ob_error *error = nullptr;
        auto      list  = ob_pipeline_get_stream_profile_list(impl_, sensorType, &error);
        Error::handle(&error);
        return std::make_shared<StreamProfileList>(list);
    }

    std::shared_ptr<StreamProfileList> getD2CDepthProfileList(std::shared_ptr<StreamProfile> colorProfile, OBAlignMode alignMode) {
        ob_error *error = nullptr;
        auto      list  = ob_get_d2c_depth_profile_list(impl_, colorProfile->getImpl(), alignMode, &error);
        Error::handle(&error);
        return std::make_shared<StreamProfileList>(list);
    }

    void enableFrameSync() const {
        ob_error *error = nullptr;
        ob_pipeline_enable_frame_sync(impl_, &error);
        Error::handle(&error);
    }

    void disableFrameSync() const {
        ob_error *error = nullptr;
        ob_pipeline_disable_frame_sync(impl_, &error);
        Error::handle(&error);
    }

    OBPipelineStatus getStatus() const {
        ob_error        *error  = nullptr;
        OBPipelineStatus status = ob_pipeline_get_status(impl_, &error);
        Error::handle(&error);
        return status;
    }

    void enableHealthMonitor(std::function<void(OBPipelineStatus status)> callback, uint32_t intervalMs = 3000) {
        statusCallback_ = callback;
        ob_error *error = nullptr;
        ob_pipeline_enable_health_monitor(impl_, &Pipeline::healthMonitorCallback, this, intervalMs, &error);
        Error::handle(&error);
    }

    void disableHealthMonitor() const {
        ob_error *error = nullptr;
        ob_pipeline_disable_health_monitor(impl_, &error);
        Error::handle(&error);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
 
    OBCameraParam getCameraParam() {
        ob_error     *error       = nullptr;
        OBCameraParam cameraParam = ob_pipeline_get_camera_param(impl_, &error);
        Error::handle(&error);
        return cameraParam;
    }
 
    OBCameraParam getCameraParamWithProfile(uint32_t colorWidth, uint32_t colorHeight, uint32_t depthWidth, uint32_t depthHeight) {
        ob_error     *error       = nullptr;
        OBCameraParam cameraParam = ob_pipeline_get_camera_param_with_profile(impl_, colorWidth, colorHeight, depthWidth, depthHeight, &error);
        Error::handle(&error);
        return cameraParam;
    }
 
    OBCalibrationParam getCalibrationParam(std::shared_ptr<Config> config) {
        ob_error          *error            = nullptr;
        OBCalibrationParam calibrationParam = ob_pipeline_get_calibration_param(impl_, config->getImpl(), &error);
        Error::handle(&error);
        return calibrationParam;
    }
 
    std::shared_ptr<FrameSet> waitForFrames(uint32_t timeoutMs = 1000) const {
        return waitForFrameset(timeoutMs);
    }
};
 
}  // namespace ob