detail_gendc_descriptor.hpp

#pragma once
 
#include "../_decl/decl_gendc_descriptor.hpp"
#include "../../_cexports/c_driver.h"
 
#include "../../global.hpp"
#include "../../composite.hpp"
#include "../../utilities/system_info.hpp"
 
#include <numeric>
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {
    namespace Detail
    {
      template <typename T>
      T GetPartInfo(void *handle, CExports::CVDGNDCPartInfoCmd cmd, std::size_t componentIdx, std::size_t partIdx)
      {
        return Internal::DoResCallValueOut<T>([&](T &value) {
          size_t valueSize = sizeof(T);
          return CVB_CALL_CAPI(CVDGNDCGetPartInfo(handle, cmd, valueSize, &value, componentIdx, partIdx));
        });
      }
 
      template <typename T>
      void SetPartInfo(void *handle, CExports::CVDGNDCPartInfoCmd cmd, std::size_t componentIdx, std::size_t partIdx,
                       const T &value)
      {
        return Internal::DoResCall([&]() {
          size_t valueSize = sizeof(T);
          return CVB_CALL_CAPI(CVDGNDCSetPartInfo(handle, cmd, valueSize, &value, componentIdx, partIdx));
        });
      }
 
      template <typename T>
      T GetComponentInfo(void *handle, CExports::CVDGNDCComponentInfoCmd cmd, std::size_t componentIdx)
      {
        return Internal::DoResCallValueOut<T>([&](T &value) {
          size_t valueSize = sizeof(T);
          return CVB_CALL_CAPI(CVDGNDCGetComponentInfo(handle, cmd, valueSize, &value, componentIdx));
        });
      }
 
      template <typename T>
      void SetComponentInfo(void *handle, CExports::CVDGNDCComponentInfoCmd cmd, std::size_t componentIdx,
                            const T &value)
      {
        return Internal::DoResCall([&]() {
          size_t valueSize = sizeof(T);
          return CVB_CALL_CAPI(CVDGNDCSetComponentInfo(handle, cmd, valueSize, &value, componentIdx));
        });
      }
 
      template <typename T>
      T GetHeaderInfo(void *handle, CExports::CVDGNDCHeaderInfoCmd cmd)
      {
        return Internal::DoResCallValueOut<T>([&](T &value) {
          size_t valueSize = sizeof(T);
          return CVB_CALL_CAPI(CVDGNDCGetHeaderInfo(handle, cmd, valueSize, &value));
        });
      }
 
      template <typename T>
      void SetHeaderInfo(void *handle, CExports::CVDGNDCHeaderInfoCmd cmd, T &value)
      {
        return Internal::DoResCall([&]() {
          size_t valueSize = sizeof(T);
          return CVB_CALL_CAPI(CVDGNDCSetHeaderInfo(handle, cmd, valueSize, &value));
        });
      }
    }  // namespace Detail
 
    inline GenDcDescriptorPartConfig::GenDcDescriptorPartConfig(GenDCPartType partType, Cvb::PfncFormat pfncFormat,
                                                                std::uint16_t flowId, std::uint64_t flowOffset,
                                                                std::uint64_t dataSize)
        : PartType{partType}
        , Format{pfncFormat}
        , FlowId{flowId}
        , FlowOffset{flowOffset}
        , DataSize{dataSize}
    {
    }
 
    inline GenDcDescriptorMetadataPartConfig::GenDcDescriptorMetadataPartConfig(GenDCPartType partType,
                                                                                std::uint16_t flowId,
                                                                                std::uint64_t flowOffset,
                                                                                std::uint64_t dataSize)
        : GenDcDescriptorPartConfig{partType, PfncFormat::Data8, flowId, flowOffset, dataSize}
    {
      if ((static_cast<std::underlying_type_t<GenDCPartType>>(partType)
           & static_cast<std::underlying_type_t<GenDCPartType>>(GenDCPartType::_TypeGenericPartMetadata))
          == 0)
        throw std::runtime_error("GenDcDescriptorMetadataPart must contain a metadata part type");
    }
 
    inline GenDcDescriptorMetadataComponentConfig::GenDcDescriptorMetadataComponentConfig(
        const std::vector<GenDcDescriptorMetadataPartConfig> &parts)
        : GenDcDescriptorComponentConfig{ComponentId::Metadata, PfncFormat::Data8}
    {
      std::transform(parts.begin(), parts.end(), std::back_inserter(Parts),
                     [](const auto &part) { return static_cast<GenDcDescriptorPartConfig>(part); });
    }
 
    inline GenDcPart::GenDcPart(void *handle, size_t componentIdx, size_t partIdx)
        : handle_{handle}
        , componentIdx_{componentIdx}
        , partIdx_{partIdx}
    {
    }
 
    inline std::size_t GenDcPart::GetOffset() const
    {
      return Detail::GetPartInfo<std::uint64_t>(handle_, CExports::CVDGNDCPI_PartOffset, componentIdx_, partIdx_);
    }
 
    inline GenDCPartType GenDcPart::GetType() const
    {
      return Detail::GetPartInfo<GenDCPartType>(handle_, CExports::CVDGNDCPI_HeaderType, componentIdx_, partIdx_);
    }
 
    inline GenDcPartFlags GenDcPart::GetFlags() const
    {
      return Detail::GetPartInfo<GenDcPartFlags>(handle_, CExports::CVDGNDCPI_FlagsValue, componentIdx_, partIdx_);
    }
 
    inline std::uint32_t GenDcPart::GetHeaderSize() const
    {
      return Detail::GetPartInfo<std::uint32_t>(handle_, CExports::CVDGNDCPI_HeaderSize, componentIdx_, partIdx_);
    }
 
    inline PfncFormat GenDcPart::GetFormat() const
    {
      return Detail::GetPartInfo<PfncFormat>(handle_, CExports::CVDGNDCPI_Format, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPart::GetFlowId() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDCPI_FlowId, componentIdx_, partIdx_);
    }
 
    inline std::size_t GenDcPart::GetFlowOffset() const
    {
      return Detail::GetPartInfo<std::size_t>(handle_, CExports::CVDGNDCPI_FlowOffset, componentIdx_, partIdx_);
    }
 
    inline std::size_t GenDcPart::GetDataOffset() const
    {
      return Detail::GetPartInfo<std::size_t>(handle_, CExports::CVDGNDCPI_DataOffset, componentIdx_, partIdx_);
    }
 
    inline std::size_t GenDcPart::GetDataSize() const
    {
      return Detail::GetPartInfo<std::size_t>(handle_, CExports::CVDGNDCPI_DataSize, componentIdx_, partIdx_);
    }
 
    inline void GenDcPart::SetFlags(GenDcPartFlags flags)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCPI_FlagsValue, componentIdx_, partIdx_, flags);
    }
 
    inline void GenDcPart::SetDataOffset(std::size_t offset)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCPI_DataOffset, componentIdx_, partIdx_, offset);
    }
 
    inline void GenDcPart::SetDataSize(std::size_t size)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCPI_DataSize, componentIdx_, partIdx_, size);
    }
 
    inline std::uint64_t GenDcPartMetadata::GetSize() const
    {
      return Detail::GetPartInfo<std::uint64_t>(handle_, CExports::CVDGNDC1DPI_Size, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPartMetadata::GetPadding() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDC1DPI_Padding, componentIdx_, partIdx_);
    }
 
    inline void GenDcPartMetadata::SetSize(std::uint64_t size)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC1DPI_Size, componentIdx_, partIdx_, size);
    }
 
    inline void GenDcPartMetadata::SetPadding(std::uint16_t padding)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC1DPI_Padding, componentIdx_, partIdx_, padding);
    }
 
    inline GenDcPartMetadata::GenDcPartMetadata(void *handle, size_t componentIdx, size_t partIdx)
        : GenDcPart{handle, componentIdx, partIdx}
    {
    }
 
    inline std::uint64_t GenDcPartMetadataGenICamChunk::GetGenICamLayoutId() const
    {
      return Detail::GetPartInfo<std::uint64_t>(handle_, CExports::CVDGNCDC1DPI_InfoTypeSpecific, componentIdx_,
                                                partIdx_);
    }
 
    inline void GenDcPartMetadataGenICamChunk::SetGenICamLayoutId(std::uint64_t id)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNCDC1DPI_InfoTypeSpecific, componentIdx_, partIdx_, id);
    }
 
    inline GenDcPartMetadataGenICamChunk::GenDcPartMetadataGenICamChunk(void *handle, size_t componentIdx,
                                                                        size_t partIdx)
        : GenDcPartMetadata{handle, componentIdx, partIdx}
    {
    }
 
    inline std::uint64_t GenDcPartMetadataGenICamXML::GetGenICamLayoutId() const
    {
      return Detail::GetPartInfo<std::uint64_t>(handle_, CExports::CVDGNCDC1DPI_InfoTypeSpecific, componentIdx_,
                                                partIdx_);
    }
 
    inline void GenDcPartMetadataGenICamXML::SetGenICamLayoutId(std::uint64_t id)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNCDC1DPI_InfoTypeSpecific, componentIdx_, partIdx_, id);
    }
 
    inline GenDcPartMetadataGenICamXML::GenDcPartMetadataGenICamXML(void *handle, size_t componentIdx, size_t partIdx)
        : GenDcPartMetadata{handle, componentIdx, partIdx}
    {
    }
 
    inline std::uint64_t GenDcPart1D::GetSize() const
    {
      return Detail::GetPartInfo<std::uint64_t>(handle_, CExports::CVDGNDC1DPI_Size, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPart1D::GetPadding() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDC1DPI_Padding, componentIdx_, partIdx_);
    }
 
    inline void GenDcPart1D::SetSize(std::uint64_t size)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC1DPI_Size, componentIdx_, partIdx_, size);
    }
 
    inline void GenDcPart1D::SetPadding(std::uint16_t padding)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC1DPI_Padding, componentIdx_, partIdx_, padding);
    }
 
    inline GenDcPart1D::GenDcPart1D(void *handle, size_t componentIdx, size_t partIdx)
        : GenDcPart{handle, componentIdx, partIdx}
    {
    }
 
    inline std::uint32_t GenDcPart2D::GetSizeX() const
    {
      return Detail::GetPartInfo<std::uint32_t>(handle_, CExports::CVDGNDC2DPI_SizeX, componentIdx_, partIdx_);
    }
 
    inline std::uint32_t GenDcPart2D::GetSizeY() const
    {
      return Detail::GetPartInfo<std::uint32_t>(handle_, CExports::CVDGNDC2DPI_SizeY, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPart2D::GetPaddingX() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDC2DPI_PaddingX, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPart2D::GetPaddingY() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDC2DPI_PaddingY, componentIdx_, partIdx_);
    }
 
    inline void GenDcPart2D::SetSizeX(std::uint32_t size)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC2DPI_SizeX, componentIdx_, partIdx_, size);
    }
 
    inline void GenDcPart2D::SetSizeY(std::uint32_t size)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC2DPI_SizeY, componentIdx_, partIdx_, size);
    }
 
    inline void GenDcPart2D::SetPaddingX(std::uint16_t padding)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC2DPI_PaddingX, componentIdx_, partIdx_, padding);
    }
 
    inline void GenDcPart2D::SetPaddingY(std::uint16_t padding)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDC2DPI_PaddingY, componentIdx_, partIdx_, padding);
    }
 
    inline GenDcPart2D::GenDcPart2D(void *handle, size_t componentIdx, size_t partIdx)
        : GenDcPart{handle, componentIdx, partIdx}
    {
    }
 
    inline std::uint32_t GenDcPartH264::GetSizeX() const
    {
      return Detail::GetPartInfo<std::uint32_t>(handle_, CExports::CVDGNDCH264PI_SizeX, componentIdx_, partIdx_);
    }
 
    inline std::uint32_t GenDcPartH264::GetSizeY() const
    {
      return Detail::GetPartInfo<std::uint32_t>(handle_, CExports::CVDGNDCH264PI_SizeY, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPartH264::GetPaddingX() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDCH264PI_PaddingX, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPartH264::GetPaddingY() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDCH264PI_PaddingY, componentIdx_, partIdx_);
    }
 
    inline std::uint8_t GenDcPartH264::GetProfileIDC() const
    {
      return Detail::GetPartInfo<std::uint8_t>(handle_, CExports::CVDGNDCH264PI_ProfileIDC, componentIdx_, partIdx_);
    }
 
    inline H264Flags GenDcPartH264::GetH264Flags() const
    {
      return Detail::GetPartInfo<H264Flags>(handle_, CExports::CVDGNDCH264PI_H264Flags, componentIdx_, partIdx_);
    }
 
    inline std::uint8_t GenDcPartH264::GetLevelIDC() const
    {
      return Detail::GetPartInfo<std::uint8_t>(handle_, CExports::CVDGNDCH264PI_LevelIDC, componentIdx_, partIdx_);
    }
 
    inline std::uint16_t GenDcPartH264::GetSpropInterleavingDepth() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDCH264PI_SpropInterleavingDepth, componentIdx_,
                                                partIdx_);
    }
    inline std::uint16_t GenDcPartH264::GetSpropMaxDonDiff() const
    {
      return Detail::GetPartInfo<std::uint16_t>(handle_, CExports::CVDGNDCH264PI_SpropMaxDonDiff, componentIdx_,
                                                partIdx_);
    }
 
    inline std::uint32_t GenDcPartH264::GetSpropDeintBufReq() const
    {
      return Detail::GetPartInfo<std::uint32_t>(handle_, CExports::CVDGNDCH264PI_SpropDeintBufReq, componentIdx_,
                                                partIdx_);
    }
 
    inline std::uint32_t GenDcPartH264::GetSpropInitBufTime() const
    {
      return Detail::GetPartInfo<std::uint32_t>(handle_, CExports::CVDGNDCH264PI_SpropInitBufTime, componentIdx_,
                                                partIdx_);
    }
 
    inline void GenDcPartH264::SetSizeX(std::uint32_t size)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_SizeX, componentIdx_, partIdx_, size);
    }
 
    inline void GenDcPartH264::SetSizeY(std::uint32_t size)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_SizeY, componentIdx_, partIdx_, size);
    }
 
    inline void GenDcPartH264::SetPaddingX(std::uint16_t padding)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_PaddingX, componentIdx_, partIdx_, padding);
    }
 
    inline void GenDcPartH264::SetPaddingY(std::uint16_t padding)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_PaddingY, componentIdx_, partIdx_, padding);
    }
 
    inline void GenDcPartH264::SetProfileIDC(std::uint8_t profile)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_ProfileIDC, componentIdx_, partIdx_, profile);
    }
 
    inline void GenDcPartH264::SetH264Flags(H264Flags flags)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_H264Flags, componentIdx_, partIdx_, flags);
    }
 
    inline void GenDcPartH264::SetLevelIDC(std::uint8_t level)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_LevelIDC, componentIdx_, partIdx_, level);
    }
 
    inline void GenDcPartH264::SetSpropInterleavingDepth(std::uint16_t depth)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_SpropInterleavingDepth, componentIdx_, partIdx_, depth);
    }
 
    inline void GenDcPartH264::SetSpropMaxDonDiff(std::uint16_t diff)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_SpropMaxDonDiff, componentIdx_, partIdx_, diff);
    }
 
    inline void GenDcPartH264::SetSpropDeintBufReq(std::uint32_t req)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_SpropDeintBufReq, componentIdx_, partIdx_, req);
    }
 
    inline void GenDcPartH264::SetSpropInitBufTime(std::uint32_t time)
    {
      Detail::SetPartInfo(handle_, CExports::CVDGNDCH264PI_SpropInitBufTime, componentIdx_, partIdx_, time);
    }
 
    inline GenDcPartH264::GenDcPartH264(void *handle, size_t componentIdx, size_t partIdx)
        : GenDcPart2D{handle, componentIdx, partIdx}
    {
    }
 
    inline GenDcComponent::GenDcComponent(void *handle, size_t componentIdx)
        : handle_{handle}
        , componentIdx_{componentIdx}
    {
      const auto partCount =
          Detail::GetComponentInfo<std::uint16_t>(handle_, CExports::CVDGNDCCMPI_PartCount, componentIdx_);
      for (std::size_t idx = 0; idx < partCount; ++idx)
      {
        const auto type =
            Detail::GetPartInfo<GenDCPartType>(handle_, CExports::CVDGNDCPI_HeaderType, componentIdx_, idx);
        switch (type)
        {
          case GenDCPartType::TypeMetadataGenICamChunk:
            parts_.push_back(GenDcPartMetadataGenICamChunk{handle_, componentIdx_, idx});
            break;
          case GenDCPartType::TypeMetadataGenICamXML:
            parts_.push_back(GenDcPartMetadataGenICamXML{handle_, componentIdx_, idx});
            break;
          case GenDCPartType::Type1D:
            parts_.push_back(GenDcPart1D{handle_, componentIdx_, idx});
            break;
          case GenDCPartType::Type2D:
            // fallthrough
          case GenDCPartType::TypeJPEG:
            // fallthrough
          case GenDCPartType::TypeJPEG2000:
            parts_.push_back(GenDcPart2D{handle_, componentIdx_, idx});
            break;
          case GenDCPartType::TypeH264:
            parts_.push_back(GenDcPartH264{handle_, componentIdx_, idx});
            break;
          default:
            parts_.push_back(GenDcPart{handle_, componentIdx_, idx});
            break;
        }
      }
    }
 
    inline std::size_t GenDcComponent::GetOffset() const
    {
      return Detail::GetComponentInfo<std::uint64_t>(handle_, CExports::CVDGNDCCMPI_ComponentOffset, componentIdx_);
    }
 
    inline GenDcComponentFlags GenDcComponent::GetFlags() const
    {
      return Detail::GetComponentInfo<GenDcComponentFlags>(handle_, CExports::CVDGNDCCMPI_FlagsValue, componentIdx_);
    }
 
    inline std::uint32_t GenDcComponent::GetHeaderSize() const
    {
      return Detail::GetComponentInfo<std::uint32_t>(handle_, CExports::CVDGNDCCMPI_HeaderSize, componentIdx_);
    }
 
    inline std::uint16_t GenDcComponent::GetGroupId() const
    {
      return Detail::GetComponentInfo<std::uint16_t>(handle_, CExports::CVDGNDCCMPI_GroupId, componentIdx_);
    }
 
    inline std::uint16_t GenDcComponent::GetSourceId() const
    {
      return Detail::GetComponentInfo<std::uint16_t>(handle_, CExports::CVDGNDCCMPI_SourceId, componentIdx_);
    }
 
    inline std::uint16_t GenDcComponent::GetRegionId() const
    {
      return Detail::GetComponentInfo<std::uint16_t>(handle_, CExports::CVDGNDCCMPI_RegionId, componentIdx_);
    }
 
    inline std::uint32_t GenDcComponent::GetRegionOffsetX() const
    {
      return Detail::GetComponentInfo<std::uint32_t>(handle_, CExports::CVDGNDCCMPI_RegionOffsetX, componentIdx_);
    }
 
    inline std::uint32_t GenDcComponent::GetRegionOffsetY() const
    {
      return Detail::GetComponentInfo<std::uint32_t>(handle_, CExports::CVDGNDCCMPI_RegionOffsetY, componentIdx_);
    }
 
    inline std::uint64_t GenDcComponent::GetTimestamp() const
    {
      return Detail::GetComponentInfo<std::uint64_t>(handle_, CExports::CVDGNDCCMPI_Timestamp, componentIdx_);
    }
 
    inline ComponentId GenDcComponent::GetTypeId() const
    {
      return static_cast<ComponentId>(
          Detail::GetComponentInfo<std::uint64_t>(handle_, CExports::CVDGNDCCMPI_TypeId, componentIdx_));
    }
 
    inline PfncFormat GenDcComponent::GetFormat() const
    {
      return Detail::GetComponentInfo<PfncFormat>(handle_, CExports::CVDGNDCCMPI_Format, componentIdx_);
    }
 
    inline const std::vector<GenDCPartVariant> &GenDcComponent::GetParts() const
    {
      return parts_;
    }
 
    inline std::vector<GenDCPartVariant> &GenDcComponent::GetParts()
    {
      return parts_;
    }
 
    inline void GenDcComponent::SetFlags(GenDcComponentFlags flags)
    {
      return Detail::SetComponentInfo(handle_, CExports::CVDGNDCCMPI_FlagsValue, componentIdx_, flags);
    }
 
    inline void GenDcComponent::SetGroupId(std::uint16_t id)
    {
      return Detail::SetComponentInfo(handle_, CExports::CVDGNDCCMPI_GroupId, componentIdx_, id);
    }
 
    inline void GenDcComponent::SetSourceId(std::uint16_t id)
    {
      return Detail::SetComponentInfo(handle_, CExports::CVDGNDCCMPI_SourceId, componentIdx_, id);
    }
 
    inline void GenDcComponent::SetRegionId(std::uint16_t id)
    {
      return Detail::SetComponentInfo(handle_, CExports::CVDGNDCCMPI_RegionId, componentIdx_, id);
    }
 
    inline void GenDcComponent::SetRegionOffsetX(std::uint32_t offset)
    {
      return Detail::SetComponentInfo(handle_, CExports::CVDGNDCCMPI_RegionOffsetX, componentIdx_, offset);
    }
 
    inline void GenDcComponent::SetRegionOffsetY(std::uint32_t offset)
    {
      return Detail::SetComponentInfo(handle_, CExports::CVDGNDCCMPI_RegionOffsetY, componentIdx_, offset);
    }
 
    inline void GenDcComponent::SetTimestamp(std::uint64_t timestamp)
    {
      return Detail::SetComponentInfo(handle_, CExports::CVDGNDCCMPI_Timestamp, componentIdx_, timestamp);
    }
 
    inline GenDcDescriptor::GenDcDescriptor(HandleGuard<GenDcDescriptor> &&guard)
        : handle_(std::move(guard))
        , components_{}
    {
      const auto componentCount = Detail::GetHeaderInfo<std::uint32_t>(Handle(), CExports::CVDGNDCCNTI_ComponentCount);
      for (std::size_t idx = 0; idx < componentCount; ++idx)
        components_.push_back(GenDcComponent{Handle(), idx});
    }
 
    inline std::unique_ptr<GenDcDescriptor> GenDcDescriptor::FromHandle(HandleGuard<GenDcDescriptor> &&guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::unique_ptr<GenDcDescriptor>{new GenDcDescriptor{std::move(guard)}};
    }
 
    inline Version GenDcDescriptor::GetVersion() const
    {
      return {Detail::GetHeaderInfo<std::uint8_t>(Handle(), CExports::CVDGNDCCNTI_VersionMajor),
              Detail::GetHeaderInfo<std::uint8_t>(Handle(), CExports::CVDGNDCCNTI_VersionMinor),
              Detail::GetHeaderInfo<std::uint8_t>(Handle(), CExports::CVDGNDCCNTI_VersionSubMinor)};
    }
 
    inline GenDcDescriptorFlag GenDcDescriptor::GetFlags() const
    {
      return Detail::GetHeaderInfo<GenDcDescriptorFlag>(Handle(), CExports::CVDGNDCCNTI_FlagsValue);
    }
 
    inline std::uint32_t GenDcDescriptor::GetHeaderSize() const
    {
      return Detail::GetHeaderInfo<std::uint32_t>(Handle(), CExports::CVDGNDCCNTI_HeaderSize);
    }
 
    inline std::uint64_t GenDcDescriptor::GetContainerId() const
    {
      return Detail::GetHeaderInfo<std::uint64_t>(Handle(), CExports::CVDGNDCCNTI_ContainerId);
    }
 
    inline GenDcDescriptorVariableField GenDcDescriptor::GetVariableFields() const
    {
      return Detail::GetHeaderInfo<GenDcDescriptorVariableField>(Handle(), CExports::CVDGNDCCNTI_VariableFields);
    }
 
    inline std::uint64_t GenDcDescriptor::GetDataSize() const
    {
      return Detail::GetHeaderInfo<std::uint64_t>(Handle(), CExports::CVDGNDCCNTI_DataSize);
    }
 
    inline std::int64_t GenDcDescriptor::GetDataOffset() const
    {
      return Detail::GetHeaderInfo<std::int64_t>(Handle(), CExports::CVDGNDCCNTI_DataOffset);
    }
 
    inline std::uint32_t GenDcDescriptor::GetDescriptorSize() const
    {
      return Detail::GetHeaderInfo<std::uint32_t>(Handle(), CExports::CVDGNDCCNTI_DescriptorSize);
    }
 
    inline const std::vector<GenDcComponent> &GenDcDescriptor::GetComponents() const
    {
      return components_;
    }
 
    inline std::vector<GenDcComponent> &GenDcDescriptor::GetComponents()
    {
      return components_;
    }
 
    inline size_t GenDcDescriptor::CalculateFlowCount() const
    {
      size_t maxFlowIdx = 0;
      for (const auto &component : GetComponents())
      {
        for (const auto &part : component.GetParts())
        {
          auto flowIdx = visit([](const GenDcPart &part) -> size_t { return part.GetFlowId(); }, part);
 
          maxFlowIdx = std::max(maxFlowIdx, flowIdx);
        }
      }
      return maxFlowIdx+1;
    }
 
    inline void GenDcDescriptor::SetFlags(GenDcDescriptorFlag flags)
    {
      Detail::SetHeaderInfo(Handle(), CExports::CVDGNDCCNTI_FlagsValue, flags);
    }
 
    inline void GenDcDescriptor::SetContainerId(std::uint64_t id)
    {
      Detail::SetHeaderInfo(Handle(), CExports::CVDGNDCCNTI_ContainerId, id);
    }
 
    inline void GenDcDescriptor::SetVariableFields(GenDcDescriptorVariableField fields)
    {
      Detail::SetHeaderInfo(Handle(), CExports::CVDGNDCCNTI_VariableFields, fields);
    }
 
    inline void GenDcDescriptor::SetDataSize(std::uint32_t size)
    {
      Detail::SetHeaderInfo(Handle(), CExports::CVDGNDCCNTI_DataSize, size);
    }
 
    inline void *GenDcDescriptor::Handle() const noexcept
    {
      return handle_.Handle();
    }
 
    inline std::size_t GenDcDescriptor::GetSerializedSize() const
    {
      return Internal::DoResCallValueOut<std::size_t>(
          [&](std::size_t &value) { return CVB_CALL_CAPI(CVDGNDCSerialize(Handle(), value, nullptr)); });
    }
 
    inline void GenDcDescriptor::Serialize(std::uint8_t *buffer, std::size_t size) const
    {
      return Internal::DoResCall([&]() { return CVB_CALL_CAPI(CVDGNDCSerialize(Handle(), size, buffer)); });
    }
 
    inline std::vector<std::uint8_t> GenDcDescriptor::Serialize() const
    {
      const std::size_t serializedSize = GetSerializedSize();
      std::vector<std::uint8_t> buffer(serializedSize);
      Serialize(buffer.data(), buffer.size());
      return buffer;
    }
 
    inline std::unique_ptr<GenDcDescriptor> GenDcDescriptor::Create(const GenDcDescriptorConfig &descriptorConfig)
    {
      if (descriptorConfig.Components.size() > std::numeric_limits<CExports::cvbuint32_t>::max())
        throw std::invalid_argument("Descriptor has more components than allowed in a GenDC container");
 
      const auto partCount =
          std::accumulate(descriptorConfig.Components.begin(), descriptorConfig.Components.end(), size_t{0},
                          [](size_t count, const auto &component) { return count + component.Parts.size(); });
      std::vector<CExports::CVDGenDCPartConfig> parts{};
      parts.reserve(partCount);
      std::vector<CExports::CVDGenDCComponentConfig> components{};
      for (const auto &component : descriptorConfig.Components)
      {
        if (component.Parts.size() > std::numeric_limits<CExports::cvbuint16_t>::max())
          throw std::invalid_argument("Component has more parts than allowed in a GenDC container");
 
        size_t startOffset = parts.size();
        for (const auto &part : component.Parts)
        {
          parts.push_back(CExports::CVDGenDCPartConfig{
              static_cast<CExports::cvbuint16_t>(part.PartType),
              static_cast<CExports::cvbuint32_t>(part.Format),
              part.FlowId,
              part.FlowOffset,
              part.DataSize,
          });
        }
        components.push_back(CExports::CVDGenDCComponentConfig{
            static_cast<CExports::cvbuint32_t>(component.TypeId), static_cast<CExports::cvbuint32_t>(component.Format),
            static_cast<CExports::cvbuint16_t>(component.Parts.size()), parts.data() + startOffset});
      }
 
      CExports::CVDGenDCDescriptorConfig config{static_cast<CExports::cvbuint32_t>(components.size()),
                                                components.data()};
 
      return Internal::DoResCallObjectOut<GenDcDescriptor>(
          [&](void *&handle) { return CVB_CALL_CAPI(CVDGNDCCreateDescriptor(config, handle)); });
    }
 
  }  // namespace Driver
 
 
  inline std::unique_ptr<Driver::GenDcDescriptor> Composite::GenDCFinalDescriptor() const
  {
    if (!CExports::CVDCanGenDCDescriptorProvider(Handle()))
      throw std::runtime_error("Composite does not represent a GenDC container");
 
    return Internal::DoResCallObjectOut<Driver::GenDcDescriptor>(
        [this](CExports::CVDGNDCDESCRIPTOR &handle) { return CVB_CALL_CAPI(CVDGNDCPGetDescriptor(Handle(), handle)); });
  }
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb