encoder.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::Encoder>::HandleGuard(void* handle) noexcept
    : HandleGuard<CodecBridge::Encoder>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace CodecBridge
  {
 
  class Encoder final
  {
 
  public:
 
 
    static std::unique_ptr<Encoder> Create(const CodecConfig& codecConfig)
    {
      return Internal::DoResCallObjectOut<Encoder>([&](void*& handle)
        {
          return CVB_CALL_CAPI(CVCBCreateEncoder(codecConfig.Handle(), handle));
        });
    }
 
    static std::unique_ptr<Encoder> FromHandle(HandleGuard<Encoder>&& guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::make_unique<Encoder>(std::move(guard));
    }
 
    explicit Encoder(HandleGuard<Encoder>&& guard) noexcept
      : handle_(std::move(guard))
    {
 
    }
 
    Encoder(const Encoder& other) = delete;
    Encoder& operator=(const Encoder& other) = delete;
    Encoder(Encoder&& other) = delete;
    Encoder& operator=(Encoder&& other) = delete;
 
    ~Encoder() = default;
 
    void* Handle() const noexcept
    {
      return handle_.Handle();
    }
 
 
    CodecStatus Encode(const Frame& frame)
    {
      CExports::CVCBCodecStatus status = CExports::CVCBCS_ReadoutRequired;
      CVB_CALL_CAPI_CHECKED(CVCBEncoderSendFrame(Handle(), frame.Handle(), status));
      return static_cast<CodecStatus>(status);
    }
 
 
    void Flush()
    {
      CExports::CVCBCodecStatus status = CExports::CVCBCS_ReadoutRequired;
      CVB_CALL_CAPI_CHECKED(CVCBEncoderSendFrame(Handle(), nullptr, status));
    }
 
 
    std::unique_ptr<Packet> ReceivePacket()
    {
      CExports::CVCBPACKET handle = nullptr;
      CVB_CALL_CAPI_CHECKED(CVCBEncoderReceivePacket(Handle(), handle));
      if (!handle)
        return  {};
      HandleGuard<Packet> guard(handle);
      return Packet::FromHandle(std::move(guard));
    }
 
 
  private:
 
    HandleGuard<Encoder> handle_;
  };
 
}
 
CVB_END_INLINE_NS
}