decoder.hpp

#pragma once
 
 
#include "codec_bridge.hpp"
#include "../global.hpp"
#include "../utilities/system_info.hpp"
 
#include "codec_config.hpp"
#include "frame.hpp"
#include "packet.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
  template <>
inline HandleGuard<CodecBridge::Decoder>::HandleGuard(void* handle) noexcept
  : HandleGuard<CodecBridge::Decoder>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
{
}
 
  namespace CodecBridge
  {
 
  class Decoder final
  {
 
  public:
 
    static std::unique_ptr<Decoder> FromHandle(HandleGuard<Decoder>&& guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::make_unique<Decoder>(std::move(guard));
    }
 
    explicit Decoder(HandleGuard<Decoder>&& guard) noexcept
      : handle_(std::move(guard))
    {
 
    }
 
    Decoder(const Decoder& other) = delete;
    Decoder& operator=(const Decoder& other) = delete;
    Decoder(Decoder&& other) = delete;
    Decoder& operator=(Decoder&& other) = delete;
 
    ~Decoder() = default;
 
    void* Handle() const noexcept
    {
      return handle_.Handle();
    }
 
 
    CodecStatus Decode(const Packet& packet)
    {
      CExports::CVCBCodecStatus status = CExports::CVCBCS_ReadoutRequired;
      CVB_CALL_CAPI_CHECKED(CVCBDecoderSendPacket(Handle(), packet.Handle(), status));
      return static_cast<CodecStatus>(status);
    }
 
 
    void Flush()
    {
      CExports::CVCBCodecStatus status = CExports::CVCBCS_ReadoutRequired;
      CVB_CALL_CAPI_CHECKED(CVCBDecoderSendPacket(Handle(), nullptr, status));
    }
 
 
    std::unique_ptr<Frame> ReceiveFrame()
    {
      CExports::CVCBFRAME handle = nullptr;
      CVB_CALL_CAPI_CHECKED(CVCBDecoderReceiveFrame(Handle(), handle));
      if (!handle)
        return {};
      HandleGuard<Frame> guard(handle);
      return Frame::FromHandle(std::move(guard));
    }
 
 
    int StreamIndex() const
    {
      return Property<int>(CExports::CVCBDP_StreamIndex);
    }
 
 
  private:
 
    template<class T>
    T Property(CExports::CVCBDecoderProperty property) const
    {
      T value = {};
      size_t size = sizeof(T);
      CVB_CALL_CAPI_CHECKED(CVCBDecoderGetProperty(Handle(), property, &value, size));
      return value;
    }
 
    HandleGuard<Decoder> handle_;
  };
 
}
 
CVB_END_INLINE_NS
}