codec_config.hpp

#pragma once
 
#include <map>
 
#include "codec_bridge.hpp"
#include "../size_2d.hpp"
#include "../string.hpp"
#include "../shims/stdvariant.hpp"
#include "../utilities/system_info.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
    template <>
  inline HandleGuard<CodecBridge::CodecConfig>::HandleGuard(void* handle) noexcept
    : HandleGuard<CodecBridge::CodecConfig>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace CodecBridge
  {
 
 
    class CodecConfig final
    {
 
    public:
 
 
      static std::unique_ptr<CodecConfig> Create(const Cvb::String& provider)
      {
        return Internal::DoResCallObjectOut<CodecConfig>([&](void*& handle)
          {
            return CVB_CALL_CAPI(CVCBCreateCodecConfigTyped(provider.c_str(), handle));
          });
      }
 
      static std::unique_ptr<CodecConfig> FromHandle(HandleGuard<CodecConfig>&& guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        return std::make_unique<CodecConfig>(std::move(guard));
      }
 
      explicit CodecConfig(HandleGuard<CodecConfig>&& guard) noexcept
        : handle_(std::move(guard))
      {
 
      }
 
      CodecConfig(const CodecConfig& other) = delete;
      CodecConfig& operator=(const CodecConfig& other) = delete;
      CodecConfig(CodecConfig&& other) = delete;
      CodecConfig& operator=(CodecConfig&& other) = delete;
 
      ~CodecConfig() = default;
 
      void* Handle() const noexcept
      {
        return handle_.Handle();
      }
 
 
      Cvb::String Name() const;
 
 
      Cvb::String ToJson() const;
 
 
      int64_t BitRate() const
      {
        return Property<int64_t>(CExports::CVCBCP_Bitrate);
      }
 
 
      void SetBitRate(int64_t bitRate)
      {
        SetProperty(bitRate, CExports::CVCBCP_Bitrate);
      }
 
 
      Size2D<int> Size() const
      {
        return { Property<int>(CExports::CVCBCP_Width),  Property<int>(CExports::CVCBCP_Height) };
      }
 
 
      int ID() const
      {
        return Property<int>(CExports::CVCBCP_ID);
      }
 
 
      void SetSize(Size2D<int> size)
      {
        SetProperty(size.Width(), CExports::CVCBCP_Width);
        SetProperty(size.Height(), CExports::CVCBCP_Height);
      }
 
 
      Rational TimeBase() const
      {
        auto timeBase = Property<CExports::CVCBRational>(CExports::CVCBCP_TimeBase);
        return { timeBase.Numerator, timeBase.Denominator };
      }
 
 
      void SetTimeBase(Rational timeBase)
      {
        SetProperty(*reinterpret_cast<CExports::CVCBRational*>(&timeBase), CExports::CVCBCP_TimeBase);
      }
 
 
      int GOPSize() const
      {
        return Property<int>(CExports::CVCBCP_GOPSize);
      }
 
 
      void SetGOPSize(int gopSize)
      {
        SetProperty(gopSize, CExports::CVCBCP_GOPSize);
      }
 
 
      int MaxBFrames() const
      {
        return Property<int>(CExports::CVCBCP_MaxBFrames);
      }
 
 
      void SetMaxBFrames(int maxBFrames)
      {
        SetProperty(maxBFrames, CExports::CVCBCP_MaxBFrames);
      }
 
 
      CodecBridge::PixelFormat PixelFormat() const
      {
        return static_cast<CodecBridge::PixelFormat>(Property<CExports::CVCBPixelFormat>(CExports::CVCBCP_PixelFormat));
      }
 
 
      void SetPixelFormat(CodecBridge::PixelFormat pixelFormat)
      {
        SetProperty(static_cast<CExports::CVCBPixelFormat>(pixelFormat), CExports::CVCBCP_PixelFormat);
      }
 
 
      template<class T>
      T Option(const Cvb::String& name) const;
 
 
      template<class T>
      void AddOption(const Cvb::String& name, const T& value);
 
 
      Cvb::String SessionDescription(const Cvb::String& url);
 
    private:
 
      template<class T>
      T Property(CExports::CVCBCodecProperty property, const Cvb::String& optionName = Cvb::String()) const
      {
        T value = {};
        size_t size = sizeof(T);
        CVB_CALL_CAPI_CHECKED(CVCBCodecConfigGetProperty(Handle(), property, &value, size, optionName.empty() ? nullptr : ToBytes(optionName).c_str()));
        return value;
      }
 
      template<class T>
      void SetProperty(const T& value, CExports::CVCBCodecProperty property, const Cvb::String& optionName = Cvb::String())
      {
        CVB_CALL_CAPI_CHECKED(CVCBCodecConfigSetProperty(Handle(), property, const_cast<T*>(&value), sizeof(T), optionName.empty() ? nullptr : ToBytes(optionName).c_str())); // NOLINT(cppcoreguidelines-pro-type-const-cast)
      }
 
      static std::string ToBytes(const std::wstring& text)
      {
        // we can be sure that options are ASCII only
        std::string asciiText;
        asciiText.reserve(text.size());
        for (const auto& c : text)
          asciiText.push_back(static_cast<char>(c));
        return asciiText;
      }
 
      static std::string ToBytes(const std::string& text)
      {
        return text;
      }
 
      HandleGuard<CodecConfig> handle_;
    };
 
    template<>
    inline Cvb::String CodecConfig::Property<Cvb::String>(CExports::CVCBCodecProperty property, const Cvb::String& optionName) const
    {
 
      size_t size = 0;
      CVB_CALL_CAPI_CHECKED(CVCBCodecConfigGetProperty(Handle(), property, nullptr, size, optionName.empty() ? nullptr : ToBytes(optionName).c_str()));
 
      std::vector<char> buffer(size);
      CVB_CALL_CAPI_CHECKED(CVCBCodecConfigGetProperty(Handle(), property, buffer.data(), size, optionName.empty() ? nullptr : ToBytes(optionName).c_str()));
 
      return { buffer.begin(), buffer.end() - 1 };
    }
 
    template<>
    inline void CodecConfig::SetProperty<Cvb::String>(const Cvb::String& value, CExports::CVCBCodecProperty property, const Cvb::String& optionName)
    {
      CVB_CALL_CAPI_CHECKED(CVCBCodecConfigSetProperty(Handle(), property, const_cast<char*>(ToBytes(value).c_str()), value.size() + 1, optionName.empty() ? nullptr : ToBytes(optionName).c_str())); // NOLINT(cppcoreguidelines-pro-type-const-cast)
    }
 
    inline Cvb::String CodecConfig::Name() const
    {
      return Property<Cvb::String>(CExports::CVCBCP_Name);
    }
 
    inline Cvb::String CodecConfig::ToJson() const
    {
      return Property<Cvb::String>(CExports::CVCBCP_JSON);
    }
 
    template<>
    inline int64_t CodecConfig::Option<int64_t>(const Cvb::String& name) const
    {
      return Property<int64_t>(CExports::CVCBCP_IntOption, name);
    }
 
    template<>
    inline Cvb::String CodecConfig::Option<Cvb::String>(const Cvb::String& name) const
    {
      return Property<Cvb::String>(CExports::CVCBCP_StringOption, name);
    }
 
    template<>
    inline double CodecConfig::Option<double>(const Cvb::String& name) const
    {
      return Property<double>(CExports::CVCBCP_DoubleOption, name);
    }
 
    template<>
    inline Rational CodecConfig::Option<Rational>(const Cvb::String& name) const
    {
      auto rational = Property<CExports::CVCBRational>(CExports::CVCBCP_DoubleOption, name);
      return { rational.Numerator, rational.Denominator };
    }
 
    template<>
    inline void CodecConfig::AddOption<Cvb::String>(const Cvb::String& name, const Cvb::String& value)
    {
      SetProperty(value, CExports::CVCBCP_StringOption, name);
    }
 
    template<>
    inline void CodecConfig::AddOption<double>(const Cvb::String& name, const double& value)
    {
      SetProperty(value, CExports::CVCBCP_DoubleOption, name);
    }
 
    template<>
    inline void CodecConfig::AddOption<Rational>(const Cvb::String& name, const Rational& value)
    {
      SetProperty(*reinterpret_cast<const CExports::CVCBRational*>(&value), CExports::CVCBCP_RationalOption, name);
    }
 
    template<>
    inline void CodecConfig::AddOption<int64_t>(const Cvb::String& name, const int64_t& value)
    {
      SetProperty(value, CExports::CVCBCP_IntOption, name);
    }
 
    inline Cvb::String CodecConfig::SessionDescription(const Cvb::String& url)
    {
      SetProperty(url, CExports::CVCBCP_URL);
      return Property<Cvb::String>(CExports::CVCBCP_SDP);
    }
 
  }
 
  CVB_END_INLINE_NS
}