detail_server.hpp

#pragma once
 
#include "../../_cexports/c_gev_server.h"
#include "../_decl/decl_node_map.hpp"
#include "../_decl/decl_server.hpp"
#include "../_decl/decl_stream.hpp"
#include "../../driver/flow_set_pool.hpp"
#include "../../driver/gendc_descriptor.hpp"
#include "../logical_network_interface.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {
 
    inline ServerPtr Server::CreateNonStreaming()
    {
      auto server =
          std::make_shared<Server>(HandleGuard<Server>(CVB_CALL_CAPI(CreateGevServer())), false, ProtectedTag{});
      return server;
    }
 
    inline ServerPtr Server::CreateWithConstSize(Size2D<int> size, PfncFormat pixelFormat,
                                                 GevServer::DriverType driverType)
    {
      // Check here is necessary as we cast to uint
      if (size.Width() < 1)
        throw std::runtime_error("Width must be larger or equal to 1");
      if (size.Height() < 1)
        throw std::runtime_error("Height must be larger or equal to 1");
      if (pixelFormat == PfncFormat::InvalidPixelFormat)
        throw std::runtime_error("Invalid pixel format");
 
      using namespace CExports;
      auto pixelFormatName = PfncFormatValue::ToANSI(pixelFormat);
      GSFixedSizeInitInfo init{GSSI_FixedSize,
                               static_cast<cvbuint32_t>(pixelFormat),
                               pixelFormatName.c_str(),
                               static_cast<cvbuint32_t>(size.Width()),
                               static_cast<cvbuint32_t>(size.Height()),
                               intptr_t()};  // Auto calculation
 
      auto server = std::make_shared<Server>(
          HandleGuard<Server>(
              CVB_CALL_CAPI(CreateGevServer2(static_cast<TDriver>(driverType), reinterpret_cast<GSInitInfo &>(init)))),
          true, ProtectedTag{});
      return server;
    }
 
    inline ServerPtr Server::CreateWithConstSize(Size2D<int> size, ColorModel colorModel, DataType dataType,
                                                 GevServer::DriverType driverType)
    {
      return CreateWithConstSize(size, PfncFormatValue::From(colorModel, dataType), driverType);
    }
 
    inline ServerPtr Server::CreateWithVariableSize(Size2D<int> maxSize, ColorModel colorModel, DataType dataType,
                                                    GevServer::DriverType driverType)
    {
      return CreateWithVariableSize(maxSize, PfncFormatValue::From(colorModel, dataType), driverType);
    }
 
    inline ServerPtr Server::CreateWithVariableSize(Size2D<int> maxSize, PfncFormat pixelFormat,
                                                    GevServer::DriverType driverType)
    {
      // check here is necessary as we cast to uint
      if (maxSize.Width() < 1)
        throw std::runtime_error("Width must be larger or equal to 1");
      if (maxSize.Height() < 1)
        throw std::runtime_error("Height must be larger or equal to 1");
      if (pixelFormat == PfncFormat::InvalidPixelFormat)
        throw std::runtime_error("Invalid pixel format");
 
      using namespace CExports;
      GSDynamicSizeInitInfo init{GSFixedSizeInitInfo{GSSI_DynamicSize, static_cast<CExports::cvbuint32_t>(pixelFormat),
                                                     PfncFormatValue::ToANSI(pixelFormat).c_str(),
                                                     static_cast<CExports::cvbuint32_t>(maxSize.Width()),
                                                     static_cast<CExports::cvbuint32_t>(maxSize.Height()), intptr_t()},
                                 static_cast<CExports::cvbuint32_t>(maxSize.Width()),
                                 static_cast<CExports::cvbuint32_t>(maxSize.Height())};
 
      auto server = std::make_shared<Server>(
          HandleGuard<Server>(
              CVB_CALL_CAPI(CreateGevServer2(static_cast<TDriver>(driverType), reinterpret_cast<GSInitInfo &>(init)))),
          true, ProtectedTag{});
 
      return server;
    }
 
    inline StreamPtr Server::Stream() const
    {
      if (hasStream_)
        return gsStream_.AtomicGet([&]() {
          return std::make_shared<GevServer::Stream>(std::const_pointer_cast<ServerBase>(shared_from_this()));
        });
      else
        return nullptr;
    }
 
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb