output_container.hpp

#pragma once
 
#include "codec_bridge.hpp"
#include "../global.hpp"
#include "../utilities/system_info.hpp"
 
#include "packet.hpp"
#include "encoder.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<CodecBridge::OutputContainer>::HandleGuard(void *handle) noexcept
      : HandleGuard<CodecBridge::OutputContainer>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace CodecBridge
  {

    class OutputContainer final
    {
 
    public:

      static std::unique_ptr<OutputContainer> Create(const Cvb::String &fileName, Encoder &encoder)
      {
        return Internal::DoResCallObjectOut<OutputContainer>([&](void *&handle) {
          return CVB_CALL_CAPI(CVCBCreateOutputContainerTyped(encoder.Handle(), fileName.c_str(), handle));
        });
      }
      static std::unique_ptr<OutputContainer> Create(const Cvb::String &fileName, Encoder &encoder) {…}
 
      static std::unique_ptr<OutputContainer> FromHandle(HandleGuard<OutputContainer> &&guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        return std::make_unique<OutputContainer>(std::move(guard));
      }
 
      explicit OutputContainer(HandleGuard<OutputContainer> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
      OutputContainer(const OutputContainer &other)            = delete;
      OutputContainer &operator=(const OutputContainer &other) = delete;
      OutputContainer(OutputContainer &&other)                 = delete;
      OutputContainer &operator=(OutputContainer &&other)      = delete;
 
      ~OutputContainer() = default;
 
      void *Handle() const noexcept
      {
        return handle_.Handle();
      }


      void WritePacket(std::unique_ptr<Packet> &&packet)
      {
        CExports::CVCBPACKET handle = packet->Handle();
        CVB_CALL_CAPI_CHECKED(CVCBOutputContainerWritePacket(Handle(), handle));
      }
      void WritePacket(std::unique_ptr<Packet> &&packet) {…}


      void WriteHeader()
      {
        CVB_CALL_CAPI_CHECKED(CVCBOutputContainerWriteHeader(Handle()));
      }
      void WriteHeader() {…}


      void WriteTrailer()
      {
        CVB_CALL_CAPI_CHECKED(CVCBOutputContainerWriteTrailer(Handle()));
      }
      void WriteTrailer() {…}
 
    private:
      HandleGuard<OutputContainer> handle_;
    };
    class OutputContainer final {…};
 
  }  // namespace CodecBridge
 
  CVB_END_INLINE_NS
}  // namespace Cvb