decl_buffer_image.hpp

#pragma once
 
#include <algorithm>
#include <exception>
#include <memory>
#include <vector>
 
#include "../../global.hpp"
#include "../driver.hpp"
#include "../stream_image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {
 
    class BufferImage : public StreamImage
    {
      struct PrivateTag
      {
      };
 
    public:
      class ImageLayout
      {
      public:
        static std::unique_ptr<ImageLayout> FromImage(const Image &image);
 
        static std::unique_ptr<ImageLayout> FromIMGHandle(void *handle);
 
        ImageLayout() noexcept                           = default;
        ImageLayout(const ImageLayout &other)            = delete;
        ImageLayout &operator=(const ImageLayout &other) = delete;
        ImageLayout(ImageLayout &&other)                 = delete;
        ImageLayout &operator=(ImageLayout &&other)      = delete;
 
        virtual ~ImageLayout() = default;
 
        virtual void *CloneImage(const Image &image) const = 0;
 
        void *CloneIMGHandle(void *handle) const;
      };
 
      static std::unique_ptr<BufferImage> Create(const DevicePtr &device, const ImageLayout &layout,
                                                 double rawTimestamp);
 
      static std::unique_ptr<BufferImage> Create(const DevicePtr &device, double rawTimestamp);
 
      BufferImage(HandleGuard<Image> &&guard, const DevicePtr &device, double rawTimestamp, PrivateTag) noexcept
          : StreamImage(std::move(guard))
          , device_(device)
      {
        SetRawTimestamp(rawTimestamp);
      }
 
    private:
      class HandleImage : public Image
      {
      public:
        explicit HandleImage(void *handle) noexcept
            : Image(HandleGuard<Image>(handle))
        {
        }
 
        HandleImage(const HandleImage &other)            = delete;
        HandleImage &operator=(const HandleImage &other) = delete;
        HandleImage(HandleImage &&other)                 = delete;
        HandleImage &operator=(HandleImage &&other)      = delete;
 
        virtual ~HandleImage()
        {
          Detach();
        }
      };
 
      class LinearLayout : public ImageLayout
      {
        struct PrivateTag
        {
        };
 
      private:
        struct PlaneIndexPair
        {
          std::uint8_t *BasePtr;
          int PlaneIndex;
        };
 
      public:
        static std::unique_ptr<LinearLayout> TryCreate(const Image &image) noexcept;
 
        void *CloneImage(const Image &image) const override;
 
        LinearLayout(std::size_t memSize, std::intptr_t xInc, std::intptr_t yInc, std::intptr_t planeInc,
                     const std::vector<PlaneIndexPair> &planeBases, PrivateTag)
            : memSize_(memSize)
            , xInc_(xInc)
            , yInc_(yInc)
            , planeInc_(planeInc)
        {
          std::vector<CExports::cvbval_t> planeOrder(planeBases.size());
          for (size_t i = 0; i < planeOrder.size(); ++i)
            planeOrder[i] = static_cast<CExports::cvbval_t>(planeBases[i].PlaneIndex);
 
          planeOrder.swap(planeOrder_);
        }
 
      private:
        std::size_t memSize_;
        std::intptr_t xInc_;
        std::intptr_t yInc_;
        std::intptr_t planeInc_;
        std::vector<CExports::cvbval_t> planeOrder_;
      };
 
      class NonLinearLayout : public ImageLayout
      {
 
      public:
        void *MakeImageFromPlane(const ImagePlane &plane) const;
 
        void *CloneImage(const Image &image) const override;
 
      private:
        class ImageArrayGuard
        {
        public:
          explicit ImageArrayGuard(std::vector<CExports::IMG> &imageArray)
              : imageArray_(imageArray)
          {
          }
 
          ImageArrayGuard(const ImageArrayGuard &other)            = delete;
          ImageArrayGuard &operator=(const ImageArrayGuard &other) = delete;
          ImageArrayGuard(ImageArrayGuard &&other)                 = delete;
          ImageArrayGuard &operator=(ImageArrayGuard &&other)      = delete;
 
          ~ImageArrayGuard()
          {
            for (auto &img : imageArray_)
              CVB_CALL_CAPI(ReleaseObject(img));
          }
 
        private:
          std::vector<CExports::IMG> &imageArray_;
        };
      };
 
      DevicePtr device_;
    };
 
  }  // namespace Driver
 
  using Driver::BufferImage;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb