Frame.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "Types.hpp"
 
#include <memory>
#include <iostream>
#include <typeinfo>
 
struct FrameImpl;
 
namespace ob {
class Device;
class Sensor;
class StreamProfile;
class Filter;
class FrameHelper;
 
typedef std::function<void(void *buffer, void *context)> BufferDestroyCallback;
 
class OB_EXTENSION_API Frame : public std::enable_shared_from_this<Frame> {
protected:
    std::unique_ptr<FrameImpl> impl_;
 
public:
    explicit Frame(std::unique_ptr<FrameImpl> impl);
    Frame(Frame &frame);
 
    virtual ~Frame() noexcept;
 
    virtual OBFrameType type();
 
    virtual OBFormat format();
 
    virtual uint64_t index();
 
    virtual void *data();
 
    virtual uint32_t dataSize();
 
    uint64_t timeStamp();
 
    uint64_t timeStampUs();
 
    uint64_t systemTimeStamp();
 
    uint64_t systemTimeStampUs();
 
    uint64_t globalTimeStampUs();
 
    void *metadata();
 
    uint32_t metadataSize();
 
    bool hasMetadata(OBFrameMetadataType type);
 
    int64_t getMetadataValue(OBFrameMetadataType type);
 
    std::shared_ptr<StreamProfile> getStreamProfile();
 
    std::shared_ptr<Sensor> getSensor();
 
    std::shared_ptr<Device> getDevice();
 
    template <typename T> bool is();
 
    template <typename T> std::shared_ptr<T> as() {
        if(!is<T>()) {
            throw std::runtime_error("unsupported operation, object's type is not require type");
        }
 
        return std::dynamic_pointer_cast<T>(shared_from_this());
    }
 
private:
    friend class Filter;
    friend class Recorder;
    friend class FrameHelper;
    friend class CoordinateTransformHelper;
};
 
class OB_EXTENSION_API VideoFrame : public Frame {
public:
    explicit VideoFrame(Frame &frame);
 
    explicit VideoFrame(std::unique_ptr<FrameImpl> impl);
 
    ~VideoFrame() noexcept override = default;
 
    uint32_t width();
 
    uint32_t height();
 
    uint8_t pixelAvailableBitSize();
};
 
class OB_EXTENSION_API ColorFrame : public VideoFrame {
public:
    explicit ColorFrame(Frame &frame);
 
    explicit ColorFrame(std::unique_ptr<FrameImpl> impl);
 
    ~ColorFrame() noexcept override = default;
};
 
class OB_EXTENSION_API DepthFrame : public VideoFrame {
public:
    explicit DepthFrame(Frame &frame);
 
    explicit DepthFrame(std::unique_ptr<FrameImpl> impl);
 
    ~DepthFrame() noexcept override = default;
 
    float getValueScale();
};
 
class OB_EXTENSION_API IRFrame : public VideoFrame {
public:
    explicit IRFrame(Frame &frame);
 
    explicit IRFrame(std::unique_ptr<FrameImpl> impl);
 
    ~IRFrame() noexcept override = default;
 
public:
    OBSensorType getDataSource();
};
 
class OB_EXTENSION_API PointsFrame : public Frame {
public:
    explicit PointsFrame(Frame &frame);
 
    explicit PointsFrame(std::unique_ptr<FrameImpl> impl);
 
    ~PointsFrame() noexcept override = default;
 
    float getPositionValueScale();
};
 
class OB_EXTENSION_API FrameSet : public Frame {
 
public:
    explicit FrameSet(std::unique_ptr<FrameImpl> impl);
 
    explicit FrameSet(Frame &frame);
 
    ~FrameSet() noexcept override;
 
    uint32_t frameCount();
 
    std::shared_ptr<DepthFrame> depthFrame();
 
    std::shared_ptr<ColorFrame> colorFrame();
 
    std::shared_ptr<IRFrame> irFrame();
 
    std::shared_ptr<PointsFrame> pointsFrame();
 
    std::shared_ptr<Frame> getFrame(OBFrameType frameType);
 
    std::shared_ptr<Frame> getFrame(int index);
 
    // Declare Pipeline and Filter classes as friends
    friend class Pipeline;
    friend class Filter;
};
 
class OB_EXTENSION_API AccelFrame : public Frame {
public:
    explicit AccelFrame(Frame &frame);
 
    explicit AccelFrame(std::unique_ptr<FrameImpl> impl);
 
    ~AccelFrame() noexcept override = default;
 
    OBAccelValue value();
 
    float temperature();
};
 
class OB_EXTENSION_API GyroFrame : public Frame {
public:
    explicit GyroFrame(Frame &frame);
 
    explicit GyroFrame(std::unique_ptr<FrameImpl> impl);
 
    ~GyroFrame() noexcept override = default;
 
    OBGyroValue value();
 
    float temperature();
};
 
class OB_EXTENSION_API RawPhaseFrame : public VideoFrame {
public:
    explicit RawPhaseFrame(Frame &frame);
 
    explicit RawPhaseFrame(std::unique_ptr<FrameImpl> impl);
 
    ~RawPhaseFrame() noexcept override = default;
};
 
class OB_EXTENSION_API FrameHelper {
public:
    static std::shared_ptr<Frame> createFrame(OBFrameType type, OBFormat format, uint32_t width, uint32_t height, uint32_t strideBytes);
 
    static std::shared_ptr<Frame> createFrameFromBuffer(OBFormat format, uint32_t width, uint32_t height, uint8_t *buffer, uint32_t bufferSize,
                                                        BufferDestroyCallback destroyCallback, void *destroyCallbackContext);
 
    static std::shared_ptr<FrameSet> createFrameSet();
 
    static void pushFrame(std::shared_ptr<Frame> frameSet, OBFrameType frameType, std::shared_ptr<Frame> frame);
 
    static void setFrameSystemTimestamp(std::shared_ptr<Frame> frame, uint64_t systemTimestamp);
 
    static void setFrameDeviceTimestamp(std::shared_ptr<Frame> frame, uint64_t deviceTimestamp);
 
    static void setFrameDeviceTimestampUs(std::shared_ptr<Frame> frame, uint64_t deviceTimestampUs);
};
 
// Define the is() template function for the Frame class
template <typename T> bool Frame::is() {
    switch(this->type()) {
    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_GYRO:
        return (typeid(T) == typeid(GyroFrame));
    case OB_FRAME_ACCEL:
        return (typeid(T) == typeid(AccelFrame));
    case OB_FRAME_SET:
        return (typeid(T) == typeid(FrameSet));
    case OB_FRAME_POINTS:
        return (typeid(T) == typeid(PointsFrame));
    case OB_FRAME_RAW_PHASE:
        return (typeid(T) == typeid(RawPhaseFrame) || typeid(T) == typeid(VideoFrame));
    default:
        std::cout << "ob::Frame::is() did not catch frame type: " << (int)this->type() << std::endl;
        break;
    }
    return false;
}
}  // namespace ob