StreamProfile.hpp

Go to the documentation of this file.

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

#pragma once
 
#include "Types.hpp"
#include "libobsensor/h/StreamProfile.h"
#include "libobsensor/h/Error.h"
#include <iostream>
#include <memory>
 
namespace ob {
 
class StreamProfile : public std::enable_shared_from_this<StreamProfile> {
protected:
    const ob_stream_profile_t *impl_ = nullptr;
 
public:
    StreamProfile(StreamProfile &streamProfile)            = delete;
    StreamProfile &operator=(StreamProfile &streamProfile) = delete;
 
    StreamProfile(StreamProfile &&streamProfile) noexcept : impl_(streamProfile.impl_) {
        streamProfile.impl_ = nullptr;
    }
 
    StreamProfile &operator=(StreamProfile &&streamProfile) noexcept {
        if(this != &streamProfile) {
            ob_error *error = nullptr;
            ob_delete_stream_profile(impl_, &error);
            Error::handle(&error);
            impl_               = streamProfile.impl_;
            streamProfile.impl_ = nullptr;
        }
        return *this;
    }
 
    virtual ~StreamProfile() noexcept {
        if(impl_) {
            ob_error *error = nullptr;
            ob_delete_stream_profile(impl_, &error);
            Error::handle(&error);
        }
    }
 
    const ob_stream_profile *getImpl() const {
        return impl_;
    }

    OBFormat getFormat() const {
        ob_error *error  = nullptr;
        auto      format = ob_stream_profile_get_format(impl_, &error);
        Error::handle(&error);
        return format;
    }

    OBStreamType getType() const {
        ob_error *error = nullptr;
        auto      type  = ob_stream_profile_get_type(impl_, &error);
        Error::handle(&error);
        return type;
    }

    OBExtrinsic getExtrinsicTo(std::shared_ptr<StreamProfile> target) const {
        ob_error *error     = nullptr;
        auto      extrinsic = ob_stream_profile_get_extrinsic_to(impl_, const_cast<ob_stream_profile_t *>(target->getImpl()), &error);
        Error::handle(&error);
        return extrinsic;
    }

    void bindExtrinsicTo(std::shared_ptr<StreamProfile> target, const OBExtrinsic &extrinsic) {
        ob_error *error = nullptr;
        ob_stream_profile_set_extrinsic_to(const_cast<ob_stream_profile_t *>(impl_), const_cast<const ob_stream_profile_t *>(target->getImpl()), extrinsic, &error);
        Error::handle(&error);
    }

    void bindExtrinsicTo(const OBStreamType &targetStreamType, const OBExtrinsic &extrinsic) {
        ob_error *error = nullptr;
        ob_stream_profile_set_extrinsic_to_type(const_cast<ob_stream_profile_t *>(impl_),targetStreamType,extrinsic, &error);
        Error::handle(&error);
    }

    template <typename T> bool is() const;

    template <typename T> std::shared_ptr<T> as() {
        if(!is<T>()) {
            throw std::runtime_error("Unsupported operation. Object's type is not the required type.");
        }
 
        return std::dynamic_pointer_cast<T>(shared_from_this());
    }

    template <typename T> std::shared_ptr<const T> as() const {
        if(!is<T>()) {
            throw std::runtime_error("Unsupported operation. Object's type is not the required type.");
        }
 
        return std::static_pointer_cast<const T>(shared_from_this());
    }
 
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    OBFormat format() const {
        return getFormat();
    }
 
    OBStreamType type() const {
        return getType();
    }
 
protected:
    explicit StreamProfile(const ob_stream_profile_t *impl) : impl_(impl) {}
};

class VideoStreamProfile : public StreamProfile {
public:
    explicit VideoStreamProfile(const ob_stream_profile_t *impl) : StreamProfile(impl) {}
 
    ~VideoStreamProfile() noexcept override = default;

    uint32_t getFps() const {
        ob_error *error = nullptr;
        auto      fps   = ob_video_stream_profile_get_fps(impl_, &error);
        Error::handle(&error);
        return fps;
    }

    uint32_t getWidth() const {
        ob_error *error = nullptr;
        auto      width = ob_video_stream_profile_get_width(impl_, &error);
        Error::handle(&error);
        return width;
    }

    uint32_t getHeight() const {
        ob_error *error  = nullptr;
        auto      height = ob_video_stream_profile_get_height(impl_, &error);
        Error::handle(&error);
        return height;
    }

    OBCameraIntrinsic getIntrinsic() const {
        ob_error *error     = nullptr;
        auto      intrinsic = ob_video_stream_profile_get_intrinsic(impl_, &error);
        Error::handle(&error);
        return intrinsic;
    }

    void setIntrinsic(const OBCameraIntrinsic &intrinsic) {
        ob_error *error = nullptr;
        ob_video_stream_profile_set_intrinsic(const_cast<ob_stream_profile_t *>(impl_), intrinsic, &error);
        Error::handle(&error);
    }

    OBCameraDistortion getDistortion() const {
        ob_error *error      = nullptr;
        auto      distortion = ob_video_stream_profile_get_distortion(impl_, &error);
        Error::handle(&error);
        return distortion;
    }

    void setDistortion(const OBCameraDistortion &distortion) {
        ob_error *error = nullptr;
        ob_video_stream_profile_set_distortion(const_cast<ob_stream_profile_t *>(impl_), distortion, &error);
        Error::handle(&error);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t fps() const {
        return getFps();
    }
 
    uint32_t width() const {
        return getWidth();
    }
 
    uint32_t height() const {
        return getHeight();
    }
};

class AccelStreamProfile : public StreamProfile {
public:
    explicit AccelStreamProfile(const ob_stream_profile_t *impl) : StreamProfile(impl) {}
 
    ~AccelStreamProfile() noexcept override = default;

    OBAccelFullScaleRange getFullScaleRange() const {
        ob_error *error          = nullptr;
        auto      fullScaleRange = ob_accel_stream_profile_get_full_scale_range(impl_, &error);
        Error::handle(&error);
        return fullScaleRange;
    }

    OBAccelSampleRate getSampleRate() const {
        ob_error *error      = nullptr;
        auto      sampleRate = ob_accel_stream_profile_get_sample_rate(impl_, &error);
        Error::handle(&error);
        return sampleRate;
    }

    OBAccelIntrinsic getIntrinsic() const {
        ob_error *error     = nullptr;
        auto      intrinsic = ob_accel_stream_profile_get_intrinsic(impl_, &error);
        Error::handle(&error);
        return intrinsic;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    OBAccelFullScaleRange fullScaleRange() const {
        return getFullScaleRange();
    }
 
    OBAccelSampleRate sampleRate() const {
        return getSampleRate();
    }
};

class GyroStreamProfile : public StreamProfile {
public:
    explicit GyroStreamProfile(const ob_stream_profile_t *impl) : StreamProfile(impl) {}
 
    ~GyroStreamProfile() noexcept override = default;

    OBGyroFullScaleRange getFullScaleRange() const {
        ob_error *error          = nullptr;
        auto      fullScaleRange = ob_gyro_stream_profile_get_full_scale_range(impl_, &error);
        Error::handle(&error);
        return fullScaleRange;
    }

    OBGyroSampleRate getSampleRate() const {
        ob_error *error      = nullptr;
        auto      sampleRate = ob_gyro_stream_profile_get_sample_rate(impl_, &error);
        Error::handle(&error);
        return sampleRate;
    }

    OBGyroIntrinsic getIntrinsic() const {
        ob_error *error     = nullptr;
        auto      intrinsic = ob_gyro_stream_get_intrinsic(impl_, &error);
        Error::handle(&error);
        return intrinsic;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    OBGyroFullScaleRange fullScaleRange() const {
        return getFullScaleRange();
    }
 
    OBGyroSampleRate sampleRate() const {
        return getSampleRate();
    }
};
 
template <typename T> bool StreamProfile::is() const {
    switch(this->getType()) {
    case OB_STREAM_VIDEO:
    case OB_STREAM_IR:
    case OB_STREAM_IR_LEFT:
    case OB_STREAM_IR_RIGHT:
    case OB_STREAM_COLOR:
    case OB_STREAM_DEPTH:
    case OB_STREAM_RAW_PHASE:
    case OB_STREAM_CONFIDENCE:
        return typeid(T) == typeid(VideoStreamProfile);
    case OB_STREAM_ACCEL:
        return typeid(T) == typeid(AccelStreamProfile);
    case OB_STREAM_GYRO:
        return typeid(T) == typeid(GyroStreamProfile);
    default:
        break;
    }
    return false;
}
 
class StreamProfileFactory {
public:
    static std::shared_ptr<StreamProfile> create(const ob_stream_profile_t *impl) {
        ob_error  *error = nullptr;
        const auto type  = ob_stream_profile_get_type(impl, &error);
        Error::handle(&error);
        switch(type) {
        case OB_STREAM_IR:
        case OB_STREAM_IR_LEFT:
        case OB_STREAM_IR_RIGHT:
        case OB_STREAM_DEPTH:
        case OB_STREAM_COLOR:
        case OB_STREAM_VIDEO:
        case OB_STREAM_CONFIDENCE:
            return std::make_shared<VideoStreamProfile>(impl);
        case OB_STREAM_ACCEL:
            return std::make_shared<AccelStreamProfile>(impl);
        case OB_STREAM_GYRO:
            return std::make_shared<GyroStreamProfile>(impl);
        default: {
            ob_error *err = ob_create_error(OB_STATUS_ERROR, "Unsupported stream type.", "StreamProfileFactory::create", "", OB_EXCEPTION_TYPE_INVALID_VALUE);
            Error::handle(&err);
            return nullptr;
        }
        }
    }
};
 
class StreamProfileList {
protected:
    const ob_stream_profile_list_t *impl_;
 
public:
    explicit StreamProfileList(ob_stream_profile_list_t *impl) : impl_(impl) {}
    ~StreamProfileList() noexcept {
        ob_error *error = nullptr;
        ob_delete_stream_profile_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() const {
        ob_error *error = nullptr;
        auto      count = ob_stream_profile_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    std::shared_ptr<StreamProfile> getProfile(uint32_t index) const {
        ob_error *error   = nullptr;
        auto      profile = ob_stream_profile_list_get_profile(impl_, index, &error);
        Error::handle(&error);
        return StreamProfileFactory::create(profile);
    }

    std::shared_ptr<VideoStreamProfile> getVideoStreamProfile(int width = OB_WIDTH_ANY, int height = OB_HEIGHT_ANY, OBFormat format = OB_FORMAT_ANY,
                                                              int fps = OB_FPS_ANY) const {
        ob_error *error   = nullptr;
        auto      profile = ob_stream_profile_list_get_video_stream_profile(impl_, width, height, format, fps, &error);
        Error::handle(&error);
        auto vsp = StreamProfileFactory::create(profile);
        return vsp->as<VideoStreamProfile>();
    }

    std::shared_ptr<AccelStreamProfile> getAccelStreamProfile(OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate) const {
        ob_error *error   = nullptr;
        auto      profile = ob_stream_profile_list_get_accel_stream_profile(impl_, fullScaleRange, sampleRate, &error);
        Error::handle(&error);
        auto asp = StreamProfileFactory::create(profile);
        return asp->as<AccelStreamProfile>();
    }

    std::shared_ptr<GyroStreamProfile> getGyroStreamProfile(OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate) const {
        ob_error *error   = nullptr;
        auto      profile = ob_stream_profile_list_get_gyro_stream_profile(impl_, fullScaleRange, sampleRate, &error);
        Error::handle(&error);
        auto gsp = StreamProfileFactory::create(profile);
        return gsp->as<GyroStreamProfile>();
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t count() const {
        return getCount();
    }
};
 
}  // namespace ob