input_container.hpp

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

    class InputContainer final
    {
 
    public:

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


      std::unique_ptr<Decoder> VideoDecoder(const Cvb::String &name,
                                            CodecBridge::PixelFormat pixelFormat = CodecBridge::PixelFormat::None)
      {
        // we can be sure that decoder names are ASCII only
        std::string asciiName;
        asciiName.reserve(name.size());
        for (const auto &c : name)
          asciiName.push_back(static_cast<char>(c));
        return Internal::DoResCallObjectOut<Decoder>([&](void *&handle) {
          return CVB_CALL_CAPI(CVCBInputContainerCreateDecoder(
              Handle(), asciiName.c_str(), static_cast<CExports::CVCBPixelFormat>(pixelFormat), handle));
        });
      }
      std::unique_ptr<Decoder> VideoDecoder(const Cvb::String &name, {…}


      std::unique_ptr<Decoder> VideoDecoder(CodecBridge::PixelFormat pixelFormat = CodecBridge::PixelFormat::None)
      {
        return Internal::DoResCallObjectOut<Decoder>([&](void *&handle) {
          return CVB_CALL_CAPI(CVCBInputContainerCreateDecoder(
              Handle(), nullptr, static_cast<CExports::CVCBPixelFormat>(pixelFormat), handle));
        });
      }
      std::unique_ptr<Decoder> VideoDecoder(CodecBridge::PixelFormat pixelFormat = CodecBridge::PixelFormat::None) {…}


      std::unique_ptr<Packet> NextPacket()
      {
        CExports::CVCBPACKET handle = nullptr;
        CVB_CALL_CAPI_CHECKED(CVCBInputContainerNextPacket(Handle(), handle));
        if (!handle)
          return {};
        HandleGuard<Packet> guard(handle);
        return Packet::FromHandle(std::move(guard));
      }
      std::unique_ptr<Packet> NextPacket() {…}
 
    private:
      HandleGuard<InputContainer> handle_;
    };
    class InputContainer final {…};
 
  }  // namespace CodecBridge
 
  CVB_END_INLINE_NS
}  // namespace Cvb