stream.hpp

#pragma once
 
#include "rtpstreaming.hpp"
#include "../global.hpp"
#include "../image.hpp"
#include "../utilities/system_info.hpp"
 
#include "stream_config.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<RTPStreaming::Stream>::HandleGuard(void *handle) noexcept
      : HandleGuard<RTPStreaming::Stream>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace RTPStreaming
  {
    class Stream final
    {
 
    public:

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


      void PushImage(const Image &image)
      {
        CVB_CALL_CAPI_CHECKED(CVRTPStreamPushImage(Handle(), image.Handle()));
      }
      void PushImage(const Image &image) {…}
 
    private:
      HandleGuard<Stream> handle_;
    };
    class Stream final {…};
 
  }  // namespace RTPStreaming
 
  CVB_END_INLINE_NS
}  // namespace Cvb