decl_stream.hpp

#pragma once
 
#include "../../global.hpp"
 
#include "../../image.hpp"
 
#include "../chunk_image_buffer_description.hpp"
#include "../gevserver.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {

    class Stream : public std::enable_shared_from_this<Stream>
    {
    public:
      explicit Stream(const ServerPtr &parent)
          : parent_(parent)
      {
        if (!parent_)
          throw std::runtime_error("Server for stream creation must not be null.");
      }
      explicit Stream(const ServerPtr &parent) {…}
 
      virtual ~Stream() {}
      Stream(const Stream &other) noexcept       = delete;
      Stream(Stream &&) noexcept                 = default;
      Stream &operator=(Stream &&) noexcept      = default;
      Stream &operator=(const Stream &) noexcept = delete;

      ServerPtr Parent();

      bool IsRunning() const;

      std::int64_t ResendBuffersCount() const;

      void SetResendBuffersCount(const std::int64_t &numBuffers);

      void Send(const ImagePtr &image, std::function<void(const ImagePtr &)> imageReleased);

      bool TrySend(const ImagePtr &image, std::function<void(const ImagePtr &)> imageReleased);

      void Send(const Image &image);

      bool TrySend(const Image &image);

      void Send(const ImageBufferDescription &bufferDescription, void *basePtr, const std::size_t &bufferSize,
                std::function<void(void *)> bufferReleased);

      bool TrySend(const ImageBufferDescription &bufferDescription, void *basePtr, const std::size_t &bufferSize,
                   std::function<void(void *)> bufferReleased);
 
    private:
      static void __stdcall SendDispatcher(void *pPrivate)
      {
        try
        {
          // Call thread context of Send function
          if (auto pFunction = reinterpret_cast<std::function<void(void)> *>(pPrivate))
          {
            (*pFunction)();
            delete pFunction;  // NOLINT(cppcoreguidelines-owning-memory)
          }
        }
        catch (...)
        {
          // swallow exception so they don't propagate to native library.
        }
      }
 
      CExports::cvbres_t InnerSend(const ImagePtr &image, std::function<void(const ImagePtr &)> callback);
 
      CExports::cvbres_t InnerSend(const Image &image);
 
      CExports::cvbres_t InnerSend(const ImageBufferDescription &description, void *basePtr, std::size_t bufferSize,
                                   std::function<void(void *)> callback);
 
      CExports::cvbres_t InnerSend(const ChunkImageBufferDescription &description, void *basePtr,
                                   std::size_t bufferSize, std::function<void(void *)> callback);
 
      ServerPtr parent_;
    };
    class Stream : public std::enable_shared_from_this<Stream> {…};
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb