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);
      }
      CodecStatus Decode(const Packet &packet) {…}


      void Flush()
      {
        CExports::CVCBCodecStatus status = CExports::CVCBCS_ReadoutRequired;
        CVB_CALL_CAPI_CHECKED(CVCBDecoderSendPacket(Handle(), nullptr, status));
      }
      void Flush() {…}


      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));
      }
      std::unique_ptr<Frame> ReceiveFrame() {…}


      int StreamIndex() const
      {
        return Property<int>(CExports::CVCBDP_StreamIndex);
      }
      int StreamIndex() const {…}
 
    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_;
    };
    class Decoder final {…};
 
  }  // namespace CodecBridge
 
  CVB_END_INLINE_NS
}  // namespace Cvb