pixel_format_converter.hpp

#pragma once
 
#include <memory>
 
#include "_cexports/c_img.h"
#include "_cexports/c_pixfmtcnv.h"
 
#include "image.hpp"
#include "global.hpp"
#include "pfnc_format.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<PixelFormatConverter>::HandleGuard(void *handle) noexcept
      : HandleGuard<PixelFormatConverter>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }


  class PixelFormatConverter final
  {
  public:

    PixelFormatConverter(PfncFormat sourceFormat, PfncFormat destinationFormat)
        : handleGuard_(CreateHandle(sourceFormat, destinationFormat))
        , sourceFormat_(sourceFormat)
        , destinationFormat_(destinationFormat)
    {
    }
 
    PixelFormatConverter()                                        = delete;
    PixelFormatConverter(PixelFormatConverter &&other)            = default;
    PixelFormatConverter &operator=(PixelFormatConverter &&rhs)   = default;
    PixelFormatConverter(const PixelFormatConverter &)            = delete;
    PixelFormatConverter &operator=(const PixelFormatConverter &) = delete;
    ~PixelFormatConverter()                                       = default;


    static std::unique_ptr<PixelFormatConverter> Create(PfncFormat sourceFormat, PfncFormat destinationFormat)
    {
      return std::make_unique<PixelFormatConverter>(sourceFormat, destinationFormat);
    }


    void *Handle() const noexcept
    {
      return handleGuard_.Handle();
    }


    Cvb::PfncFormat SourceFormat() const noexcept
    {
      return sourceFormat_;
    }


    Cvb::PfncFormat DestinationFormat() const noexcept
    {
      return destinationFormat_;
    }


    template <class T>
    void Execute(const T &sourceObject, Image &destinationObject)
    {
      CVB_CALL_CAPI_CHECKED(
          CVPFConverterExecute(handleGuard_.Handle(), sourceObject.Handle(), destinationObject.Handle()));
    }
 
  private:
    void *CreateHandle(PfncFormat sourceFormat, PfncFormat destinationFormat)
    {
      void *handle = nullptr;
      CVB_CALL_CAPI_CHECKED(CVPFCreateConverter(static_cast<Cvb::CExports::cvbuint32_t>(sourceFormat),
                                                static_cast<Cvb::CExports::cvbuint32_t>(destinationFormat), handle));
      if (!handle)
        throw std::runtime_error("handle must not be null");
 
      return handle;
    }
 
    HandleGuard<PixelFormatConverter> handleGuard_;
    Cvb::PfncFormat sourceFormat_;
    Cvb::PfncFormat destinationFormat_;
  };
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb