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);
    }
 
  }  // namespace RTPStreaming
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb