stream_config.hpp

#pragma once
 
#include <map>
 
#include "rtpstreaming.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<RTPStreaming::StreamConfig>::HandleGuard(void* handle) noexcept
    : HandleGuard<RTPStreaming::StreamConfig>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace RTPStreaming
  {
 
    class StreamConfig final
    {
    public:
 
 
      static std::unique_ptr<StreamConfig> Create()
      {
        return Internal::DoResCallObjectOut<StreamConfig>([&](void*& handle)
          {
            return CVB_CALL_CAPI(CVRTPCreateStreamConfig(handle));
          });
      }
 
      static std::unique_ptr<StreamConfig> FromHandle(HandleGuard<StreamConfig>&& guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        return std::make_unique<StreamConfig>(std::move(guard));
      }
 
      explicit StreamConfig(HandleGuard<StreamConfig>&& guard) noexcept
        : handle_(std::move(guard))
      {
 
      }
 
      StreamConfig(const StreamConfig& other) = delete;
      StreamConfig& operator=(const StreamConfig& other) = delete;
      StreamConfig(StreamConfig&& other) = delete;
      StreamConfig& operator=(StreamConfig&& other) = delete;
 
      ~StreamConfig() = default;
 
      void* Handle() const noexcept
      {
        return handle_.Handle();
      }
 
 
      String DstAddr() const;
 
 
      void SetDstAddr(const String& dstAddr);
 
 
      uint16_t DstPort() const
      {
        return Property<uint16_t>(CExports::CVRTPSP_DST_PORT);
      }
 
 
      void SetDstPort(uint16_t port)
      {
        return SetProperty<uint16_t>(port, CExports::CVRTPSP_DST_PORT);
      }
 
 
      String URL() const;
 
 
      void SetURL(const String& url);
 
 
      void SetupCodecFromJSON(const String& codecJSON);
 
 
      void SetupCodecWithName(const String& codecName);
 
 
      String ReadCodecJSON() const;
 
 
      String ReadSessionDescriptionProtocol() const;
 
    private:
 
      template<class T>
      T Property(CExports::CVRTPStreamProperty property) const
      {
        T value = {};
        size_t size = sizeof(T);
        CVB_CALL_CAPI_CHECKED(CVRTPStreamConfigGetProperty(Handle(), property, &value, size));
        return value;
      }
 
      template<class T>
      void SetProperty(const T& value, CExports::CVRTPStreamProperty property)
      {
        CVB_CALL_CAPI_CHECKED(CVRTPStreamConfigSetProperty(Handle(), property, const_cast<T*>(&value), sizeof(T))); // NOLINT(cppcoreguidelines-pro-type-const-cast)
      }
 
      static std::string ToBytes(const std::wstring& text)
      {
        // we can be sure that properties 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<StreamConfig> handle_;
 
    };
 
    template<>
    inline String StreamConfig::Property<String>(CExports::CVRTPStreamProperty property) const
    {
 
      size_t size = 0;
      CVB_CALL_CAPI_CHECKED(CVRTPStreamConfigGetProperty(Handle(), property, nullptr, size));
 
      std::vector<char> buffer(size);
      CVB_CALL_CAPI_CHECKED(CVRTPStreamConfigGetProperty(Handle(), property, buffer.data(), size));
 
      return { buffer.begin(), buffer.end() - 1 };
    }
 
    template<>
    inline void StreamConfig::SetProperty<String>(const String& value, CExports::CVRTPStreamProperty property)
    {
      CVB_CALL_CAPI_CHECKED(CVRTPStreamConfigSetProperty(Handle(), property, const_cast<char*>(ToBytes(value).c_str()), value.size() + 1)); // NOLINT(cppcoreguidelines-pro-type-const-cast)
    }
 
 
    String StreamConfig::DstAddr() const
    {
      return Property<String>(CExports::CVRTPSP_DST_ADDR);
    }
 
    void StreamConfig::SetDstAddr(const String& dstAddr)
    {
      SetProperty<String>(dstAddr, CExports::CVRTPSP_DST_ADDR);
    }
 
    String StreamConfig::URL() const
    {
      return Property<String>(CExports::CVRTPSP_URL);
    }
 
    void StreamConfig::SetURL(const String& url)
    {
      SetProperty<String>(url, CExports::CVRTPSP_URL);
    }
 
    void StreamConfig::SetupCodecFromJSON(const String& codecJSON)
    {
      SetProperty<String>(codecJSON, CExports::CVRTPSP_CodecJSON);
    }
 
    void StreamConfig::SetupCodecWithName(const String& codecName)
    {
      SetProperty<String>(codecName, CExports::CVRTPSP_CodecName);
    }
 
    String StreamConfig::ReadCodecJSON() const
    {
      return Property<String>(CExports::CVRTPSP_CodecJSON);
    }
 
    String StreamConfig::ReadSessionDescriptionProtocol() const
    {
      return Property<String>(CExports::CVRTPSP_SDP);
    }
 
  }
 
  CVB_END_INLINE_NS
 
}