Frame.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/Frame.h"
#include "libobsensor/hpp/Error.hpp"
#include "libobsensor/hpp/StreamProfile.hpp"
#include <memory>
#include <iostream>
#include <typeinfo>
#include <functional>

 
namespace ob {
class Device;
class Sensor;

class Frame : public std::enable_shared_from_this<Frame> {
protected:
    const ob_frame *impl_ = nullptr;
 
public:
    explicit Frame(const ob_frame *impl) : impl_(impl) {}

    const ob_frame *getImpl() const {
        return impl_;
    }

    virtual ~Frame() noexcept {
        if(impl_) {
            ob_error *error = nullptr;
            ob_delete_frame(impl_, &error);
            Error::handle(&error, false);
            impl_ = nullptr;
        }
    }

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

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

    virtual uint64_t getIndex() const {
        ob_error *error = nullptr;
        auto      index = ob_frame_get_index(impl_, &error);
        Error::handle(&error);
 
        return index;
    }

    virtual uint8_t *getData() const {
        ob_error *error = nullptr;
        auto      data  = ob_frame_get_data(impl_, &error);
        Error::handle(&error);
 
        return data;
    }

    virtual uint32_t getDataSize() const {
        ob_error *error    = nullptr;
        auto      dataSize = ob_frame_get_data_size(impl_, &error);
        Error::handle(&error);
 
        return dataSize;
    }

    uint64_t getTimeStampUs() const {
        ob_error *error       = nullptr;
        auto      timeStampUs = ob_frame_get_timestamp_us(impl_, &error);
        Error::handle(&error);
 
        return timeStampUs;
    }

    uint64_t getSystemTimeStampUs() const {
        ob_error *error             = nullptr;
        auto      systemTimeStampUs = ob_frame_get_system_timestamp_us(impl_, &error);
        Error::handle(&error);
 
        return systemTimeStampUs;
    }

    uint64_t getGlobalTimeStampUs() const {
        ob_error *error             = nullptr;
        auto      globalTimeStampUs = ob_frame_get_global_timestamp_us(impl_, &error);
        Error::handle(&error);
 
        return globalTimeStampUs;
    }

    uint8_t *getMetadata() const {
        ob_error *error    = nullptr;
        auto      metadata = ob_frame_get_metadata(impl_, &error);
        Error::handle(&error);
 
        return metadata;
    }

    uint32_t getMetadataSize() const {
        ob_error *error        = nullptr;
        auto      metadataSize = ob_frame_get_metadata_size(impl_, &error);
        Error::handle(&error);
 
        return metadataSize;
    }

    bool hasMetadata(OBFrameMetadataType type) const {
        ob_error *error  = nullptr;
        auto      result = ob_frame_has_metadata(impl_, type, &error);
        Error::handle(&error);
 
        return result;
    }

    int64_t getMetadataValue(OBFrameMetadataType type) const {
        ob_error *error = nullptr;
        auto      value = ob_frame_get_metadata_value(impl_, type, &error);
        Error::handle(&error);
 
        return value;
    }

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

    std::shared_ptr<Sensor> getSensor() const {
        ob_error *error  = nullptr;
        auto      sensor = ob_frame_get_sensor(impl_, &error);
        Error::handle(&error);
 
        return std::make_shared<Sensor>(sensor);
    }

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

    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 require type");
        }
 
        ob_error *error = nullptr;
        ob_frame_add_ref(impl_, &error);
        Error::handle(&error);
 
        return std::make_shared<T>(impl_);
    }

    template <typename T> std::shared_ptr<const T> as() const {
        if(!is<const T>()) {
            throw std::runtime_error("unsupported operation, object's type is not require type");
        }
 
        ob_error *error = nullptr;
        ob_frame_add_ref(impl_, &error);
        Error::handle(&error);
 
        return std::make_shared<const T>(impl_);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    OBFrameType type() const {
        return getType();
    }
 
    virtual OBFormat format() const {
        return getFormat();
    }
 
    virtual uint64_t index() const {
        return getIndex();
    }
 
    virtual void *data() const {
        auto data = getData();
        return reinterpret_cast<void *>(data);
    }
 
    virtual uint32_t dataSize() const {
        return getDataSize();
    }
 
    uint64_t timeStamp() const {
        return getTimeStampUs() / 1000;
    }
 
    uint64_t timeStampUs() const {
        return getTimeStampUs();
    }
 
    uint64_t systemTimeStamp() const {
        return getSystemTimeStampUs() / 1000;
    }
 
    uint64_t systemTimeStampUs() const {
        return getSystemTimeStampUs();
    }
 
    uint64_t globalTimeStampUs() const {
        return getGlobalTimeStampUs();
    }
 
    uint8_t *metadata() const {
        return getMetadata();
    }
 
    uint32_t metadataSize() const {
        return getMetadataSize();
    }
};

class VideoFrame : public Frame {
public:
    explicit VideoFrame(const ob_frame *impl) : Frame(impl) {};
 
    ~VideoFrame() noexcept override = default;

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

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

    OBPixelType getPixelType() const {
        ob_error *error     = nullptr;
        auto      pixelType = ob_video_frame_get_pixel_type(impl_, &error);
        Error::handle(&error);
 
        return pixelType;
    }

    uint8_t getPixelAvailableBitSize() const {
        ob_error *error   = nullptr;
        auto      bitSize = ob_video_frame_get_pixel_available_bit_size(impl_, &error);
        Error::handle(&error);
 
        return bitSize;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t width() const {
        return getWidth();
    }
 
    uint32_t height() const {
        return getHeight();
    }
 
    uint8_t pixelAvailableBitSize() const {
        return getPixelAvailableBitSize();
    }
};

class ColorFrame : public VideoFrame {
public:
    explicit ColorFrame(const ob_frame *impl) : VideoFrame(impl) {};
 
    ~ColorFrame() noexcept override = default;
};

class DepthFrame : public VideoFrame {
 
public:
    explicit DepthFrame(const ob_frame *impl) : VideoFrame(impl) {};
 
    ~DepthFrame() noexcept override = default;

    float getValueScale() const {
        ob_error *error = nullptr;
        auto      scale = ob_depth_frame_get_value_scale(impl_, &error);
        Error::handle(&error);
 
        return scale;
    }
};

class IRFrame : public VideoFrame {
 
public:
    explicit IRFrame(const ob_frame *impl) : VideoFrame(impl) {};
 
    ~IRFrame() noexcept override = default;
};

class ConfidenceFrame : public VideoFrame {
 
public:
    explicit ConfidenceFrame(const ob_frame *impl) : VideoFrame(impl) {};
 
    ~ConfidenceFrame() noexcept override = default;
};

class PointsFrame : public Frame {
 
public:
    explicit PointsFrame(const ob_frame *impl) : Frame(impl) {};
 
    ~PointsFrame() noexcept override = default;

    float getCoordinateValueScale() const {
        ob_error *error = nullptr;
        auto      scale = ob_points_frame_get_coordinate_value_scale(impl_, &error);
        Error::handle(&error);
 
        return scale;
    }

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

    uint32_t getHeight() const {
        ob_error *error  = nullptr;
        auto      height = ob_point_cloud_frame_get_height(impl_, &error);
        Error::handle(&error);
 
        return height;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
#define getPositionValueScale getCoordinateValueScale
};

class AccelFrame : public Frame {
 
public:
    explicit AccelFrame(const ob_frame *impl) : Frame(impl) {};
 
    ~AccelFrame() noexcept override = default;

    OBAccelValue getValue() const {
        ob_error *error = nullptr;
        auto      value = ob_accel_frame_get_value(impl_, &error);
        Error::handle(&error);
 
        return value;
    }

    float getTemperature() const {
        ob_error *error = nullptr;
        auto      temp  = ob_accel_frame_get_temperature(impl_, &error);
        Error::handle(&error);
 
        return temp;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    OBAccelValue value() {
        return getValue();
    }
 
    float temperature() {
        return getTemperature();
    }
};

class GyroFrame : public Frame {
 
public:
    explicit GyroFrame(const ob_frame *impl) : Frame(impl) {};
 
    ~GyroFrame() noexcept override = default;

    OBGyroValue getValue() const {
        ob_error *error = nullptr;
        auto      value = ob_gyro_frame_get_value(impl_, &error);
        Error::handle(&error);
 
        return value;
    }

    float getTemperature() const {
        ob_error *error       = nullptr;
        auto      temperature = ob_gyro_frame_get_temperature(impl_, &error);
        Error::handle(&error);
 
        return temperature;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    OBGyroValue value() {
        return getValue();
    }
 
    float temperature() {
        return getTemperature();
    }
};

class FrameSet : public Frame {
 
public:
    explicit FrameSet(const ob_frame *impl) : Frame(impl) {};
 
    ~FrameSet() noexcept override = default;

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

    std::shared_ptr<Frame> getFrame(OBFrameType frameType) const {
        ob_error *error = nullptr;
        auto      frame = ob_frameset_get_frame(impl_, frameType, &error);
        if(!frame) {
            return nullptr;
        }
        Error::handle(&error);
        return std::make_shared<Frame>(frame);
    }

    std::shared_ptr<Frame> getFrameByIndex(uint32_t index) const {
        ob_error *error = nullptr;
        auto      frame = ob_frameset_get_frame_by_index(impl_, index, &error);
        if(!frame) {
            return nullptr;
        }
        Error::handle(&error);
        return std::make_shared<Frame>(frame);
    }

    void pushFrame(std::shared_ptr<const Frame> frame) const {
        ob_error *error = nullptr;
 
        // unsafe operation, need to cast const to non-const
        auto unConstImpl = const_cast<ob_frame *>(impl_);
 
        auto otherImpl = frame->getImpl();
        ob_frameset_push_frame(unConstImpl, otherImpl, &error);
 
        Error::handle(&error);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t frameCount() const {
        return getCount();
    }
 
    std::shared_ptr<DepthFrame> depthFrame() const {
        auto frame = getFrame(OB_FRAME_DEPTH);
        if(frame == nullptr) {
            return nullptr;
        }
        auto depthFrame = frame->as<ob::DepthFrame>();
        return depthFrame;
    }
 
    std::shared_ptr<ColorFrame> colorFrame() const {
        auto frame = getFrame(OB_FRAME_COLOR);
        if(frame == nullptr) {
            return nullptr;
        }
        auto colorFrame = frame->as<ob::ColorFrame>();
        return colorFrame;
    }
 
    std::shared_ptr<IRFrame> irFrame() const {
        auto frame = getFrame(OB_FRAME_IR);
        if(frame == nullptr) {
            return nullptr;
        }
        auto irFrame = frame->as<ob::IRFrame>();
        return irFrame;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    std::shared_ptr<PointsFrame> pointsFrame() const {
        auto frame = getFrame(OB_FRAME_POINTS);
        if(frame == nullptr) {
            return nullptr;
        }
        auto pointsFrame = frame->as<ob::PointsFrame>();
        return pointsFrame;
    }
 
    std::shared_ptr<Frame> getFrame(int index) const {
        return getFrameByIndex(index);
    }
};

class FrameFactory {
public:
    static std::shared_ptr<Frame> createFrame(OBFrameType frameType, OBFormat format, uint32_t dataSize) {
        ob_error *error = nullptr;
        auto      impl  = ob_create_frame(frameType, format, dataSize, &error);
        Error::handle(&error);
 
        return std::make_shared<Frame>(impl);
    }

    static std::shared_ptr<VideoFrame> createVideoFrame(OBFrameType frameType, OBFormat format, uint32_t width, uint32_t height, uint32_t stride = 0) {
        ob_error *error = nullptr;
        auto      impl  = ob_create_video_frame(frameType, format, width, height, stride, &error);
        Error::handle(&error);
 
        auto frame = std::make_shared<Frame>(impl);
        return frame->as<VideoFrame>();
    }

    static std::shared_ptr<Frame> createFrameFromOtherFrame(std::shared_ptr<const Frame> otherFrame, bool shouldCopyData = true) {
        ob_error *error     = nullptr;
        auto      otherImpl = otherFrame->getImpl();
        auto      impl      = ob_create_frame_from_other_frame(otherImpl, shouldCopyData, &error);
        Error::handle(&error);
 
        return std::make_shared<Frame>(impl);
    }

    static std::shared_ptr<Frame> createFrameFromStreamProfile(std::shared_ptr<const StreamProfile> profile) {
        ob_error *error = nullptr;
        auto      impl  = ob_create_frame_from_stream_profile(profile->getImpl(), &error);
        Error::handle(&error);
 
        return std::make_shared<Frame>(impl);
    }

    typedef std::function<void(uint8_t *)> BufferDestroyCallback;

    static std::shared_ptr<Frame> createFrameFromBuffer(OBFrameType frameType, OBFormat format, uint8_t *buffer, BufferDestroyCallback destroyCallback,
                                                        uint32_t bufferSize) {
        ob_error *error = nullptr;
        auto      ctx   = new BufferDestroyContext{ destroyCallback };
        auto      impl  = ob_create_frame_from_buffer(frameType, format, buffer, bufferSize, &FrameFactory::BufferDestroy, ctx, &error);
        Error::handle(&error);
 
        return std::make_shared<Frame>(impl);
    }

    static std::shared_ptr<VideoFrame> createVideoFrameFromBuffer(OBFrameType frameType, OBFormat format, uint32_t width, uint32_t height, uint8_t *buffer,
                                                                  BufferDestroyCallback destroyCallback, uint32_t bufferSize, uint32_t stride = 0) {
        ob_error *error = nullptr;
        auto      ctx   = new BufferDestroyContext{ destroyCallback };
        auto impl = ob_create_video_frame_from_buffer(frameType, format, width, height, stride, buffer, bufferSize, &FrameFactory::BufferDestroy, ctx, &error);
        Error::handle(&error);
 
        auto frame = std::make_shared<Frame>(impl);
        return frame->as<VideoFrame>();
    }

    static std::shared_ptr<FrameSet> createFrameSet() {
        ob_error *error = nullptr;
        auto      impl  = ob_create_frameset(&error);
        Error::handle(&error);
        return std::make_shared<FrameSet>(impl);
    }
 
private:
    struct BufferDestroyContext {
        BufferDestroyCallback callback;
    };
 
    static void BufferDestroy(uint8_t *buffer, void *context) {
        auto *ctx = static_cast<BufferDestroyContext *>(context);
        if(ctx->callback) {
            ctx->callback(buffer);
        }
        delete ctx;
    }
};

class FrameHelper : public FrameFactory {
public:
    static void setFrameDeviceTimestampUs(std::shared_ptr<Frame> frame, uint64_t deviceTimestampUs) {
        ob_error *error = nullptr;
        auto      impl  = const_cast<ob_frame *>(frame->getImpl());
        ob_frame_set_timestamp_us(impl, deviceTimestampUs, &error);
        Error::handle(&error);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    static void setFrameSystemTimestamp(std::shared_ptr<Frame> frame, uint64_t systemTimestamp) {
        // In order to compile, some high-version compilers will warn that the function parameters are not used.
        (void)frame;
        (void)systemTimestamp;
    }
 
    static void setFrameDeviceTimestamp(std::shared_ptr<Frame> frame, uint64_t deviceTimestamp) {
        // In order to compile, some high-version compilers will warn that the function parameters are not used.
        (void)frame;
        (void)deviceTimestamp;
    }
};
 
// Define the is() template function for the Frame class
template <typename T> bool Frame::is() const {
    switch(this->getType()) {
    case OB_FRAME_IR_LEFT:   // Follow
    case OB_FRAME_IR_RIGHT:  // Follow
    case OB_FRAME_IR:
        return (typeid(T) == typeid(IRFrame) || typeid(T) == typeid(VideoFrame));
    case OB_FRAME_DEPTH:
        return (typeid(T) == typeid(DepthFrame) || typeid(T) == typeid(VideoFrame));
    case OB_FRAME_COLOR:
        return (typeid(T) == typeid(ColorFrame) || typeid(T) == typeid(VideoFrame));
    case OB_FRAME_CONFIDENCE:
        return (typeid(T) == typeid(ConfidenceFrame) || typeid(T) == typeid(VideoFrame));
    case OB_FRAME_GYRO:
        return (typeid(T) == typeid(GyroFrame));
    case OB_FRAME_ACCEL:
        return (typeid(T) == typeid(AccelFrame));
    case OB_FRAME_POINTS:
        return (typeid(T) == typeid(PointsFrame));
    case OB_FRAME_SET:
        return (typeid(T) == typeid(FrameSet));
    default:
        std::cout << "ob::Frame::is() did not catch frame type: " << (int)this->getType() << std::endl;
        break;
    }
    return false;
}
 
}  // namespace ob