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
}