image_buffer_description.hpp

#pragma once
 
#include "../_cexports/c_gev_server.h"
#include "../global.hpp"
#include "../point_2d.hpp"
#include "../size_2d.hpp"
#include "../pfnc_format.hpp"
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace GevServer
{
class ImageBufferDescription
{
  friend class Stream;
  friend class ChunkImageBufferDescription;
 
public:
  virtual ~ImageBufferDescription() = default;
 
  ImageBufferDescription(Size2D<int> size, ColorModel colorModel, DataType dataType)
      : ImageBufferDescription(size, PfncFormatValue::From(colorModel, dataType))
  {
  }
 
  ImageBufferDescription(Size2D<int> size, PfncFormat pixelFormat)
  {
    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");
 
    data_ = CExports::GSImageDataBlock{{CExports::TGSPayloadType::GSPT_Image},
                                       static_cast<CExports::cvbuint32_t>(pixelFormat),
                                       static_cast<CExports::cvbuint32_t>(size.Width()),
                                       static_cast<CExports::cvbuint32_t>(size.Height()),
                                       {},
                                       {},
                                       {},
                                       {},
                                       {}};
  }
 
  PfncFormat PixelFormat() const noexcept { return static_cast<PfncFormat>(data_.PixelFormat); }
 
  void SetPixelFormat(const PfncFormat &pixelFormat)
  {
    if (pixelFormat == PfncFormat::InvalidPixelFormat)
      throw std::runtime_error("Invalid pixel format");
 
    data_.PixelFormat = static_cast<CExports::cvbuint32_t>(pixelFormat);
  }
 
  Size2D<int> Size() const noexcept
  {
    return Size2D<int>(static_cast<int>(data_.Width), static_cast<int>(data_.Height));
  }
 
  void SetSize(const Size2D<int> &size)
  {
    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");
 
    data_.Width = static_cast<CExports::cvbuint32_t>(size.Width());
    data_.Height = static_cast<CExports::cvbuint32_t>(size.Height());
  }
 
  Point2D<int> Offset() const noexcept
  {
    return Point2D<int>(static_cast<int>(data_.XOffset), static_cast<int>(data_.YOffset));
  }
 
  void SetOffset(Point2D<int> point)
  {
    if (point.X() < 0)
      throw std::runtime_error("X must be larger or equal to 0");
    if (point.Y() < 0)
      throw std::runtime_error("Y must be larger or equal to 0");
 
    data_.XOffset = static_cast<CExports::cvbuint32_t>(point.X());
    data_.YOffset = static_cast<CExports::cvbuint32_t>(point.Y());
  }
 
  int LinePadding() const noexcept { return static_cast<int>(data_.XPadding); }
 
  void SetLinePadding(int padding) { data_.XPadding = static_cast<CExports::cvbuint32_t>(padding); }
 
private:
  CExports::GSImageDataBlock ImageDataBlock() { return data_; }
 
  CExports::GSImageDataBlock data_;
};
}
CVB_END_INLINE_NS
}