detail_stream.hpp

#pragma once
 
#include "../../_cexports/c_gev_server.h"
#include "../../global.hpp"
 
#include "../_decl/decl_node_map.hpp"
 
#include "../_decl/decl_server.hpp"
#include "../_decl/decl_stream.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace GevServer
  {
    class Stream;
 
    inline void Stream::Send(const ImagePtr &image, std::function<void(const ImagePtr &)> imageReleased)
    {
      int result = InnerSend(image, imageReleased);
      if (result < 0)
        throw std::runtime_error("Could not send image");
    }
 
    inline bool Stream::TrySend(const ImagePtr &image, std::function<void(const ImagePtr &)> imageReleased)
    {
      return InnerSend(image, imageReleased) >= 0;
    }
 
    inline void Stream::Send(const Image &image)
    {
      if (ResendBuffersCount() > 0)
        throw std::runtime_error("Packet resend must be disabled for send without callback");
 
      int result = InnerSend(image);
      if (result < 0)
        throw std::runtime_error("Could not send image");
    }
 
    inline bool Stream::TrySend(const Image &image)
    {
      if (ResendBuffersCount() > 0)
        throw std::runtime_error("Packet resend must be disabled for send without callback");
 
      return InnerSend(image) >= 0;
    }
 
    inline void Stream::Send(const ImageBufferDescription &bufferDescription, void *basePtr,
                             const std::size_t &bufferSize, std::function<void(void *)> bufferReleased)
    {
      int result = InnerSend(bufferDescription, basePtr, bufferSize, bufferReleased);
      if (result < 0)
        throw std::runtime_error("Could not send image");
    }
 
    inline bool Stream::TrySend(const ImageBufferDescription &bufferDescription, void *basePtr,
                                const std::size_t &bufferSize, std::function<void(void *)> bufferReleased)
    {
      return InnerSend(bufferDescription, basePtr, bufferSize, bufferReleased) >= 0;
    }
 
    inline CExports::cvbres_t Stream::InnerSend(const ImagePtr &image, std::function<void(const ImagePtr &)> callback)
    {
      auto pPrivate =
          new std::function<void()>([imagePtr = image, callback]() mutable  // NOLINT(cppcoreguidelines-owning-memory)
                                    {
                                      callback(imagePtr);
                                      imagePtr.reset();
                                    });
      auto res = CVB_CALL_CAPI(GSSendImageCB(parent_->Handle(), image->Handle(), &Stream::SendDispatcher, pPrivate));
      if (res < 0)
        delete pPrivate;  // NOLINT(cppcoreguidelines-owning-memory) on success pPrivate is released in the
                          // SendDispatcher
      return res;
    }
 
    inline CExports::cvbres_t Stream::InnerSend(const Image &image)
    {
      return CVB_CALL_CAPI(GSSendImage(parent_->Handle(), image.Handle()));
    }
 
    inline CExports::cvbres_t Stream::InnerSend(const ImageBufferDescription &description, void *basePtr,
                                                std::size_t bufferSize, std::function<void(void *)> callback)
    {
      auto pPrivate  = new std::function<void()>([basePtr, callback]() { callback(basePtr); });
      auto dataBlock = description.ImageDataBlock();
      auto res       = CVB_CALL_CAPI(
          GSSendBlock(parent_->Handle(), reinterpret_cast<const CExports::GSDataBlock &>(dataBlock),
                            static_cast<CExports::cvbuint8_t *>(basePtr), bufferSize, &Stream::SendDispatcher, pPrivate));
      if (res < 0)
        delete pPrivate;  // NOLINT(cppcoreguidelines-owning-memory) on success pPrivate is released in the
                          // SendDispatcher
      return res;
    }
 
    inline CExports::cvbres_t Stream::InnerSend(const ChunkImageBufferDescription &description, void *basePtr,
                                                std::size_t bufferSize, std::function<void(void *)> callback)
    {
      auto pPrivate  = new std::function<void()>([basePtr, callback]() { callback(basePtr); });
      auto dataBlock = description.ChunkImageDataBlock();
      auto res       = CVB_CALL_CAPI(
          GSSendBlock(parent_->Handle(), reinterpret_cast<const CExports::GSDataBlock &>(dataBlock),
                            static_cast<CExports::cvbuint8_t *>(basePtr), bufferSize, &Stream::SendDispatcher, pPrivate));
      if (res < 0)
        delete pPrivate;  // NOLINT(cppcoreguidelines-owning-memory) on success pPrivate is released in the
                          // SendDispatcher
      return res;
    }
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb