decl_gendc_descriptor.hpp

#pragma once
 
#include "../../pfnc_format.hpp"
#include "../../shims/stdvariant.hpp"
#include "../../version.hpp"
#include "../driver.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<Driver::GenDcDescriptor>::HandleGuard(void *handle) noexcept
      : HandleGuard<Driver::GenDcDescriptor>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace Driver
  {
    struct GenDcDescriptorPartConfig
    {
      GenDcDescriptorPartConfig(GenDCPartType partType, PfncFormat pfncFormat, std::uint16_t flowId,
                                std::uint64_t flowOffset, std::uint64_t dataSize);

      GenDCPartType PartType;
      PfncFormat Format;
      std::uint16_t FlowId;
      std::uint64_t FlowOffset;
      std::uint64_t DataSize;
    };

    struct GenDcDescriptorMetadataPartConfig : public GenDcDescriptorPartConfig
    {
      GenDcDescriptorMetadataPartConfig(GenDCPartType partType, std::uint16_t flowId, std::uint64_t flowOffset,
                                        std::uint64_t dataSize);
    };

    struct GenDcDescriptorComponentConfig
    {
      ComponentId TypeId = ComponentId::Undefined;
      PfncFormat Format = PfncFormat::InvalidPixelFormat;
      std::vector<GenDcDescriptorPartConfig> Parts{};
    };

    struct GenDcDescriptorMetadataComponentConfig : public GenDcDescriptorComponentConfig
    {
      explicit GenDcDescriptorMetadataComponentConfig(const std::vector<GenDcDescriptorMetadataPartConfig> &parts);
    };

    struct GenDcDescriptorConfig
    {
      std::vector<GenDcDescriptorComponentConfig> Components{};
    };

    class GenDcPart
    {
    public:

      std::size_t GetOffset() const;

      GenDCPartType GetType() const;

      GenDcPartFlags GetFlags() const;

      std::uint32_t GetHeaderSize() const;

      PfncFormat GetFormat() const;

      std::uint16_t GetFlowId() const;

      std::size_t GetFlowOffset() const;

      std::size_t GetDataSize() const;

      std::size_t GetDataOffset() const;


      void SetFlags(GenDcPartFlags flags);

      void SetDataSize(std::size_t size);

      void SetDataOffset(std::size_t offset);
 
    protected:
      friend class GenDcComponent;
      GenDcPart(void *handle, size_t componentIdx, size_t partIdx);
 
      // NOLINTBEGIN misc-non-private-member-variables-in-classes
      void *handle_;
      size_t componentIdx_;
      size_t partIdx_;
      // NOLINTEND
    };

    class GenDcPartMetadata : public GenDcPart
    {
    public:

      std::uint64_t GetSize() const;

      std::uint16_t GetPadding() const;


      void SetSize(std::uint64_t size);

      void SetPadding(std::uint16_t padding);
 
    protected:
      friend class GenDcComponent;
      GenDcPartMetadata(void *handle, size_t componentIdx, size_t partIdx);
    };

    class GenDcPartMetadataGenICamChunk : public GenDcPartMetadata
    {
    public:

      std::uint64_t GetGenICamLayoutId() const;


      void SetGenICamLayoutId(std::uint64_t id);
 
    protected:
      friend class GenDcComponent;
      GenDcPartMetadataGenICamChunk(void *handle, size_t componentIdx, size_t partIdx);
    };

    class GenDcPartMetadataGenICamXML : public GenDcPartMetadata
    {
    public:

      std::uint64_t GetGenICamLayoutId() const;


      void SetGenICamLayoutId(std::uint64_t id);
 
    protected:
      friend class GenDcComponent;
      GenDcPartMetadataGenICamXML(void *handle, size_t componentIdx, size_t partIdx);
    };

    class GenDcPart1D : public GenDcPart
    {
    public:

      std::uint64_t GetSize() const;

      std::uint16_t GetPadding() const;


      void SetSize(std::uint64_t size);

      void SetPadding(std::uint16_t padding);
 
    protected:
      friend class GenDcComponent;
      GenDcPart1D(void *handle, size_t componentIdx, size_t partIdx);
    };

    class GenDcPart2D : public GenDcPart
    {
    public:
      virtual ~GenDcPart2D()                      = default;
      GenDcPart2D(const GenDcPart2D &)            = default;
      GenDcPart2D(GenDcPart2D &&)                 = default;
      GenDcPart2D &operator=(const GenDcPart2D &) = default;
      GenDcPart2D &operator=(GenDcPart2D &&)      = default;


      virtual std::uint32_t GetSizeX() const;

      virtual std::uint32_t GetSizeY() const;

      virtual std::uint16_t GetPaddingX() const;

      virtual std::uint16_t GetPaddingY() const;


      virtual void SetSizeX(std::uint32_t size);

      virtual void SetSizeY(std::uint32_t size);

      virtual void SetPaddingX(std::uint16_t padding);

      virtual void SetPaddingY(std::uint16_t padding);
 
    protected:
      friend class GenDcComponent;
      GenDcPart2D(void *handle, size_t componentIdx, size_t partIdx);
    };

    class GenDcPartH264 : public GenDcPart2D
    {
    public:

      std::uint32_t GetSizeX() const override;

      std::uint32_t GetSizeY() const override;

      std::uint16_t GetPaddingX() const override;

      std::uint16_t GetPaddingY() const override;

      std::uint8_t GetProfileIDC() const;

      H264Flags GetH264Flags() const;

      std::uint8_t GetLevelIDC() const;

      std::uint16_t GetSpropInterleavingDepth() const;

      std::uint16_t GetSpropMaxDonDiff() const;

      std::uint32_t GetSpropDeintBufReq() const;

      std::uint32_t GetSpropInitBufTime() const;


      void SetSizeX(std::uint32_t size) override;

      void SetSizeY(std::uint32_t size) override;

      void SetPaddingX(std::uint16_t padding) override;

      void SetPaddingY(std::uint16_t padding) override;

      void SetProfileIDC(std::uint8_t profile);

      void SetH264Flags(H264Flags flags);

      void SetLevelIDC(std::uint8_t level);

      void SetSpropInterleavingDepth(std::uint16_t depth);

      void SetSpropMaxDonDiff(std::uint16_t diff);

      void SetSpropDeintBufReq(std::uint32_t req);

      void SetSpropInitBufTime(std::uint32_t time);
 
    protected:
      friend class GenDcComponent;
      GenDcPartH264(void *handle, size_t componentIdx, size_t partIdx);
    };

    using GenDCPartVariant = variant<GenDcPart, GenDcPart1D, GenDcPart2D, GenDcPartMetadata,
                                     GenDcPartMetadataGenICamChunk, GenDcPartMetadataGenICamXML, GenDcPartH264>;

    class GenDcComponent
    {
    public:

      std::size_t GetOffset() const;

      GenDcComponentFlags GetFlags() const;

      std::uint32_t GetHeaderSize() const;

      std::uint16_t GetGroupId() const;

      std::uint16_t GetSourceId() const;

      std::uint16_t GetRegionId() const;

      std::uint32_t GetRegionOffsetX() const;

      std::uint32_t GetRegionOffsetY() const;

      std::uint64_t GetTimestamp() const;

      ComponentId GetTypeId() const;

      PfncFormat GetFormat() const;


      const std::vector<GenDCPartVariant> &GetParts() const;

      std::vector<GenDCPartVariant> &GetParts();


      void SetFlags(GenDcComponentFlags flags);

      void SetGroupId(std::uint16_t id);

      void SetSourceId(std::uint16_t id);

      void SetRegionId(std::uint16_t id);

      void SetRegionOffsetX(std::uint32_t offset);

      void SetRegionOffsetY(std::uint32_t offset);

      void SetTimestamp(std::uint64_t timestamp);
 
    private:
      friend class GenDcDescriptor;
      GenDcComponent(void *handle, size_t componentIdx);
 
      void *handle_;
      size_t componentIdx_;
      std::vector<GenDCPartVariant> parts_;
    };

    class GenDcDescriptor
    {
    public:
      using GuardType = HandleGuard<GenDcDescriptor>;


      static std::unique_ptr<GenDcDescriptor> Create(const GenDcDescriptorConfig &descriptorConfig);


      static std::unique_ptr<GenDcDescriptor> FromHandle(HandleGuard<GenDcDescriptor> &&guard);
 
      virtual ~GenDcDescriptor()                          = default;
      GenDcDescriptor(const GenDcDescriptor &)            = delete;
      GenDcDescriptor(GenDcDescriptor &&)                 = default;
      GenDcDescriptor &operator=(const GenDcDescriptor &) = delete;
      GenDcDescriptor &operator=(GenDcDescriptor &&)      = default;


      Version GetVersion() const;

      GenDcDescriptorFlag GetFlags() const;

      std::uint32_t GetHeaderSize() const;

      std::uint64_t GetContainerId() const;

      GenDcDescriptorVariableField GetVariableFields() const;

      std::uint64_t GetDataSize() const;

      std::int64_t GetDataOffset() const;

      std::uint32_t GetDescriptorSize() const;


      const std::vector<GenDcComponent> &GetComponents() const;


      std::vector<GenDcComponent> &GetComponents();


      size_t CalculateDataFlowCount() const;


      std::vector<size_t> CalculateDataFlowSizes() const;


      void SetFlags(GenDcDescriptorFlag flags);


      void SetContainerId(std::uint64_t id);


      void SetVariableFields(GenDcDescriptorVariableField fields);


      void SetDataSize(std::uint32_t size);


      std::size_t GetSerializedSize() const;


      void Serialize(std::uint8_t *buffer, std::size_t size) const;


      std::vector<std::uint8_t> Serialize() const;


      void *Handle() const noexcept;
 
    protected:
      explicit GenDcDescriptor(HandleGuard<GenDcDescriptor> &&guard);
 
    private:
      HandleGuard<GenDcDescriptor> handle_;
      std::vector<GenDcComponent> components_;
    };
  }  // namespace Driver
 
  using Driver::GenDcComponent;
  using Driver::GenDcDescriptor;
  using Driver::GenDcDescriptorComponentConfig;
  using Driver::GenDcDescriptorConfig;
  using Driver::GenDcDescriptorMetadataComponentConfig;
  using Driver::GenDcDescriptorMetadataPartConfig;
  using Driver::GenDcDescriptorPartConfig;
  using Driver::GenDcPart;
  using Driver::GenDcPart1D;
  using Driver::GenDcPart2D;
  using Driver::GenDcPartH264;
  using Driver::GenDcPartMetadata;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb