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)
  {
    return Create(size, format, nullptr);
  }
 
  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 Height() const
  {
    return static_cast<int>(Property<CExports::cvbdim_t>(CExports::CVCBFP_Height));
  }
 
 
  Size2D<int> Size() const
  {
    return { Width(), Height() };
  }
 
 
  int64_t PresentationTimeStamp() const
  {
    return static_cast<int64_t>(Property<CExports::cvbint64_t>(CExports::CVCBFP_PresentationTimestamp));
  }
 
 
  void SetPresentationTimeStamp(int64_t value)
  {
    SetProperty(static_cast<CExports::cvbint64_t>(value), CExports::CVCBFP_PresentationTimestamp);
  }
 
 
  CodecBridge::PixelFormat PixelFormat() const
  {
    return static_cast<CodecBridge::PixelFormat>(Property<CExports::CVCBPixelFormat>(CExports::CVCBFP_PixelFormat));
  }
 
 
  void UserData(void* buffer, size_t& size) const
  {
    CVB_CALL_CAPI_CHECKED(CVCBFrameGetProperty(Handle(), CExports::CVCBFP_SEIUserData, buffer, size));
  }
 
 
  Rational TimeBase() const
  {
    auto timeBase = Property<CExports::CVCBRational>(CExports::CVCBFP_TimeBase);
    return { timeBase.Numerator , timeBase.Denominator };
  }
 
 
  void SetUserData(void* buffer, size_t size)
  {
    CVB_CALL_CAPI_CHECKED(CVCBFrameSetProperty(Handle(), CExports::CVCBFP_SEIUserData, buffer, size));
  }
 
 
  void DeleteUserData()
  {
    CVB_CALL_CAPI_CHECKED(CVCBFrameSetProperty(Handle(), CExports::CVCBFP_SEIUserData, nullptr, 0));
  }
 
 
  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));
 
  }
 
 
  int PlanesCount() const noexcept
  {
    CExports::cvbdim_t numElements = 0;
    CExports::CVCPlaneEnumGetCount(Handle(), numElements);
    return static_cast<int>(numElements);
  }
 
 
  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;
  }
 
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_;
};
 
}
 
CVB_END_INLINE_NS
}