detail_buffer_image.hpp

#pragma once
 
#include "../../global.hpp"
 
#include "../../_decl/decl_device.hpp"
#include "../../_decl/decl_image_plane.hpp"
#include "../../_decl/decl_vpat.hpp"
 
#include "../_decl/decl_buffer_image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {
 
    inline std::unique_ptr<BufferImage::ImageLayout> BufferImage::ImageLayout::FromImage(const Image &image)
    {
      std::unique_ptr<ImageLayout> layout;
      auto linearLayout = BufferImage::LinearLayout::TryCreate(image);
      if (linearLayout)
        layout.reset(linearLayout.release());
      else
        layout = std::make_unique<BufferImage::NonLinearLayout>();
      return layout;
    }
 
    inline std::unique_ptr<BufferImage::ImageLayout> BufferImage::ImageLayout::FromIMGHandle(void *handle)
    {
      BufferImage::HandleImage image(handle);
      return FromImage(image);
    }
 
    inline void *BufferImage::ImageLayout::CloneIMGHandle(void *handle) const
    {
      BufferImage::HandleImage image(handle);
      return CloneImage(image);
    }
 
    inline std::unique_ptr<BufferImage> BufferImage::Create(const DevicePtr &device,
                                                            const BufferImage::ImageLayout &layout, double rawTimestamp)
    {
      HandleGuard<Image> guard(layout.CloneIMGHandle(device->Handle()));
      return std::make_unique<BufferImage>(std::move(guard), device, rawTimestamp, PrivateTag{});
    }
 
    inline std::unique_ptr<BufferImage> BufferImage::Create(const DevicePtr &device, double rawTimestamp)
    {
      return Create(device, *ImageLayout::FromIMGHandle(device->Handle()), rawTimestamp);
    }
 
    inline std::unique_ptr<BufferImage::LinearLayout> BufferImage::LinearLayout::TryCreate(const Image &image) noexcept
    {
      try
      {
        if (!image.PlaneDataTypesIdentical())
          return std::unique_ptr<LinearLayout>();
 
        auto numPlanes = image.PlanesCount();
        std::vector<LinearAccessData> planeData(numPlanes);
        std::vector<PlaneIndexPair> planeBases(numPlanes);
        for (int i = 0; i < static_cast<int>(planeData.size()); ++i)
        {
          if (!image.Plane(i).TryLinearAccess(planeData[i]))
            return std::unique_ptr<LinearLayout>();
 
          if (i > 0 && (planeData[i].XInc() != planeData[0].XInc() || planeData[i].YInc() != planeData[i].YInc()))
            return std::unique_ptr<LinearLayout>();
 
          planeBases[i].BasePtr    = planeData[i].BasePtr();
          planeBases[i].PlaneIndex = i;
        }
 
        std::intptr_t planeInc = 0;
        if (numPlanes > 1)
        {
          std::sort(planeBases.begin(), planeBases.end(),
                    [](const PlaneIndexPair &a, const PlaneIndexPair &b) { return a.BasePtr < b.BasePtr; });
          planeInc = planeBases[1].BasePtr - planeBases[0].BasePtr;
          for (int i = 2; i < numPlanes; ++i)
            if ((planeBases[i].BasePtr - planeBases[i - 1].BasePtr) != planeInc)
              return std::unique_ptr<LinearLayout>();
        }
 
        return std::make_unique<LinearLayout>(
            static_cast<size_t>(numPlanes) * static_cast<size_t>(image.Height()) * static_cast<size_t>(image.Width())
                * static_cast<size_t>(image.Plane(0).DataType().BytesPerPixel()),
            planeData[0].XInc(), planeData[0].YInc(), planeInc, planeBases, PrivateTag{});
      }
      catch (...)
      {
        return std::unique_ptr<LinearLayout>();
      }
    }
 
    inline void *BufferImage::LinearLayout::CloneImage(const Image &image) const
    {
      LinearAccessData linearAccess;
      image.Plane(0).TryLinearAccess(linearAccess);
      CExports::IMG img = nullptr;
      auto result       = CVB_CALL_CAPI(CreateImageFromPointer(
          reinterpret_cast<void *>(linearAccess.BasePtr()), memSize_, static_cast<CExports::cvbdim_t>(image.Width()),
          static_cast<CExports::cvbdim_t>(image.Height()), static_cast<CExports::cvbdim_t>(planeOrder_.size()),
          static_cast<CExports::cvbdatatype_t>(image.Plane(0).DataType().NativeDescriptor()), xInc_, yInc_, planeInc_,
          const_cast<CExports::cvbval_t *>(&planeOrder_[0]),  // NOLINT(cppcoreguidelines-pro-type-const-cast)
          nullptr, nullptr, img));
      if (result < 0)
        Utilities::SystemInfo::ThrowLastError(result);
 
      return img;
    }
 
    inline void *BufferImage::NonLinearLayout::MakeImageFromPlane(const ImagePlane &plane) const
    {
      auto width    = plane.Parent().Width();
      auto height   = plane.Parent().Height();
      auto dataType = plane.DataType();
      auto memSize =
          static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(dataType.BytesPerPixel());
      auto vpat         = plane.Vpat();
      CExports::IMG img = nullptr;
 
      CVB_CALL_CAPI(CreateImageFromPointer(reinterpret_cast<void *>(vpat.BasePtr()), memSize,
                                           static_cast<CExports::cvbdim_t>(width),
                                           static_cast<CExports::cvbdim_t>(height), static_cast<CExports::cvbdim_t>(1),
                                           static_cast<CExports::cvbdatatype_t>(dataType.NativeDescriptor()), 1, height,
                                           0, nullptr, nullptr, nullptr, img));
 
      try
      {
#ifdef max
#  undef max
#endif
        HandleImage image(img);
        auto targetVpat = image.Plane(0).Vpat().VpatPtr();
        auto sourceVpat = vpat.VpatPtr();
        auto vpatSize   = std::max(width, height);
        for (int e = 0; e < vpatSize; ++e)
          targetVpat[e] = sourceVpat[e];
        return img;
      }
      catch (...)
      {
        std::rethrow_exception(std::current_exception());
      }
    }
 
    inline void *BufferImage::NonLinearLayout::CloneImage(const Image &image) const
    {
      if (image.PlanesCount() == 1)
        return MakeImageFromPlane(image.Plane(0));
 
      std::vector<CExports::IMG> resultIMGs(image.PlanesCount());
      std::fill(resultIMGs.begin(), resultIMGs.end(), nullptr);
      ImageArrayGuard imageGuard(resultIMGs);
 
      for (size_t i = 0; i < resultIMGs.size(); ++i)
        resultIMGs[i] = MakeImageFromPlane(image.Plane(static_cast<int>(i)));
 
      CExports::IMG concatIMG = nullptr;
      if (!CVB_CALL_CAPI(CreateConcatenatedImage(&resultIMGs[0], resultIMGs.size(), true, concatIMG)))
        Utilities::SystemInfo::ThrowLastError();
      return concatIMG;
    }
 
  }  // namespace Driver
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb