frame.hpp

#pragma once
 
#include <map>
 
#include "codec_bridge.hpp"
#include "../global.hpp"
#include "../size_2d.hpp"
#include "../image.hpp"
#include "../plane.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<CodecBridge::Frame>::HandleGuard(void *handle) noexcept
      : HandleGuard<CodecBridge::Frame>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace CodecBridge
  {

    class Frame final
    {
 
    public:

      static std::unique_ptr<Frame> Create(Size2D<int> size, CodecBridge::PixelFormat format, uint8_t *buffer)
      {
        return Internal::DoResCallObjectOut<Frame>([&](void *&handle) {
          return CVB_CALL_CAPI(CVCBCreateFrame(size.Width(), size.Height(),
                                               static_cast<CExports::CVCBPixelFormat>(format), buffer, handle));
        });
      }
      static std::unique_ptr<Frame> Create(Size2D<int> size, CodecBridge::PixelFormat format, uint8_t *buffer) {…}


      static std::unique_ptr<Frame> Create(Size2D<int> size, CodecBridge::PixelFormat format)
      {
        return Create(size, format, nullptr);
      }
      static std::unique_ptr<Frame> Create(Size2D<int> size, CodecBridge::PixelFormat format) {…}
 
      static std::unique_ptr<Frame> FromHandle(HandleGuard<Frame> &&guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        return std::make_unique<Frame>(std::move(guard));
      }
 
      explicit Frame(HandleGuard<Frame> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
      Frame(const Frame &other)            = delete;
      Frame &operator=(const Frame &other) = delete;
      Frame(Frame &&other)                 = delete;
      Frame &operator=(Frame &&other)      = delete;
 
      ~Frame() = default;
 
      void *Handle() const noexcept
      {
        return handle_.Handle();
      }


      int Width() const
      {
        return static_cast<int>(Property<CExports::cvbdim_t>(CExports::CVCBFP_Width));
      }
      int Width() const {…}


      int Height() const
      {
        return static_cast<int>(Property<CExports::cvbdim_t>(CExports::CVCBFP_Height));
      }
      int Height() const {…}


      Size2D<int> Size() const
      {
        return {Width(), Height()};
      }
      Size2D<int> Size() const {…}


      int64_t PresentationTimeStamp() const
      {
        return static_cast<int64_t>(Property<CExports::cvbint64_t>(CExports::CVCBFP_PresentationTimestamp));
      }
      int64_t PresentationTimeStamp() const {…}


      void SetPresentationTimeStamp(int64_t value)
      {
        SetProperty(static_cast<CExports::cvbint64_t>(value), CExports::CVCBFP_PresentationTimestamp);
      }
      void SetPresentationTimeStamp(int64_t value) {…}


      CodecBridge::PixelFormat PixelFormat() const
      {
        return static_cast<CodecBridge::PixelFormat>(Property<CExports::CVCBPixelFormat>(CExports::CVCBFP_PixelFormat));
      }
      CodecBridge::PixelFormat PixelFormat() const {…}


      void UserData(void *buffer, size_t &size) const
      {
        CVB_CALL_CAPI_CHECKED(CVCBFrameGetProperty(Handle(), CExports::CVCBFP_SEIUserData, buffer, size));
      }
      void UserData(void *buffer, size_t &size) const {…}


      Rational TimeBase() const
      {
        auto timeBase = Property<CExports::CVCBRational>(CExports::CVCBFP_TimeBase);
        return {timeBase.Numerator, timeBase.Denominator};
      }
      Rational TimeBase() const {…}


      void SetUserData(void *buffer, size_t size)
      {
        CVB_CALL_CAPI_CHECKED(CVCBFrameSetProperty(Handle(), CExports::CVCBFP_SEIUserData, buffer, size));
      }
      void SetUserData(void *buffer, size_t size) {…}


      void DeleteUserData()
      {
        CVB_CALL_CAPI_CHECKED(CVCBFrameSetProperty(Handle(), CExports::CVCBFP_SEIUserData, nullptr, 0));
      }
      void DeleteUserData() {…}


      std::unique_ptr<Image> AsImage() const
      {
        if (!CExports::IsImage(Handle()))
          throw std::runtime_error("frame is not an image");
 
        if (!CExports::ShareObject(Handle()))
          throw std::runtime_error("failed to share frame handle");
 
        HandleGuard<Image> guard(Handle());
        return Image::FromHandle(std::move(guard));
      }
      std::unique_ptr<Image> AsImage() const {…}


      int PlanesCount() const noexcept
      {
        CExports::cvbdim_t numElements = 0;
        CExports::CVCPlaneEnumGetCount(Handle(), numElements);
        return static_cast<int>(numElements);
      }
      int PlanesCount() const noexcept {…}


      PlanePtr Plane(int index) const
      {
        std::unique_lock<std::mutex> guard(planesMtx_);
        auto candidate = planes_.find(index);
        if (candidate != planes_.end())
          if (auto plane = candidate->second.lock())
            return plane;
 
        auto plane = Internal::DoResCallShareOut<Cvb::Plane>([&](void *&handle) {
          return CVB_CALL_CAPI(CVCPlaneEnumGetAt(Handle(), static_cast<CExports::cvbdim_t>(index), handle));
        });
 
        planes_[index] = plane;
        return plane;
      }
      PlanePtr Plane(int index) const {…}
 
    private:
      template <class T>
      T Property(CExports::CVCBFrameProperty property) const
      {
        T value     = {};
        size_t size = sizeof(T);
        CVB_CALL_CAPI_CHECKED(CVCBFrameGetProperty(Handle(), property, &value, size));
        return value;
      }
 
      template <class T>
      void SetProperty(T value, CExports::CVCBFrameProperty property) const
      {
        CVB_CALL_CAPI_CHECKED(CVCBFrameSetProperty(Handle(), property, &value, sizeof(T)));
      }
 
      HandleGuard<Frame> handle_;
      mutable std::mutex planesMtx_;
      mutable std::map<int, std::weak_ptr<Cvb::Plane>> planes_;
    };
    class Frame final {…};
 
  }  // namespace CodecBridge
 
  CVB_END_INLINE_NS
}  // namespace Cvb