using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
};
+ struct VideoProfileInfoKHR
+ {
+ using NativeType = VkVideoProfileInfoKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileInfoKHR;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR(
+ VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone,
+ VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ = {},
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ = {},
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , videoCodecOperation( videoCodecOperation_ )
+ , chromaSubsampling( chromaSubsampling_ )
+ , lumaBitDepth( lumaBitDepth_ )
+ , chromaBitDepth( chromaBitDepth_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoProfileInfoKHR( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoProfileInfoKHR( *reinterpret_cast<VideoProfileInfoKHR const *>( &rhs ) )
+ {
+ }
+
+ VideoProfileInfoKHR & operator=( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoProfileInfoKHR & operator=( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const *>( &rhs );
+ return *this;
+ }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR &
+ setVideoCodecOperation( VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) VULKAN_HPP_NOEXCEPT
+ {
+ videoCodecOperation = videoCodecOperation_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR &
+ setChromaSubsampling( VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) VULKAN_HPP_NOEXCEPT
+ {
+ chromaSubsampling = chromaSubsampling_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setLumaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) VULKAN_HPP_NOEXCEPT
+ {
+ lumaBitDepth = lumaBitDepth_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) VULKAN_HPP_NOEXCEPT
+ {
+ chromaBitDepth = chromaBitDepth_;
+ return *this;
+ }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoProfileInfoKHR *>( this );
+ }
+
+ operator VkVideoProfileInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoProfileInfoKHR *>( this );
+ }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth );
+ }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoProfileInfoKHR const & ) const = default;
+#else
+ bool operator==( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) &&
+ ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && ( chromaBitDepth == rhs.chromaBitDepth );
+# endif
+ }
+
+ bool operator!=( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+#endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoProfileInfoKHR;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone;
+ VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling = {};
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth = {};
+ VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoProfileInfoKHR>
+ {
+ using Type = VideoProfileInfoKHR;
+ };
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR
+ {
+ using NativeType = VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile_ = {},
+ uint32_t qualityLevel_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , pVideoProfile( pVideoProfile_ )
+ , qualityLevel( qualityLevel_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ PhysicalDeviceVideoEncodeQualityLevelInfoKHR( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ : PhysicalDeviceVideoEncodeQualityLevelInfoKHR( *reinterpret_cast<PhysicalDeviceVideoEncodeQualityLevelInfoKHR const *>( &rhs ) )
+ {
+ }
+
+ PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR &
+ setPVideoProfile( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pVideoProfile = pVideoProfile_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) VULKAN_HPP_NOEXCEPT
+ {
+ qualityLevel = qualityLevel_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( this );
+ }
+
+ operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, pVideoProfile, qualityLevel );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & ) const = default;
+# else
+ bool operator==( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVideoProfile == rhs.pVideoProfile ) && ( qualityLevel == rhs.qualityLevel );
+# endif
+ }
+
+ bool operator!=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR;
+ const void * pNext = {};
+ const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile = {};
+ uint32_t qualityLevel = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR>
+ {
+ using Type = PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
struct PhysicalDeviceVideoFormatInfoKHR
{
using NativeType = VkPhysicalDeviceVideoFormatInfoKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeCapabilitiesKHR;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes_ = {},
- uint32_t maxRateControlLayers_ = {},
- uint32_t maxQualityLevels_ = {},
- VULKAN_HPP_NAMESPACE::Extent2D inputImageDataFillAlignment_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags_ = {},
+ VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes_ = {},
+ uint32_t maxRateControlLayers_ = {},
+ uint64_t maxBitrate_ = {},
+ uint32_t maxQualityLevels_ = {},
+ VULKAN_HPP_NAMESPACE::Extent2D encodeInputPictureGranularity_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, flags( flags_ )
, rateControlModes( rateControlModes_ )
, maxRateControlLayers( maxRateControlLayers_ )
+ , maxBitrate( maxBitrate_ )
, maxQualityLevels( maxQualityLevels_ )
- , inputImageDataFillAlignment( inputImageDataFillAlignment_ )
+ , encodeInputPictureGranularity( encodeInputPictureGranularity_ )
, supportedEncodeFeedbackFlags( supportedEncodeFeedbackFlags_ )
{
}
VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR const &,
VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR const &,
uint32_t const &,
+ uint64_t const &,
uint32_t const &,
VULKAN_HPP_NAMESPACE::Extent2D const &,
VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie(
- sType, pNext, flags, rateControlModes, maxRateControlLayers, maxQualityLevels, inputImageDataFillAlignment, supportedEncodeFeedbackFlags );
+ return std::tie( sType,
+ pNext,
+ flags,
+ rateControlModes,
+ maxRateControlLayers,
+ maxBitrate,
+ maxQualityLevels,
+ encodeInputPictureGranularity,
+ supportedEncodeFeedbackFlags );
}
# endif
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlModes == rhs.rateControlModes ) &&
- ( maxRateControlLayers == rhs.maxRateControlLayers ) && ( maxQualityLevels == rhs.maxQualityLevels ) &&
- ( inputImageDataFillAlignment == rhs.inputImageDataFillAlignment ) && ( supportedEncodeFeedbackFlags == rhs.supportedEncodeFeedbackFlags );
+ ( maxRateControlLayers == rhs.maxRateControlLayers ) && ( maxBitrate == rhs.maxBitrate ) && ( maxQualityLevels == rhs.maxQualityLevels ) &&
+ ( encodeInputPictureGranularity == rhs.encodeInputPictureGranularity ) && ( supportedEncodeFeedbackFlags == rhs.supportedEncodeFeedbackFlags );
# endif
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeCapabilitiesKHR;
- void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes = {};
- uint32_t maxRateControlLayers = {};
- uint32_t maxQualityLevels = {};
- VULKAN_HPP_NAMESPACE::Extent2D inputImageDataFillAlignment = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeCapabilitiesKHR;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes = {};
+ uint32_t maxRateControlLayers = {};
+ uint64_t maxBitrate = {};
+ uint32_t maxQualityLevels = {};
+ VULKAN_HPP_NAMESPACE::Extent2D encodeInputPictureGranularity = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags = {};
};
template <>
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264CapabilitiesEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {},
- uint32_t maxPPictureL0ReferenceCount_ = {},
- uint32_t maxBPictureL0ReferenceCount_ = {},
- uint32_t maxL1ReferenceCount_ = {},
- VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag_ = {},
- uint32_t maxBytesPerPicDenom_ = {},
- uint32_t maxBitsPerMbDenom_ = {},
- uint32_t log2MaxMvLengthHorizontal_ = {},
- uint32_t log2MaxMvLengthVertical_ = {},
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {},
+ StdVideoH264LevelIdc maxLevelIdc_ = {},
+ uint32_t maxSliceCount_ = {},
+ uint32_t maxPPictureL0ReferenceCount_ = {},
+ uint32_t maxBPictureL0ReferenceCount_ = {},
+ uint32_t maxL1ReferenceCount_ = {},
+ uint32_t maxTemporalLayerCount_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalLayerPattern_ = {},
+ int32_t minQp_ = {},
+ int32_t maxQp_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT stdSyntaxFlags_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, flags( flags_ )
+ , maxLevelIdc( maxLevelIdc_ )
+ , maxSliceCount( maxSliceCount_ )
, maxPPictureL0ReferenceCount( maxPPictureL0ReferenceCount_ )
, maxBPictureL0ReferenceCount( maxBPictureL0ReferenceCount_ )
, maxL1ReferenceCount( maxL1ReferenceCount_ )
- , motionVectorsOverPicBoundariesFlag( motionVectorsOverPicBoundariesFlag_ )
- , maxBytesPerPicDenom( maxBytesPerPicDenom_ )
- , maxBitsPerMbDenom( maxBitsPerMbDenom_ )
- , log2MaxMvLengthHorizontal( log2MaxMvLengthHorizontal_ )
- , log2MaxMvLengthVertical( log2MaxMvLengthVertical_ )
+ , maxTemporalLayerCount( maxTemporalLayerCount_ )
+ , expectDyadicTemporalLayerPattern( expectDyadicTemporalLayerPattern_ )
+ , minQp( minQp_ )
+ , maxQp( maxQp_ )
+ , prefersGopRemainingFrames( prefersGopRemainingFrames_ )
+ , requiresGopRemainingFrames( requiresGopRemainingFrames_ )
+ , stdSyntaxFlags( stdSyntaxFlags_ )
{
}
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT const &,
+ StdVideoH264LevelIdc const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
- VULKAN_HPP_NAMESPACE::Bool32 const &,
- uint32_t const &,
uint32_t const &,
uint32_t const &,
- uint32_t const &>
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ int32_t const &,
+ int32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType,
pNext,
flags,
+ maxLevelIdc,
+ maxSliceCount,
maxPPictureL0ReferenceCount,
maxBPictureL0ReferenceCount,
maxL1ReferenceCount,
- motionVectorsOverPicBoundariesFlag,
- maxBytesPerPicDenom,
- maxBitsPerMbDenom,
- log2MaxMvLengthHorizontal,
- log2MaxMvLengthVertical );
+ maxTemporalLayerCount,
+ expectDyadicTemporalLayerPattern,
+ minQp,
+ maxQp,
+ prefersGopRemainingFrames,
+ requiresGopRemainingFrames,
+ stdSyntaxFlags );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default;
-# else
- bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ std::strong_ordering operator<=>( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
-# if defined( VULKAN_HPP_USE_REFLECT )
- return this->reflect() == rhs.reflect();
-# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) &&
- ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) &&
- ( motionVectorsOverPicBoundariesFlag == rhs.motionVectorsOverPicBoundariesFlag ) && ( maxBytesPerPicDenom == rhs.maxBytesPerPicDenom ) &&
- ( maxBitsPerMbDenom == rhs.maxBitsPerMbDenom ) && ( log2MaxMvLengthHorizontal == rhs.log2MaxMvLengthHorizontal ) &&
- ( log2MaxMvLengthVertical == rhs.log2MaxMvLengthVertical );
-# endif
+ if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
+ return cmp;
+ if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
+ return cmp;
+ if ( auto cmp = flags <=> rhs.flags; cmp != 0 )
+ return cmp;
+ if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 )
+ return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+ if ( auto cmp = maxSliceCount <=> rhs.maxSliceCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxTemporalLayerCount <=> rhs.maxTemporalLayerCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = expectDyadicTemporalLayerPattern <=> rhs.expectDyadicTemporalLayerPattern; cmp != 0 )
+ return cmp;
+ if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 )
+ return cmp;
+ if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 )
+ return cmp;
+ if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 )
+ return cmp;
+ if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 )
+ return cmp;
+
+ return std::strong_ordering::equivalent;
}
+# endif
- bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+ ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ) && ( maxSliceCount == rhs.maxSliceCount ) &&
+ ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) &&
+ ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxTemporalLayerCount == rhs.maxTemporalLayerCount ) &&
+ ( expectDyadicTemporalLayerPattern == rhs.expectDyadicTemporalLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) &&
+ ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) &&
+ ( stdSyntaxFlags == rhs.stdSyntaxFlags );
+ }
+
+ bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
-# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT;
- void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {};
- uint32_t maxPPictureL0ReferenceCount = {};
- uint32_t maxBPictureL0ReferenceCount = {};
- uint32_t maxL1ReferenceCount = {};
- VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag = {};
- uint32_t maxBytesPerPicDenom = {};
- uint32_t maxBitsPerMbDenom = {};
- uint32_t log2MaxMvLengthHorizontal = {};
- uint32_t log2MaxMvLengthVertical = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {};
+ StdVideoH264LevelIdc maxLevelIdc = {};
+ uint32_t maxSliceCount = {};
+ uint32_t maxPPictureL0ReferenceCount = {};
+ uint32_t maxBPictureL0ReferenceCount = {};
+ uint32_t maxL1ReferenceCount = {};
+ uint32_t maxTemporalLayerCount = {};
+ VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalLayerPattern = {};
+ int32_t minQp = {};
+ int32_t maxQp = {};
+ VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames = {};
+ VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT stdSyntaxFlags = {};
};
template <>
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH264GopRemainingFrameInfoEXT
+ {
+ using NativeType = VkVideoEncodeH264GopRemainingFrameInfoEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ = {},
+ uint32_t gopRemainingI_ = {},
+ uint32_t gopRemainingP_ = {},
+ uint32_t gopRemainingB_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , useGopRemainingFrames( useGopRemainingFrames_ )
+ , gopRemainingI( gopRemainingI_ )
+ , gopRemainingP( gopRemainingP_ )
+ , gopRemainingB( gopRemainingB_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoEXT( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH264GopRemainingFrameInfoEXT( VkVideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH264GopRemainingFrameInfoEXT( *reinterpret_cast<VideoEncodeH264GopRemainingFrameInfoEXT const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeH264GopRemainingFrameInfoEXT & operator=( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH264GopRemainingFrameInfoEXT & operator=( VkVideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT &
+ setUseGopRemainingFrames( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ ) VULKAN_HPP_NOEXCEPT
+ {
+ useGopRemainingFrames = useGopRemainingFrames_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setGopRemainingI( uint32_t gopRemainingI_ ) VULKAN_HPP_NOEXCEPT
+ {
+ gopRemainingI = gopRemainingI_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setGopRemainingP( uint32_t gopRemainingP_ ) VULKAN_HPP_NOEXCEPT
+ {
+ gopRemainingP = gopRemainingP_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setGopRemainingB( uint32_t gopRemainingB_ ) VULKAN_HPP_NOEXCEPT
+ {
+ gopRemainingB = gopRemainingB_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeH264GopRemainingFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoEXT *>( this );
+ }
+
+ operator VkVideoEncodeH264GopRemainingFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeH264GopRemainingFrameInfoEXT *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH264GopRemainingFrameInfoEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) &&
+ ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB );
+# endif
+ }
+
+ bool operator!=( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames = {};
+ uint32_t gopRemainingI = {};
+ uint32_t gopRemainingP = {};
+ uint32_t gopRemainingB = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT>
+ {
+ using Type = VideoEncodeH264GopRemainingFrameInfoEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoEncodeH264NaluSliceInfoEXT
{
using NativeType = VkVideoEncodeH264NaluSliceInfoEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264NaluSliceInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoEXT( uint32_t mbCount_ = {},
- const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ = {},
- const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoEXT( int32_t constantQp_ = {},
+ const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , mbCount( mbCount_ )
- , pStdReferenceFinalLists( pStdReferenceFinalLists_ )
+ , constantQp( constantQp_ )
, pStdSliceHeader( pStdSliceHeader_ )
{
}
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoEXT & setMbCount( uint32_t mbCount_ ) VULKAN_HPP_NOEXCEPT
- {
- mbCount = mbCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoEXT &
- setPStdReferenceFinalLists( const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoEXT & setConstantQp( int32_t constantQp_ ) VULKAN_HPP_NOEXCEPT
{
- pStdReferenceFinalLists = pStdReferenceFinalLists_;
+ constantQp = constantQp_;
return *this;
}
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
- uint32_t const &,
- const StdVideoEncodeH264ReferenceListsInfo * const &,
- const StdVideoEncodeH264SliceHeader * const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, int32_t const &, const StdVideoEncodeH264SliceHeader * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, mbCount, pStdReferenceFinalLists, pStdSliceHeader );
+ return std::tie( sType, pNext, constantQp, pStdSliceHeader );
}
# endif
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mbCount == rhs.mbCount ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) &&
- ( pStdSliceHeader == rhs.pStdSliceHeader );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceHeader == rhs.pStdSliceHeader );
# endif
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264NaluSliceInfoEXT;
- const void * pNext = {};
- uint32_t mbCount = {};
- const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists = {};
- const StdVideoEncodeH264SliceHeader * pStdSliceHeader = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264NaluSliceInfoEXT;
+ const void * pNext = {};
+ int32_t constantQp = {};
+ const StdVideoEncodeH264SliceHeader * pStdSliceHeader = {};
};
template <>
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH264PictureInfoEXT
+ {
+ using NativeType = VkVideoEncodeH264PictureInfoEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264PictureInfoEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoEXT( uint32_t naluSliceEntryCount_ = {},
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ = {},
+ const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , naluSliceEntryCount( naluSliceEntryCount_ )
+ , pNaluSliceEntries( pNaluSliceEntries_ )
+ , pStdPictureInfo( pStdPictureInfo_ )
+ , generatePrefixNalu( generatePrefixNalu_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoEXT( VideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH264PictureInfoEXT( VkVideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH264PictureInfoEXT( *reinterpret_cast<VideoEncodeH264PictureInfoEXT const *>( &rhs ) )
+ {
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeH264PictureInfoEXT(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT> const & naluSliceEntries_,
+ const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu_ = {},
+ const void * pNext_ = nullptr )
+ : pNext( pNext_ )
+ , naluSliceEntryCount( static_cast<uint32_t>( naluSliceEntries_.size() ) )
+ , pNaluSliceEntries( naluSliceEntries_.data() )
+ , pStdPictureInfo( pStdPictureInfo_ )
+ , generatePrefixNalu( generatePrefixNalu_ )
+ {
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VideoEncodeH264PictureInfoEXT & operator=( VideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH264PictureInfoEXT & operator=( VkVideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ naluSliceEntryCount = naluSliceEntryCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT &
+ setPNaluSliceEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNaluSliceEntries = pNaluSliceEntries_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeH264PictureInfoEXT & setNaluSliceEntries(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT> const & naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT
+ {
+ naluSliceEntryCount = static_cast<uint32_t>( naluSliceEntries_.size() );
+ pNaluSliceEntries = naluSliceEntries_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pStdPictureInfo = pStdPictureInfo_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setGeneratePrefixNalu( VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu_ ) VULKAN_HPP_NOEXCEPT
+ {
+ generatePrefixNalu = generatePrefixNalu_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeH264PictureInfoEXT *>( this );
+ }
+
+ operator VkVideoEncodeH264PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeH264PictureInfoEXT *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * const &,
+ const StdVideoEncodeH264PictureInfo * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, naluSliceEntryCount, pNaluSliceEntries, pStdPictureInfo, generatePrefixNalu );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH264PictureInfoEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceEntryCount == rhs.naluSliceEntryCount ) &&
+ ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( generatePrefixNalu == rhs.generatePrefixNalu );
+# endif
+ }
+
+ bool operator!=( VideoEncodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264PictureInfoEXT;
+ const void * pNext = {};
+ uint32_t naluSliceEntryCount = {};
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries = {};
+ const StdVideoEncodeH264PictureInfo * pStdPictureInfo = {};
+ VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH264PictureInfoEXT>
+ {
+ using Type = VideoEncodeH264PictureInfoEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoEncodeH264ProfileInfoEXT
{
using NativeType = VkVideoEncodeH264ProfileInfoEXT;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH264RateControlInfoEXT
+ struct VideoEncodeH264QualityLevelPropertiesEXT
{
- using NativeType = VkVideoEncodeH264RateControlInfoEXT;
+ using NativeType = VkVideoEncodeH264QualityLevelPropertiesEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264QualityLevelPropertiesEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( uint32_t gopFrameCount_ = {},
- uint32_t idrPeriod_ = {},
- uint32_t consecutiveBFrameCount_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT rateControlStructure_ =
- VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT::eUnknown,
- uint32_t temporalLayerCount_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT preferredRateControlFlags_ = {},
+ uint32_t preferredGopFrameCount_ = {},
+ uint32_t preferredIdrPeriod_ = {},
+ uint32_t preferredConsecutiveBFrameCount_ = {},
+ uint32_t preferredTemporalLayerCount_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT preferredConstantQp_ = {},
+ uint32_t preferredMaxL0ReferenceCount_ = {},
+ uint32_t preferredMaxL1ReferenceCount_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 preferredStdEntropyCodingModeFlag_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , gopFrameCount( gopFrameCount_ )
- , idrPeriod( idrPeriod_ )
- , consecutiveBFrameCount( consecutiveBFrameCount_ )
- , rateControlStructure( rateControlStructure_ )
- , temporalLayerCount( temporalLayerCount_ )
+ , preferredRateControlFlags( preferredRateControlFlags_ )
+ , preferredGopFrameCount( preferredGopFrameCount_ )
+ , preferredIdrPeriod( preferredIdrPeriod_ )
+ , preferredConsecutiveBFrameCount( preferredConsecutiveBFrameCount_ )
+ , preferredTemporalLayerCount( preferredTemporalLayerCount_ )
+ , preferredConstantQp( preferredConstantQp_ )
+ , preferredMaxL0ReferenceCount( preferredMaxL0ReferenceCount_ )
+ , preferredMaxL1ReferenceCount( preferredMaxL1ReferenceCount_ )
+ , preferredStdEntropyCodingModeFlag( preferredStdEntropyCodingModeFlag_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesEXT( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH264RateControlInfoEXT( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH264RateControlInfoEXT( *reinterpret_cast<VideoEncodeH264RateControlInfoEXT const *>( &rhs ) )
+ VideoEncodeH264QualityLevelPropertiesEXT( VkVideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH264QualityLevelPropertiesEXT( *reinterpret_cast<VideoEncodeH264QualityLevelPropertiesEXT const *>( &rhs ) )
{
}
- VideoEncodeH264RateControlInfoEXT & operator=( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH264QualityLevelPropertiesEXT & operator=( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH264RateControlInfoEXT & operator=( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH264QualityLevelPropertiesEXT & operator=( VkVideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT const *>( &rhs );
return *this;
}
-# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH264QualityLevelPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
- pNext = pNext_;
- return *this;
+ return *reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesEXT *>( this );
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH264QualityLevelPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
- gopFrameCount = gopFrameCount_;
- return *this;
+ return *reinterpret_cast<VkVideoEncodeH264QualityLevelPropertiesEXT *>( this );
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
+ uint32_t const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
{
- idrPeriod = idrPeriod_;
- return *this;
+ return std::tie( sType,
+ pNext,
+ preferredRateControlFlags,
+ preferredGopFrameCount,
+ preferredIdrPeriod,
+ preferredConsecutiveBFrameCount,
+ preferredTemporalLayerCount,
+ preferredConstantQp,
+ preferredMaxL0ReferenceCount,
+ preferredMaxL1ReferenceCount,
+ preferredStdEntropyCodingModeFlag );
}
+# endif
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH264QualityLevelPropertiesEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- consecutiveBFrameCount = consecutiveBFrameCount_;
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) &&
+ ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) &&
+ ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredTemporalLayerCount == rhs.preferredTemporalLayerCount ) &&
+ ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) &&
+ ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount ) &&
+ ( preferredStdEntropyCodingModeFlag == rhs.preferredStdEntropyCodingModeFlag );
+# endif
+ }
+
+ bool operator!=( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264QualityLevelPropertiesEXT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT preferredRateControlFlags = {};
+ uint32_t preferredGopFrameCount = {};
+ uint32_t preferredIdrPeriod = {};
+ uint32_t preferredConsecutiveBFrameCount = {};
+ uint32_t preferredTemporalLayerCount = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT preferredConstantQp = {};
+ uint32_t preferredMaxL0ReferenceCount = {};
+ uint32_t preferredMaxL1ReferenceCount = {};
+ VULKAN_HPP_NAMESPACE::Bool32 preferredStdEntropyCodingModeFlag = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH264QualityLevelPropertiesEXT>
+ {
+ using Type = VideoEncodeH264QualityLevelPropertiesEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH264RateControlInfoEXT
+ {
+ using NativeType = VkVideoEncodeH264RateControlInfoEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlInfoEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT flags_ = {},
+ uint32_t gopFrameCount_ = {},
+ uint32_t idrPeriod_ = {},
+ uint32_t consecutiveBFrameCount_ = {},
+ uint32_t temporalLayerCount_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , gopFrameCount( gopFrameCount_ )
+ , idrPeriod( idrPeriod_ )
+ , consecutiveBFrameCount( consecutiveBFrameCount_ )
+ , temporalLayerCount( temporalLayerCount_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH264RateControlInfoEXT( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH264RateControlInfoEXT( *reinterpret_cast<VideoEncodeH264RateControlInfoEXT const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeH264RateControlInfoEXT & operator=( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH264RateControlInfoEXT & operator=( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ gopFrameCount = gopFrameCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT
+ {
+ idrPeriod = idrPeriod_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT &
- setRateControlStructure( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT rateControlStructure_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT
{
- rateControlStructure = rateControlStructure_;
+ consecutiveBFrameCount = consecutiveBFrameCount_;
return *this;
}
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT const &,
uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, temporalLayerCount );
+ return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, temporalLayerCount );
}
# endif
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && ( idrPeriod == rhs.idrPeriod ) &&
- ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( rateControlStructure == rhs.rateControlStructure ) &&
- ( temporalLayerCount == rhs.temporalLayerCount );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) &&
+ ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( temporalLayerCount == rhs.temporalLayerCount );
# endif
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264RateControlInfoEXT;
- const void * pNext = {};
- uint32_t gopFrameCount = {};
- uint32_t idrPeriod = {};
- uint32_t consecutiveBFrameCount = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT rateControlStructure = VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT::eUnknown;
- uint32_t temporalLayerCount = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264RateControlInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT flags = {};
+ uint32_t gopFrameCount = {};
+ uint32_t idrPeriod = {};
+ uint32_t consecutiveBFrameCount = {};
+ uint32_t temporalLayerCount = {};
};
template <>
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlLayerInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoEXT( uint32_t temporalLayerId_ = {},
- VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT initialRcQp_ = {},
- VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {},
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT minQp_ = {},
VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT maxQp_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT maxFrameSize_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , temporalLayerId( temporalLayerId_ )
- , useInitialRcQp( useInitialRcQp_ )
- , initialRcQp( initialRcQp_ )
, useMinQp( useMinQp_ )
, minQp( minQp_ )
, useMaxQp( useMaxQp_ )
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT & setTemporalLayerId( uint32_t temporalLayerId_ ) VULKAN_HPP_NOEXCEPT
- {
- temporalLayerId = temporalLayerId_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT & setUseInitialRcQp( VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ ) VULKAN_HPP_NOEXCEPT
- {
- useInitialRcQp = useInitialRcQp_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT &
- setInitialRcQp( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & initialRcQp_ ) VULKAN_HPP_NOEXCEPT
- {
- initialRcQp = initialRcQp_;
- return *this;
- }
-
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT & setUseMinQp( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ ) VULKAN_HPP_NOEXCEPT
{
useMinQp = useMinQp_;
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
- uint32_t const &,
- VULKAN_HPP_NAMESPACE::Bool32 const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, temporalLayerId, useInitialRcQp, initialRcQp, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize );
+ return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize );
}
# endif
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalLayerId == rhs.temporalLayerId ) && ( useInitialRcQp == rhs.useInitialRcQp ) &&
- ( initialRcQp == rhs.initialRcQp ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize );
# endif
}
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264RateControlLayerInfoEXT;
const void * pNext = {};
- uint32_t temporalLayerId = {};
- VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT initialRcQp = {};
VULKAN_HPP_NAMESPACE::Bool32 useMinQp = {};
VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT minQp = {};
VULKAN_HPP_NAMESPACE::Bool32 useMaxQp = {};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH264SessionCreateInfoEXT
+ {
+ using NativeType = VkVideoEncodeH264SessionCreateInfoEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionCreateInfoEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ = {},
+ StdVideoH264LevelIdc maxLevelIdc_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , useMaxLevelIdc( useMaxLevelIdc_ )
+ , maxLevelIdc( maxLevelIdc_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoEXT( VideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH264SessionCreateInfoEXT( VkVideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH264SessionCreateInfoEXT( *reinterpret_cast<VideoEncodeH264SessionCreateInfoEXT const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeH264SessionCreateInfoEXT & operator=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH264SessionCreateInfoEXT & operator=( VkVideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoEXT & setUseMaxLevelIdc( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ ) VULKAN_HPP_NOEXCEPT
+ {
+ useMaxLevelIdc = useMaxLevelIdc_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoEXT & setMaxLevelIdc( StdVideoH264LevelIdc maxLevelIdc_ ) VULKAN_HPP_NOEXCEPT
+ {
+ maxLevelIdc = maxLevelIdc_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT *>( this );
+ }
+
+ operator VkVideoEncodeH264SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &, StdVideoH264LevelIdc const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ std::strong_ordering operator<=>( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
+ return cmp;
+ if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
+ return cmp;
+ if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 )
+ return cmp;
+ if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 )
+ return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+
+ return std::strong_ordering::equivalent;
+ }
+# endif
+
+ bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) &&
+ ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 );
+ }
+
+ bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264SessionCreateInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc = {};
+ StdVideoH264LevelIdc maxLevelIdc = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH264SessionCreateInfoEXT>
+ {
+ using Type = VideoEncodeH264SessionCreateInfoEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoEncodeH264SessionParametersAddInfoEXT
{
using NativeType = VkVideoEncodeH264SessionParametersAddInfoEXT;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH264VclFrameInfoEXT
+ struct VideoEncodeH264SessionParametersFeedbackInfoEXT
{
- using NativeType = VkVideoEncodeH264VclFrameInfoEXT;
+ using NativeType = VkVideoEncodeH264SessionParametersFeedbackInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264VclFrameInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH264VclFrameInfoEXT( const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ = {},
- uint32_t naluSliceEntryCount_ = {},
- const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ = {},
- const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersFeedbackInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , pStdReferenceFinalLists( pStdReferenceFinalLists_ )
- , naluSliceEntryCount( naluSliceEntryCount_ )
- , pNaluSliceEntries( pNaluSliceEntries_ )
- , pStdPictureInfo( pStdPictureInfo_ )
+ , hasStdSPSOverrides( hasStdSPSOverrides_ )
+ , hasStdPPSOverrides( hasStdPPSOverrides_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH264VclFrameInfoEXT( VideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VideoEncodeH264VclFrameInfoEXT( VkVideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH264VclFrameInfoEXT( *reinterpret_cast<VideoEncodeH264VclFrameInfoEXT const *>( &rhs ) )
- {
- }
+ VULKAN_HPP_CONSTEXPR
+ VideoEncodeH264SessionParametersFeedbackInfoEXT( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH264VclFrameInfoEXT(
- const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_,
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT> const & naluSliceEntries_,
- const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {},
- const void * pNext_ = nullptr )
- : pNext( pNext_ )
- , pStdReferenceFinalLists( pStdReferenceFinalLists_ )
- , naluSliceEntryCount( static_cast<uint32_t>( naluSliceEntries_.size() ) )
- , pNaluSliceEntries( naluSliceEntries_.data() )
- , pStdPictureInfo( pStdPictureInfo_ )
+ VideoEncodeH264SessionParametersFeedbackInfoEXT( VkVideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH264SessionParametersFeedbackInfoEXT( *reinterpret_cast<VideoEncodeH264SessionParametersFeedbackInfoEXT const *>( &rhs ) )
{
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VideoEncodeH264VclFrameInfoEXT & operator=( VideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH264SessionParametersFeedbackInfoEXT & operator=( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH264VclFrameInfoEXT & operator=( VkVideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const *>( &rhs );
- return *this;
- }
-
-# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
- {
- pNext = pNext_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT &
- setPStdReferenceFinalLists( const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT
- {
- pStdReferenceFinalLists = pStdReferenceFinalLists_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) VULKAN_HPP_NOEXCEPT
- {
- naluSliceEntryCount = naluSliceEntryCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT &
- setPNaluSliceEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ ) VULKAN_HPP_NOEXCEPT
- {
- pNaluSliceEntries = pNaluSliceEntries_;
- return *this;
- }
-
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH264VclFrameInfoEXT & setNaluSliceEntries(
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT> const & naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT
- {
- naluSliceEntryCount = static_cast<uint32_t>( naluSliceEntries_.size() );
- pNaluSliceEntries = naluSliceEntries_.data();
- return *this;
- }
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH264SessionParametersFeedbackInfoEXT & operator=( VkVideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- pStdPictureInfo = pStdPictureInfo_;
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT const *>( &rhs );
return *this;
}
-# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH264SessionParametersFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoEXT *>( this );
}
- operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH264SessionParametersFeedbackInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH264SessionParametersFeedbackInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
- const StdVideoEncodeH264ReferenceListsInfo * const &,
- uint32_t const &,
- const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * const &,
- const StdVideoEncodeH264PictureInfo * const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, pStdReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pStdPictureInfo );
+ return std::tie( sType, pNext, hasStdSPSOverrides, hasStdPPSOverrides );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default;
+ auto operator<=>( VideoEncodeH264SessionParametersFeedbackInfoEXT const & ) const = default;
# else
- bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) &&
- ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) &&
+ ( hasStdPPSOverrides == rhs.hasStdPPSOverrides );
# endif
}
- bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264VclFrameInfoEXT;
- const void * pNext = {};
- const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists = {};
- uint32_t naluSliceEntryCount = {};
- const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries = {};
- const StdVideoEncodeH264PictureInfo * pStdPictureInfo = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides = {};
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH264VclFrameInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT>
{
- using Type = VideoEncodeH264VclFrameInfoEXT;
+ using Type = VideoEncodeH264SessionParametersFeedbackInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265CapabilitiesEXT
+ struct VideoEncodeH264SessionParametersGetInfoEXT
{
- using NativeType = VkVideoEncodeH265CapabilitiesEXT;
+ using NativeType = VkVideoEncodeH264SessionParametersGetInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265CapabilitiesEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersGetInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes_ = {},
- uint32_t maxPPictureL0ReferenceCount_ = {},
- uint32_t maxBPictureL0ReferenceCount_ = {},
- uint32_t maxL1ReferenceCount_ = {},
- uint32_t maxSubLayersCount_ = {},
- uint32_t minLog2MinLumaCodingBlockSizeMinus3_ = {},
- uint32_t maxLog2MinLumaCodingBlockSizeMinus3_ = {},
- uint32_t minLog2MinLumaTransformBlockSizeMinus2_ = {},
- uint32_t maxLog2MinLumaTransformBlockSizeMinus2_ = {},
- uint32_t minMaxTransformHierarchyDepthInter_ = {},
- uint32_t maxMaxTransformHierarchyDepthInter_ = {},
- uint32_t minMaxTransformHierarchyDepthIntra_ = {},
- uint32_t maxMaxTransformHierarchyDepthIntra_ = {},
- uint32_t maxDiffCuQpDeltaDepth_ = {},
- uint32_t minMaxNumMergeCand_ = {},
- uint32_t maxMaxNumMergeCand_ = {},
- void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ = {},
+ uint32_t stdSPSId_ = {},
+ uint32_t stdPPSId_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , flags( flags_ )
- , ctbSizes( ctbSizes_ )
- , transformBlockSizes( transformBlockSizes_ )
- , maxPPictureL0ReferenceCount( maxPPictureL0ReferenceCount_ )
- , maxBPictureL0ReferenceCount( maxBPictureL0ReferenceCount_ )
- , maxL1ReferenceCount( maxL1ReferenceCount_ )
- , maxSubLayersCount( maxSubLayersCount_ )
- , minLog2MinLumaCodingBlockSizeMinus3( minLog2MinLumaCodingBlockSizeMinus3_ )
- , maxLog2MinLumaCodingBlockSizeMinus3( maxLog2MinLumaCodingBlockSizeMinus3_ )
- , minLog2MinLumaTransformBlockSizeMinus2( minLog2MinLumaTransformBlockSizeMinus2_ )
- , maxLog2MinLumaTransformBlockSizeMinus2( maxLog2MinLumaTransformBlockSizeMinus2_ )
- , minMaxTransformHierarchyDepthInter( minMaxTransformHierarchyDepthInter_ )
- , maxMaxTransformHierarchyDepthInter( maxMaxTransformHierarchyDepthInter_ )
- , minMaxTransformHierarchyDepthIntra( minMaxTransformHierarchyDepthIntra_ )
- , maxMaxTransformHierarchyDepthIntra( maxMaxTransformHierarchyDepthIntra_ )
- , maxDiffCuQpDeltaDepth( maxDiffCuQpDeltaDepth_ )
- , minMaxNumMergeCand( minMaxNumMergeCand_ )
- , maxMaxNumMergeCand( maxMaxNumMergeCand_ )
+ , writeStdSPS( writeStdSPS_ )
+ , writeStdPPS( writeStdPPS_ )
+ , stdSPSId( stdSPSId_ )
+ , stdPPSId( stdPPSId_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoEXT( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH265CapabilitiesEXT( VkVideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265CapabilitiesEXT( *reinterpret_cast<VideoEncodeH265CapabilitiesEXT const *>( &rhs ) )
+ VideoEncodeH264SessionParametersGetInfoEXT( VkVideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH264SessionParametersGetInfoEXT( *reinterpret_cast<VideoEncodeH264SessionParametersGetInfoEXT const *>( &rhs ) )
{
}
- VideoEncodeH265CapabilitiesEXT & operator=( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH264SessionParametersGetInfoEXT & operator=( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH264SessionParametersGetInfoEXT & operator=( VkVideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setWriteStdSPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ ) VULKAN_HPP_NOEXCEPT
+ {
+ writeStdSPS = writeStdSPS_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setWriteStdPPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ ) VULKAN_HPP_NOEXCEPT
+ {
+ writeStdPPS = writeStdPPS_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setStdSPSId( uint32_t stdSPSId_ ) VULKAN_HPP_NOEXCEPT
+ {
+ stdSPSId = stdSPSId_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setStdPPSId( uint32_t stdPPSId_ ) VULKAN_HPP_NOEXCEPT
+ {
+ stdPPSId = stdPPSId_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeH264SessionParametersGetInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoEXT *>( this );
+ }
+
+ operator VkVideoEncodeH264SessionParametersGetInfoEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeH264SessionParametersGetInfoEXT *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, writeStdSPS, writeStdPPS, stdSPSId, stdPPSId );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH264SessionParametersGetInfoEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdSPS == rhs.writeStdSPS ) && ( writeStdPPS == rhs.writeStdPPS ) &&
+ ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId );
+# endif
+ }
+
+ bool operator!=( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264SessionParametersGetInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS = {};
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS = {};
+ uint32_t stdSPSId = {};
+ uint32_t stdPPSId = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH264SessionParametersGetInfoEXT>
+ {
+ using Type = VideoEncodeH264SessionParametersGetInfoEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH265CapabilitiesEXT
+ {
+ using NativeType = VkVideoEncodeH265CapabilitiesEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265CapabilitiesEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags_ = {},
+ StdVideoH265LevelIdc maxLevelIdc_ = {},
+ uint32_t maxSliceSegmentCount_ = {},
+ VULKAN_HPP_NAMESPACE::Extent2D maxTiles_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes_ = {},
+ uint32_t maxPPictureL0ReferenceCount_ = {},
+ uint32_t maxBPictureL0ReferenceCount_ = {},
+ uint32_t maxL1ReferenceCount_ = {},
+ uint32_t maxSubLayerCount_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalSubLayerPattern_ = {},
+ int32_t minQp_ = {},
+ int32_t maxQp_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT stdSyntaxFlags_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , maxLevelIdc( maxLevelIdc_ )
+ , maxSliceSegmentCount( maxSliceSegmentCount_ )
+ , maxTiles( maxTiles_ )
+ , ctbSizes( ctbSizes_ )
+ , transformBlockSizes( transformBlockSizes_ )
+ , maxPPictureL0ReferenceCount( maxPPictureL0ReferenceCount_ )
+ , maxBPictureL0ReferenceCount( maxBPictureL0ReferenceCount_ )
+ , maxL1ReferenceCount( maxL1ReferenceCount_ )
+ , maxSubLayerCount( maxSubLayerCount_ )
+ , expectDyadicTemporalSubLayerPattern( expectDyadicTemporalSubLayerPattern_ )
+ , minQp( minQp_ )
+ , maxQp( maxQp_ )
+ , prefersGopRemainingFrames( prefersGopRemainingFrames_ )
+ , requiresGopRemainingFrames( requiresGopRemainingFrames_ )
+ , stdSyntaxFlags( stdSyntaxFlags_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH265CapabilitiesEXT( VkVideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265CapabilitiesEXT( *reinterpret_cast<VideoEncodeH265CapabilitiesEXT const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeH265CapabilitiesEXT & operator=( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
VideoEncodeH265CapabilitiesEXT & operator=( VkVideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT const &,
+ StdVideoH265LevelIdc const &,
+ uint32_t const &,
+ VULKAN_HPP_NAMESPACE::Extent2D const &,
VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT const &,
VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &>
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ int32_t const &,
+ int32_t const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType,
pNext,
flags,
+ maxLevelIdc,
+ maxSliceSegmentCount,
+ maxTiles,
ctbSizes,
transformBlockSizes,
maxPPictureL0ReferenceCount,
maxBPictureL0ReferenceCount,
maxL1ReferenceCount,
- maxSubLayersCount,
- minLog2MinLumaCodingBlockSizeMinus3,
- maxLog2MinLumaCodingBlockSizeMinus3,
- minLog2MinLumaTransformBlockSizeMinus2,
- maxLog2MinLumaTransformBlockSizeMinus2,
- minMaxTransformHierarchyDepthInter,
- maxMaxTransformHierarchyDepthInter,
- minMaxTransformHierarchyDepthIntra,
- maxMaxTransformHierarchyDepthIntra,
- maxDiffCuQpDeltaDepth,
- minMaxNumMergeCand,
- maxMaxNumMergeCand );
+ maxSubLayerCount,
+ expectDyadicTemporalSubLayerPattern,
+ minQp,
+ maxQp,
+ prefersGopRemainingFrames,
+ requiresGopRemainingFrames,
+ stdSyntaxFlags );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default;
-# else
+ std::strong_ordering operator<=>( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
+ return cmp;
+ if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
+ return cmp;
+ if ( auto cmp = flags <=> rhs.flags; cmp != 0 )
+ return cmp;
+ if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 )
+ return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+ if ( auto cmp = maxSliceSegmentCount <=> rhs.maxSliceSegmentCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxTiles <=> rhs.maxTiles; cmp != 0 )
+ return cmp;
+ if ( auto cmp = ctbSizes <=> rhs.ctbSizes; cmp != 0 )
+ return cmp;
+ if ( auto cmp = transformBlockSizes <=> rhs.transformBlockSizes; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxSubLayerCount <=> rhs.maxSubLayerCount; cmp != 0 )
+ return cmp;
+ if ( auto cmp = expectDyadicTemporalSubLayerPattern <=> rhs.expectDyadicTemporalSubLayerPattern; cmp != 0 )
+ return cmp;
+ if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 )
+ return cmp;
+ if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 )
+ return cmp;
+ if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 )
+ return cmp;
+ if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 )
+ return cmp;
+ if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 )
+ return cmp;
+
+ return std::strong_ordering::equivalent;
+ }
+# endif
+
bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
-# if defined( VULKAN_HPP_USE_REFLECT )
- return this->reflect() == rhs.reflect();
-# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( ctbSizes == rhs.ctbSizes ) &&
- ( transformBlockSizes == rhs.transformBlockSizes ) && ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) &&
- ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) &&
- ( maxSubLayersCount == rhs.maxSubLayersCount ) && ( minLog2MinLumaCodingBlockSizeMinus3 == rhs.minLog2MinLumaCodingBlockSizeMinus3 ) &&
- ( maxLog2MinLumaCodingBlockSizeMinus3 == rhs.maxLog2MinLumaCodingBlockSizeMinus3 ) &&
- ( minLog2MinLumaTransformBlockSizeMinus2 == rhs.minLog2MinLumaTransformBlockSizeMinus2 ) &&
- ( maxLog2MinLumaTransformBlockSizeMinus2 == rhs.maxLog2MinLumaTransformBlockSizeMinus2 ) &&
- ( minMaxTransformHierarchyDepthInter == rhs.minMaxTransformHierarchyDepthInter ) &&
- ( maxMaxTransformHierarchyDepthInter == rhs.maxMaxTransformHierarchyDepthInter ) &&
- ( minMaxTransformHierarchyDepthIntra == rhs.minMaxTransformHierarchyDepthIntra ) &&
- ( maxMaxTransformHierarchyDepthIntra == rhs.maxMaxTransformHierarchyDepthIntra ) && ( maxDiffCuQpDeltaDepth == rhs.maxDiffCuQpDeltaDepth ) &&
- ( minMaxNumMergeCand == rhs.minMaxNumMergeCand ) && ( maxMaxNumMergeCand == rhs.maxMaxNumMergeCand );
-# endif
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+ ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ) && ( maxSliceSegmentCount == rhs.maxSliceSegmentCount ) &&
+ ( maxTiles == rhs.maxTiles ) && ( ctbSizes == rhs.ctbSizes ) && ( transformBlockSizes == rhs.transformBlockSizes ) &&
+ ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) &&
+ ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxSubLayerCount == rhs.maxSubLayerCount ) &&
+ ( expectDyadicTemporalSubLayerPattern == rhs.expectDyadicTemporalSubLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) &&
+ ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) &&
+ ( stdSyntaxFlags == rhs.stdSyntaxFlags );
}
bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
-# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265CapabilitiesEXT;
- void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes = {};
- uint32_t maxPPictureL0ReferenceCount = {};
- uint32_t maxBPictureL0ReferenceCount = {};
- uint32_t maxL1ReferenceCount = {};
- uint32_t maxSubLayersCount = {};
- uint32_t minLog2MinLumaCodingBlockSizeMinus3 = {};
- uint32_t maxLog2MinLumaCodingBlockSizeMinus3 = {};
- uint32_t minLog2MinLumaTransformBlockSizeMinus2 = {};
- uint32_t maxLog2MinLumaTransformBlockSizeMinus2 = {};
- uint32_t minMaxTransformHierarchyDepthInter = {};
- uint32_t maxMaxTransformHierarchyDepthInter = {};
- uint32_t minMaxTransformHierarchyDepthIntra = {};
- uint32_t maxMaxTransformHierarchyDepthIntra = {};
- uint32_t maxDiffCuQpDeltaDepth = {};
- uint32_t minMaxNumMergeCand = {};
- uint32_t maxMaxNumMergeCand = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265CapabilitiesEXT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags = {};
+ StdVideoH265LevelIdc maxLevelIdc = {};
+ uint32_t maxSliceSegmentCount = {};
+ VULKAN_HPP_NAMESPACE::Extent2D maxTiles = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes = {};
+ uint32_t maxPPictureL0ReferenceCount = {};
+ uint32_t maxBPictureL0ReferenceCount = {};
+ uint32_t maxL1ReferenceCount = {};
+ uint32_t maxSubLayerCount = {};
+ VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalSubLayerPattern = {};
+ int32_t minQp = {};
+ int32_t maxQp = {};
+ VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames = {};
+ VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT stdSyntaxFlags = {};
};
template <>
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265NaluSliceSegmentInfoEXT
+ struct VideoEncodeH265GopRemainingFrameInfoEXT
{
- using NativeType = VkVideoEncodeH265NaluSliceSegmentInfoEXT;
+ using NativeType = VkVideoEncodeH265GopRemainingFrameInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( uint32_t ctbCount_ = {},
- const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ = {},
- const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ = {},
+ uint32_t gopRemainingI_ = {},
+ uint32_t gopRemainingP_ = {},
+ uint32_t gopRemainingB_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , ctbCount( ctbCount_ )
- , pStdReferenceFinalLists( pStdReferenceFinalLists_ )
- , pStdSliceSegmentHeader( pStdSliceSegmentHeader_ )
+ , useGopRemainingFrames( useGopRemainingFrames_ )
+ , gopRemainingI( gopRemainingI_ )
+ , gopRemainingP( gopRemainingP_ )
+ , gopRemainingB( gopRemainingB_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoEXT( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH265NaluSliceSegmentInfoEXT( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265NaluSliceSegmentInfoEXT( *reinterpret_cast<VideoEncodeH265NaluSliceSegmentInfoEXT const *>( &rhs ) )
+ VideoEncodeH265GopRemainingFrameInfoEXT( VkVideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265GopRemainingFrameInfoEXT( *reinterpret_cast<VideoEncodeH265GopRemainingFrameInfoEXT const *>( &rhs ) )
{
}
- VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265GopRemainingFrameInfoEXT & operator=( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265GopRemainingFrameInfoEXT & operator=( VkVideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setCtbCount( uint32_t ctbCount_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT &
+ setUseGopRemainingFrames( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ ) VULKAN_HPP_NOEXCEPT
{
- ctbCount = ctbCount_;
+ useGopRemainingFrames = useGopRemainingFrames_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT &
- setPStdReferenceFinalLists( const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setGopRemainingI( uint32_t gopRemainingI_ ) VULKAN_HPP_NOEXCEPT
{
- pStdReferenceFinalLists = pStdReferenceFinalLists_;
+ gopRemainingI = gopRemainingI_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT &
- setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setGopRemainingP( uint32_t gopRemainingP_ ) VULKAN_HPP_NOEXCEPT
{
- pStdSliceSegmentHeader = pStdSliceSegmentHeader_;
+ gopRemainingP = gopRemainingP_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setGopRemainingB( uint32_t gopRemainingB_ ) VULKAN_HPP_NOEXCEPT
+ {
+ gopRemainingB = gopRemainingB_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265NaluSliceSegmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265GopRemainingFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265NaluSliceSegmentInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoEXT *>( this );
}
- operator VkVideoEncodeH265NaluSliceSegmentInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265GopRemainingFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265NaluSliceSegmentInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265GopRemainingFrameInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
uint32_t const &,
- const StdVideoEncodeH265ReferenceListsInfo * const &,
- const StdVideoEncodeH265SliceSegmentHeader * const &>
+ uint32_t const &,
+ uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, ctbCount, pStdReferenceFinalLists, pStdSliceSegmentHeader );
+ return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265NaluSliceSegmentInfoEXT const & ) const = default;
+ auto operator<=>( VideoEncodeH265GopRemainingFrameInfoEXT const & ) const = default;
# else
- bool operator==( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) &&
- ( pStdSliceSegmentHeader == rhs.pStdSliceSegmentHeader );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) &&
+ ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB );
# endif
}
- bool operator!=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT;
- const void * pNext = {};
- uint32_t ctbCount = {};
- const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists = {};
- const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames = {};
+ uint32_t gopRemainingI = {};
+ uint32_t gopRemainingP = {};
+ uint32_t gopRemainingB = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT>
{
- using Type = VideoEncodeH265NaluSliceSegmentInfoEXT;
+ using Type = VideoEncodeH265GopRemainingFrameInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265ProfileInfoEXT
+ struct VideoEncodeH265NaluSliceSegmentInfoEXT
{
- using NativeType = VkVideoEncodeH265ProfileInfoEXT;
+ using NativeType = VkVideoEncodeH265NaluSliceSegmentInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265ProfileInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( int32_t constantQp_ = {},
+ const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , stdProfileIdc( stdProfileIdc_ )
+ , constantQp( constantQp_ )
+ , pStdSliceSegmentHeader( pStdSliceSegmentHeader_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH265ProfileInfoEXT( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265ProfileInfoEXT( *reinterpret_cast<VideoEncodeH265ProfileInfoEXT const *>( &rhs ) )
+ VideoEncodeH265NaluSliceSegmentInfoEXT( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265NaluSliceSegmentInfoEXT( *reinterpret_cast<VideoEncodeH265NaluSliceSegmentInfoEXT const *>( &rhs ) )
{
}
- VideoEncodeH265ProfileInfoEXT & operator=( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265ProfileInfoEXT & operator=( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setConstantQp( int32_t constantQp_ ) VULKAN_HPP_NOEXCEPT
{
- stdProfileIdc = stdProfileIdc_;
+ constantQp = constantQp_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT &
+ setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pStdSliceSegmentHeader = pStdSliceSegmentHeader_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265ProfileInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265NaluSliceSegmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265ProfileInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265NaluSliceSegmentInfoEXT *>( this );
}
- operator VkVideoEncodeH265ProfileInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265NaluSliceSegmentInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265NaluSliceSegmentInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, int32_t const &, const StdVideoEncodeH265SliceSegmentHeader * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, stdProfileIdc );
+ return std::tie( sType, pNext, constantQp, pStdSliceSegmentHeader );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- std::strong_ordering operator<=>( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ auto operator<=>( VideoEncodeH265NaluSliceSegmentInfoEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
- return cmp;
- if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
- return cmp;
- if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 )
- return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
-
- return std::strong_ordering::equivalent;
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceSegmentHeader == rhs.pStdSliceSegmentHeader );
+# endif
}
-# endif
- bool operator==( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
- }
-
- bool operator!=( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
+# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265ProfileInfoEXT;
- const void * pNext = {};
- StdVideoH265ProfileIdc stdProfileIdc = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT;
+ const void * pNext = {};
+ int32_t constantQp = {};
+ const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH265ProfileInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT>
{
- using Type = VideoEncodeH265ProfileInfoEXT;
+ using Type = VideoEncodeH265NaluSliceSegmentInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265QpEXT
+ struct VideoEncodeH265PictureInfoEXT
{
- using NativeType = VkVideoEncodeH265QpEXT;
+ using NativeType = VkVideoEncodeH265PictureInfoEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265PictureInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT
- : qpI( qpI_ )
- , qpP( qpP_ )
- , qpB( qpB_ )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoEXT( uint32_t naluSliceSegmentEntryCount_ = {},
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ = {},
+ const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , naluSliceSegmentEntryCount( naluSliceSegmentEntryCount_ )
+ , pNaluSliceSegmentEntries( pNaluSliceSegmentEntries_ )
+ , pStdPictureInfo( pStdPictureInfo_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoEXT( VideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH265QpEXT( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265QpEXT( *reinterpret_cast<VideoEncodeH265QpEXT const *>( &rhs ) )
+ VideoEncodeH265PictureInfoEXT( VkVideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265PictureInfoEXT( *reinterpret_cast<VideoEncodeH265PictureInfoEXT const *>( &rhs ) )
{
}
- VideoEncodeH265QpEXT & operator=( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeH265PictureInfoEXT(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT> const & naluSliceSegmentEntries_,
+ const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {},
+ const void * pNext_ = nullptr )
+ : pNext( pNext_ )
+ , naluSliceSegmentEntryCount( static_cast<uint32_t>( naluSliceSegmentEntries_.size() ) )
+ , pNaluSliceSegmentEntries( naluSliceSegmentEntries_.data() )
+ , pStdPictureInfo( pStdPictureInfo_ )
+ {
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VideoEncodeH265PictureInfoEXT & operator=( VideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265QpEXT & operator=( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265PictureInfoEXT & operator=( VkVideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpI( int32_t qpI_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
- qpI = qpI_;
+ pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpP( int32_t qpP_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT & setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) VULKAN_HPP_NOEXCEPT
{
- qpP = qpP_;
+ naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpB( int32_t qpB_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT &
+ setPNaluSliceSegmentEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ ) VULKAN_HPP_NOEXCEPT
{
- qpB = qpB_;
+ pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeH265PictureInfoEXT & setNaluSliceSegmentEntries(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT> const & naluSliceSegmentEntries_ )
+ VULKAN_HPP_NOEXCEPT
+ {
+ naluSliceSegmentEntryCount = static_cast<uint32_t>( naluSliceSegmentEntries_.size() );
+ pNaluSliceSegmentEntries = naluSliceSegmentEntries_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT & setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pStdPictureInfo = pStdPictureInfo_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265QpEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265PictureInfoEXT *>( this );
}
- operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265QpEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265PictureInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<int32_t const &, int32_t const &, int32_t const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * const &,
+ const StdVideoEncodeH265PictureInfo * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( qpI, qpP, qpB );
+ return std::tie( sType, pNext, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pStdPictureInfo );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265QpEXT const & ) const = default;
+ auto operator<=>( VideoEncodeH265PictureInfoEXT const & ) const = default;
# else
- bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) &&
+ ( pNaluSliceSegmentEntries == rhs.pNaluSliceSegmentEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo );
# endif
}
- bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- int32_t qpI = {};
- int32_t qpP = {};
- int32_t qpB = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265PictureInfoEXT;
+ const void * pNext = {};
+ uint32_t naluSliceSegmentEntryCount = {};
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries = {};
+ const StdVideoEncodeH265PictureInfo * pStdPictureInfo = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265PictureInfoEXT>
+ {
+ using Type = VideoEncodeH265PictureInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265RateControlInfoEXT
+ struct VideoEncodeH265ProfileInfoEXT
{
- using NativeType = VkVideoEncodeH265RateControlInfoEXT;
+ using NativeType = VkVideoEncodeH265ProfileInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265ProfileInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( uint32_t gopFrameCount_ = {},
- uint32_t idrPeriod_ = {},
- uint32_t consecutiveBFrameCount_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT rateControlStructure_ =
- VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT::eUnknown,
- uint32_t subLayerCount_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , gopFrameCount( gopFrameCount_ )
- , idrPeriod( idrPeriod_ )
- , consecutiveBFrameCount( consecutiveBFrameCount_ )
- , rateControlStructure( rateControlStructure_ )
- , subLayerCount( subLayerCount_ )
+ , stdProfileIdc( stdProfileIdc_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH265RateControlInfoEXT( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265RateControlInfoEXT( *reinterpret_cast<VideoEncodeH265RateControlInfoEXT const *>( &rhs ) )
+ VideoEncodeH265ProfileInfoEXT( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265ProfileInfoEXT( *reinterpret_cast<VideoEncodeH265ProfileInfoEXT const *>( &rhs ) )
{
}
- VideoEncodeH265RateControlInfoEXT & operator=( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265ProfileInfoEXT & operator=( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265RateControlInfoEXT & operator=( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265ProfileInfoEXT & operator=( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT
- {
- gopFrameCount = gopFrameCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT
- {
- idrPeriod = idrPeriod_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT
- {
- consecutiveBFrameCount = consecutiveBFrameCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT &
- setRateControlStructure( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT rateControlStructure_ ) VULKAN_HPP_NOEXCEPT
- {
- rateControlStructure = rateControlStructure_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setSubLayerCount( uint32_t subLayerCount_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) VULKAN_HPP_NOEXCEPT
{
- subLayerCount = subLayerCount_;
+ stdProfileIdc = stdProfileIdc_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265ProfileInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265ProfileInfoEXT *>( this );
}
- operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265ProfileInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT const &,
- uint32_t const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, subLayerCount );
+ return std::tie( sType, pNext, stdProfileIdc );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default;
-# else
- bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ std::strong_ordering operator<=>( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
-# if defined( VULKAN_HPP_USE_REFLECT )
- return this->reflect() == rhs.reflect();
-# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && ( idrPeriod == rhs.idrPeriod ) &&
- ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( rateControlStructure == rhs.rateControlStructure ) &&
- ( subLayerCount == rhs.subLayerCount );
-# endif
+ if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
+ return cmp;
+ if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
+ return cmp;
+ if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 )
+ return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+
+ return std::strong_ordering::equivalent;
}
+# endif
- bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
+ }
+
+ bool operator!=( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
-# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlInfoEXT;
- const void * pNext = {};
- uint32_t gopFrameCount = {};
- uint32_t idrPeriod = {};
- uint32_t consecutiveBFrameCount = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT rateControlStructure = VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT::eUnknown;
- uint32_t subLayerCount = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265ProfileInfoEXT;
+ const void * pNext = {};
+ StdVideoH265ProfileIdc stdProfileIdc = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH265RateControlInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265ProfileInfoEXT>
{
- using Type = VideoEncodeH265RateControlInfoEXT;
+ using Type = VideoEncodeH265ProfileInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265RateControlLayerInfoEXT
+ struct VideoEncodeH265QpEXT
{
- using NativeType = VkVideoEncodeH265RateControlLayerInfoEXT;
-
- static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT;
+ using NativeType = VkVideoEncodeH265QpEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( uint32_t temporalId_ = {},
- VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT initialRcQp_ = {},
- VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp_ = {},
- VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp_ = {},
- VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
- : pNext( pNext_ )
- , temporalId( temporalId_ )
- , useInitialRcQp( useInitialRcQp_ )
- , initialRcQp( initialRcQp_ )
- , useMinQp( useMinQp_ )
- , minQp( minQp_ )
- , useMaxQp( useMaxQp_ )
- , maxQp( maxQp_ )
- , useMaxFrameSize( useMaxFrameSize_ )
- , maxFrameSize( maxFrameSize_ )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT
+ : qpI( qpI_ )
+ , qpP( qpP_ )
+ , qpB( qpB_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH265RateControlLayerInfoEXT( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265RateControlLayerInfoEXT( *reinterpret_cast<VideoEncodeH265RateControlLayerInfoEXT const *>( &rhs ) )
+ VideoEncodeH265QpEXT( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265QpEXT( *reinterpret_cast<VideoEncodeH265QpEXT const *>( &rhs ) )
{
}
- VideoEncodeH265RateControlLayerInfoEXT & operator=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265QpEXT & operator=( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265RateControlLayerInfoEXT & operator=( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265QpEXT & operator=( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpI( int32_t qpI_ ) VULKAN_HPP_NOEXCEPT
{
- pNext = pNext_;
+ qpI = qpI_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setTemporalId( uint32_t temporalId_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpP( int32_t qpP_ ) VULKAN_HPP_NOEXCEPT
{
- temporalId = temporalId_;
+ qpP = qpP_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseInitialRcQp( VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpB( int32_t qpB_ ) VULKAN_HPP_NOEXCEPT
{
- useInitialRcQp = useInitialRcQp_;
+ qpB = qpB_;
return *this;
}
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT &
- setInitialRcQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & initialRcQp_ ) VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT
{
- initialRcQp = initialRcQp_;
- return *this;
+ return *reinterpret_cast<const VkVideoEncodeH265QpEXT *>( this );
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMinQp( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ ) VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT
{
- useMinQp = useMinQp_;
- return *this;
+ return *reinterpret_cast<VkVideoEncodeH265QpEXT *>( this );
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMinQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & minQp_ ) VULKAN_HPP_NOEXCEPT
- {
- minQp = minQp_;
- return *this;
- }
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<int32_t const &, int32_t const &, int32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( qpI, qpP, qpB );
+ }
+# endif
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxQp( VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ ) VULKAN_HPP_NOEXCEPT
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH265QpEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- useMaxQp = useMaxQp_;
- return *this;
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+# endif
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMaxQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & maxQp_ ) VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
- maxQp = maxQp_;
- return *this;
+ return !operator==( rhs );
}
+# endif
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxFrameSize( VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ ) VULKAN_HPP_NOEXCEPT
+ public:
+ int32_t qpI = {};
+ int32_t qpP = {};
+ int32_t qpB = {};
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH265QualityLevelPropertiesEXT
+ {
+ using NativeType = VkVideoEncodeH265QualityLevelPropertiesEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265QualityLevelPropertiesEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT preferredRateControlFlags_ = {},
+ uint32_t preferredGopFrameCount_ = {},
+ uint32_t preferredIdrPeriod_ = {},
+ uint32_t preferredConsecutiveBFrameCount_ = {},
+ uint32_t preferredSubLayerCount_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT preferredConstantQp_ = {},
+ uint32_t preferredMaxL0ReferenceCount_ = {},
+ uint32_t preferredMaxL1ReferenceCount_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , preferredRateControlFlags( preferredRateControlFlags_ )
+ , preferredGopFrameCount( preferredGopFrameCount_ )
+ , preferredIdrPeriod( preferredIdrPeriod_ )
+ , preferredConsecutiveBFrameCount( preferredConsecutiveBFrameCount_ )
+ , preferredSubLayerCount( preferredSubLayerCount_ )
+ , preferredConstantQp( preferredConstantQp_ )
+ , preferredMaxL0ReferenceCount( preferredMaxL0ReferenceCount_ )
+ , preferredMaxL1ReferenceCount( preferredMaxL1ReferenceCount_ )
{
- useMaxFrameSize = useMaxFrameSize_;
- return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT &
- setMaxFrameSize( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & maxFrameSize_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesEXT( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH265QualityLevelPropertiesEXT( VkVideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265QualityLevelPropertiesEXT( *reinterpret_cast<VideoEncodeH265QualityLevelPropertiesEXT const *>( &rhs ) )
{
- maxFrameSize = maxFrameSize_;
+ }
+
+ VideoEncodeH265QualityLevelPropertiesEXT & operator=( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH265QualityLevelPropertiesEXT & operator=( VkVideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT const *>( &rhs );
return *this;
}
-# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265QualityLevelPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesEXT *>( this );
}
- operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265QualityLevelPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265QualityLevelPropertiesEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
uint32_t const &,
- VULKAN_HPP_NAMESPACE::Bool32 const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
- VULKAN_HPP_NAMESPACE::Bool32 const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
- VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
- VULKAN_HPP_NAMESPACE::Bool32 const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const &>
+ uint32_t const &,
+ uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, temporalId, useInitialRcQp, initialRcQp, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize );
+ return std::tie( sType,
+ pNext,
+ preferredRateControlFlags,
+ preferredGopFrameCount,
+ preferredIdrPeriod,
+ preferredConsecutiveBFrameCount,
+ preferredSubLayerCount,
+ preferredConstantQp,
+ preferredMaxL0ReferenceCount,
+ preferredMaxL1ReferenceCount );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default;
+ auto operator<=>( VideoEncodeH265QualityLevelPropertiesEXT const & ) const = default;
# else
- bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalId == rhs.temporalId ) && ( useInitialRcQp == rhs.useInitialRcQp ) &&
- ( initialRcQp == rhs.initialRcQp ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
- ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) &&
+ ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) &&
+ ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredSubLayerCount == rhs.preferredSubLayerCount ) &&
+ ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) &&
+ ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount );
# endif
}
- bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT;
- const void * pNext = {};
- uint32_t temporalId = {};
- VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT initialRcQp = {};
- VULKAN_HPP_NAMESPACE::Bool32 useMinQp = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp = {};
- VULKAN_HPP_NAMESPACE::Bool32 useMaxQp = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp = {};
- VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265QualityLevelPropertiesEXT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT preferredRateControlFlags = {};
+ uint32_t preferredGopFrameCount = {};
+ uint32_t preferredIdrPeriod = {};
+ uint32_t preferredConsecutiveBFrameCount = {};
+ uint32_t preferredSubLayerCount = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT preferredConstantQp = {};
+ uint32_t preferredMaxL0ReferenceCount = {};
+ uint32_t preferredMaxL1ReferenceCount = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH265RateControlLayerInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265QualityLevelPropertiesEXT>
{
- using Type = VideoEncodeH265RateControlLayerInfoEXT;
+ using Type = VideoEncodeH265QualityLevelPropertiesEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265SessionParametersAddInfoEXT
+ struct VideoEncodeH265RateControlInfoEXT
{
- using NativeType = VkVideoEncodeH265SessionParametersAddInfoEXT;
+ using NativeType = VkVideoEncodeH265RateControlInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( uint32_t stdVPSCount_ = {},
- const StdVideoH265VideoParameterSet * pStdVPSs_ = {},
- uint32_t stdSPSCount_ = {},
- const StdVideoH265SequenceParameterSet * pStdSPSs_ = {},
- uint32_t stdPPSCount_ = {},
- const StdVideoH265PictureParameterSet * pStdPPSs_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT flags_ = {},
+ uint32_t gopFrameCount_ = {},
+ uint32_t idrPeriod_ = {},
+ uint32_t consecutiveBFrameCount_ = {},
+ uint32_t subLayerCount_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , stdVPSCount( stdVPSCount_ )
- , pStdVPSs( pStdVPSs_ )
- , stdSPSCount( stdSPSCount_ )
- , pStdSPSs( pStdSPSs_ )
- , stdPPSCount( stdPPSCount_ )
- , pStdPPSs( pStdPPSs_ )
+ , flags( flags_ )
+ , gopFrameCount( gopFrameCount_ )
+ , idrPeriod( idrPeriod_ )
+ , consecutiveBFrameCount( consecutiveBFrameCount_ )
+ , subLayerCount( subLayerCount_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VideoEncodeH265SessionParametersAddInfoEXT( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265SessionParametersAddInfoEXT( *reinterpret_cast<VideoEncodeH265SessionParametersAddInfoEXT const *>( &rhs ) )
- {
- }
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH265SessionParametersAddInfoEXT( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265VideoParameterSet> const & stdVPSs_,
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265SequenceParameterSet> const & stdSPSs_ = {},
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265PictureParameterSet> const & stdPPSs_ = {},
- const void * pNext_ = nullptr )
- : pNext( pNext_ )
- , stdVPSCount( static_cast<uint32_t>( stdVPSs_.size() ) )
- , pStdVPSs( stdVPSs_.data() )
- , stdSPSCount( static_cast<uint32_t>( stdSPSs_.size() ) )
- , pStdSPSs( stdSPSs_.data() )
- , stdPPSCount( static_cast<uint32_t>( stdPPSs_.size() ) )
- , pStdPPSs( stdPPSs_.data() )
+ VideoEncodeH265RateControlInfoEXT( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265RateControlInfoEXT( *reinterpret_cast<VideoEncodeH265RateControlInfoEXT const *>( &rhs ) )
{
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VideoEncodeH265SessionParametersAddInfoEXT & operator=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265RateControlInfoEXT & operator=( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265SessionParametersAddInfoEXT & operator=( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265RateControlInfoEXT & operator=( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdVPSCount( uint32_t stdVPSCount_ ) VULKAN_HPP_NOEXCEPT
- {
- stdVPSCount = stdVPSCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) VULKAN_HPP_NOEXCEPT
- {
- pStdVPSs = pStdVPSs_;
- return *this;
- }
-
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH265SessionParametersAddInfoEXT &
- setStdVPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265VideoParameterSet> const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT
- {
- stdVPSCount = static_cast<uint32_t>( stdVPSs_.size() );
- pStdVPSs = stdVPSs_.data();
- return *this;
- }
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdSPSCount( uint32_t stdSPSCount_ ) VULKAN_HPP_NOEXCEPT
- {
- stdSPSCount = stdSPSCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
{
- pStdSPSs = pStdSPSs_;
+ flags = flags_;
return *this;
}
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH265SessionParametersAddInfoEXT &
- setStdSPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265SequenceParameterSet> const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT
{
- stdSPSCount = static_cast<uint32_t>( stdSPSs_.size() );
- pStdSPSs = stdSPSs_.data();
+ gopFrameCount = gopFrameCount_;
return *this;
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdPPSCount( uint32_t stdPPSCount_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT
{
- stdPPSCount = stdPPSCount_;
+ idrPeriod = idrPeriod_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT
{
- pStdPPSs = pStdPPSs_;
+ consecutiveBFrameCount = consecutiveBFrameCount_;
return *this;
}
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH265SessionParametersAddInfoEXT &
- setStdPPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265PictureParameterSet> const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setSubLayerCount( uint32_t subLayerCount_ ) VULKAN_HPP_NOEXCEPT
{
- stdPPSCount = static_cast<uint32_t>( stdPPSs_.size() );
- pStdPPSs = stdPPSs_.data();
+ subLayerCount = subLayerCount_;
return *this;
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT *>( this );
}
- operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT const &,
uint32_t const &,
- const StdVideoH265VideoParameterSet * const &,
uint32_t const &,
- const StdVideoH265SequenceParameterSet * const &,
uint32_t const &,
- const StdVideoH265PictureParameterSet * const &>
+ uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs );
+ return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, subLayerCount );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default;
+ auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default;
# else
- bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) &&
- ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) &&
+ ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( subLayerCount == rhs.subLayerCount );
# endif
}
- bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT;
- const void * pNext = {};
- uint32_t stdVPSCount = {};
- const StdVideoH265VideoParameterSet * pStdVPSs = {};
- uint32_t stdSPSCount = {};
- const StdVideoH265SequenceParameterSet * pStdSPSs = {};
- uint32_t stdPPSCount = {};
- const StdVideoH265PictureParameterSet * pStdPPSs = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT flags = {};
+ uint32_t gopFrameCount = {};
+ uint32_t idrPeriod = {};
+ uint32_t consecutiveBFrameCount = {};
+ uint32_t subLayerCount = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH265SessionParametersAddInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265RateControlInfoEXT>
{
- using Type = VideoEncodeH265SessionParametersAddInfoEXT;
+ using Type = VideoEncodeH265RateControlInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265SessionParametersCreateInfoEXT
+ struct VideoEncodeH265RateControlLayerInfoEXT
{
- using NativeType = VkVideoEncodeH265SessionParametersCreateInfoEXT;
+ using NativeType = VkVideoEncodeH265RateControlLayerInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR
- VideoEncodeH265SessionParametersCreateInfoEXT( uint32_t maxStdVPSCount_ = {},
- uint32_t maxStdSPSCount_ = {},
- uint32_t maxStdPPSCount_ = {},
- const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , maxStdVPSCount( maxStdVPSCount_ )
- , maxStdSPSCount( maxStdSPSCount_ )
- , maxStdPPSCount( maxStdPPSCount_ )
- , pParametersAddInfo( pParametersAddInfo_ )
+ , useMinQp( useMinQp_ )
+ , minQp( minQp_ )
+ , useMaxQp( useMaxQp_ )
+ , maxQp( maxQp_ )
+ , useMaxFrameSize( useMaxFrameSize_ )
+ , maxFrameSize( maxFrameSize_ )
{
}
- VULKAN_HPP_CONSTEXPR
- VideoEncodeH265SessionParametersCreateInfoEXT( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeH265SessionParametersCreateInfoEXT( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265SessionParametersCreateInfoEXT( *reinterpret_cast<VideoEncodeH265SessionParametersCreateInfoEXT const *>( &rhs ) )
+ VideoEncodeH265RateControlLayerInfoEXT( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265RateControlLayerInfoEXT( *reinterpret_cast<VideoEncodeH265RateControlLayerInfoEXT const *>( &rhs ) )
{
}
- VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265RateControlLayerInfoEXT & operator=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265RateControlLayerInfoEXT & operator=( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMinQp( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ ) VULKAN_HPP_NOEXCEPT
{
- maxStdVPSCount = maxStdVPSCount_;
+ useMinQp = useMinQp_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMinQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & minQp_ ) VULKAN_HPP_NOEXCEPT
{
- maxStdSPSCount = maxStdSPSCount_;
+ minQp = minQp_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxQp( VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ ) VULKAN_HPP_NOEXCEPT
{
- maxStdPPSCount = maxStdPPSCount_;
+ useMaxQp = useMaxQp_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT &
- setPParametersAddInfo( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMaxQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & maxQp_ ) VULKAN_HPP_NOEXCEPT
{
- pParametersAddInfo = pParametersAddInfo_;
+ maxQp = maxQp_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxFrameSize( VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ ) VULKAN_HPP_NOEXCEPT
+ {
+ useMaxFrameSize = useMaxFrameSize_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT &
+ setMaxFrameSize( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & maxFrameSize_ ) VULKAN_HPP_NOEXCEPT
+ {
+ maxFrameSize = maxFrameSize_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
}
- operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * const &>
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo );
+ return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default;
+ auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default;
# else
- bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) &&
- ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
+ ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize );
# endif
}
- bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT;
- const void * pNext = {};
- uint32_t maxStdVPSCount = {};
- uint32_t maxStdSPSCount = {};
- uint32_t maxStdPPSCount = {};
- const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 useMinQp = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp = {};
+ VULKAN_HPP_NAMESPACE::Bool32 useMaxQp = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp = {};
+ VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265RateControlLayerInfoEXT>
{
- using Type = VideoEncodeH265SessionParametersCreateInfoEXT;
+ using Type = VideoEncodeH265RateControlLayerInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeH265VclFrameInfoEXT
+ struct VideoEncodeH265SessionCreateInfoEXT
{
- using NativeType = VkVideoEncodeH265VclFrameInfoEXT;
+ using NativeType = VkVideoEncodeH265SessionCreateInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265VclFrameInfoEXT;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionCreateInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeH265VclFrameInfoEXT( const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ = {},
- uint32_t naluSliceSegmentEntryCount_ = {},
- const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ = {},
- const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ = {},
+ StdVideoH265LevelIdc maxLevelIdc_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , pStdReferenceFinalLists( pStdReferenceFinalLists_ )
- , naluSliceSegmentEntryCount( naluSliceSegmentEntryCount_ )
- , pNaluSliceSegmentEntries( pNaluSliceSegmentEntries_ )
- , pStdPictureInfo( pStdPictureInfo_ )
+ , useMaxLevelIdc( useMaxLevelIdc_ )
+ , maxLevelIdc( maxLevelIdc_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeH265VclFrameInfoEXT( VideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VideoEncodeH265VclFrameInfoEXT( VkVideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeH265VclFrameInfoEXT( *reinterpret_cast<VideoEncodeH265VclFrameInfoEXT const *>( &rhs ) )
- {
- }
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoEXT( VideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH265VclFrameInfoEXT(
- const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_,
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT> const & naluSliceSegmentEntries_,
- const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {},
- const void * pNext_ = nullptr )
- : pNext( pNext_ )
- , pStdReferenceFinalLists( pStdReferenceFinalLists_ )
- , naluSliceSegmentEntryCount( static_cast<uint32_t>( naluSliceSegmentEntries_.size() ) )
- , pNaluSliceSegmentEntries( naluSliceSegmentEntries_.data() )
- , pStdPictureInfo( pStdPictureInfo_ )
+ VideoEncodeH265SessionCreateInfoEXT( VkVideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265SessionCreateInfoEXT( *reinterpret_cast<VideoEncodeH265SessionCreateInfoEXT const *>( &rhs ) )
{
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VideoEncodeH265VclFrameInfoEXT & operator=( VideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265SessionCreateInfoEXT & operator=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeH265VclFrameInfoEXT & operator=( VkVideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265SessionCreateInfoEXT & operator=( VkVideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT &
- setPStdReferenceFinalLists( const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT
- {
- pStdReferenceFinalLists = pStdReferenceFinalLists_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) VULKAN_HPP_NOEXCEPT
- {
- naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT &
- setPNaluSliceSegmentEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ ) VULKAN_HPP_NOEXCEPT
- {
- pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_;
- return *this;
- }
-
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeH265VclFrameInfoEXT & setNaluSliceSegmentEntries(
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT> const & naluSliceSegmentEntries_ )
- VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoEXT & setUseMaxLevelIdc( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ ) VULKAN_HPP_NOEXCEPT
{
- naluSliceSegmentEntryCount = static_cast<uint32_t>( naluSliceSegmentEntries_.size() );
- pNaluSliceSegmentEntries = naluSliceSegmentEntries_.data();
+ useMaxLevelIdc = useMaxLevelIdc_;
return *this;
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoEXT & setMaxLevelIdc( StdVideoH265LevelIdc maxLevelIdc_ ) VULKAN_HPP_NOEXCEPT
{
- pStdPictureInfo = pStdPictureInfo_;
+ maxLevelIdc = maxLevelIdc_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT *>( this );
}
- operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
- const StdVideoEncodeH265ReferenceListsInfo * const &,
- uint32_t const &,
- const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * const &,
- const StdVideoEncodeH265PictureInfo * const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &, StdVideoH265LevelIdc const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, pStdReferenceFinalLists, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pStdPictureInfo );
+ return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default;
-# else
- bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ std::strong_ordering operator<=>( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
-# if defined( VULKAN_HPP_USE_REFLECT )
- return this->reflect() == rhs.reflect();
-# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) &&
- ( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) && ( pNaluSliceSegmentEntries == rhs.pNaluSliceSegmentEntries ) &&
- ( pStdPictureInfo == rhs.pStdPictureInfo );
-# endif
+ if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
+ return cmp;
+ if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
+ return cmp;
+ if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 )
+ return cmp;
+ if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 )
+ return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+
+ return std::strong_ordering::equivalent;
+ }
+# endif
+
+ bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) &&
+ ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 );
}
- bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
-# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265VclFrameInfoEXT;
- const void * pNext = {};
- const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists = {};
- uint32_t naluSliceSegmentEntryCount = {};
- const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries = {};
- const StdVideoEncodeH265PictureInfo * pStdPictureInfo = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionCreateInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc = {};
+ StdVideoH265LevelIdc maxLevelIdc = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeH265VclFrameInfoEXT>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265SessionCreateInfoEXT>
{
- using Type = VideoEncodeH265VclFrameInfoEXT;
+ using Type = VideoEncodeH265SessionCreateInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeInfoKHR
+ struct VideoEncodeH265SessionParametersAddInfoEXT
{
- using NativeType = VkVideoEncodeInfoKHR;
+ using NativeType = VkVideoEncodeH265SessionParametersAddInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeInfoKHR;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ = {},
- uint32_t qualityLevel_ = {},
- VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ = {},
- VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ = {},
- VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ = {},
- VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_ = {},
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {},
- uint32_t referenceSlotCount_ = {},
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ = {},
- uint32_t precedingExternallyEncodedBytes_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( uint32_t stdVPSCount_ = {},
+ const StdVideoH265VideoParameterSet * pStdVPSs_ = {},
+ uint32_t stdSPSCount_ = {},
+ const StdVideoH265SequenceParameterSet * pStdSPSs_ = {},
+ uint32_t stdPPSCount_ = {},
+ const StdVideoH265PictureParameterSet * pStdPPSs_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , flags( flags_ )
- , qualityLevel( qualityLevel_ )
- , dstBuffer( dstBuffer_ )
- , dstBufferOffset( dstBufferOffset_ )
- , dstBufferRange( dstBufferRange_ )
- , srcPictureResource( srcPictureResource_ )
- , pSetupReferenceSlot( pSetupReferenceSlot_ )
- , referenceSlotCount( referenceSlotCount_ )
- , pReferenceSlots( pReferenceSlots_ )
- , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ )
+ , stdVPSCount( stdVPSCount_ )
+ , pStdVPSs( pStdVPSs_ )
+ , stdSPSCount( stdSPSCount_ )
+ , pStdSPSs( pStdSPSs_ )
+ , stdPPSCount( stdPPSCount_ )
+ , pStdPPSs( pStdPPSs_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeInfoKHR( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoEncodeInfoKHR( *reinterpret_cast<VideoEncodeInfoKHR const *>( &rhs ) ) {}
+ VideoEncodeH265SessionParametersAddInfoEXT( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265SessionParametersAddInfoEXT( *reinterpret_cast<VideoEncodeH265SessionParametersAddInfoEXT const *>( &rhs ) )
+ {
+ }
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_,
- uint32_t qualityLevel_,
- VULKAN_HPP_NAMESPACE::Buffer dstBuffer_,
- VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_,
- VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_,
- VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_,
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_,
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> const & referenceSlots_,
- uint32_t precedingExternallyEncodedBytes_ = {},
- const void * pNext_ = nullptr )
+ VideoEncodeH265SessionParametersAddInfoEXT( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265VideoParameterSet> const & stdVPSs_,
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265SequenceParameterSet> const & stdSPSs_ = {},
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265PictureParameterSet> const & stdPPSs_ = {},
+ const void * pNext_ = nullptr )
: pNext( pNext_ )
- , flags( flags_ )
- , qualityLevel( qualityLevel_ )
- , dstBuffer( dstBuffer_ )
- , dstBufferOffset( dstBufferOffset_ )
- , dstBufferRange( dstBufferRange_ )
- , srcPictureResource( srcPictureResource_ )
- , pSetupReferenceSlot( pSetupReferenceSlot_ )
- , referenceSlotCount( static_cast<uint32_t>( referenceSlots_.size() ) )
- , pReferenceSlots( referenceSlots_.data() )
- , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ )
+ , stdVPSCount( static_cast<uint32_t>( stdVPSs_.size() ) )
+ , pStdVPSs( stdVPSs_.data() )
+ , stdSPSCount( static_cast<uint32_t>( stdSPSs_.size() ) )
+ , pStdSPSs( stdSPSs_.data() )
+ , stdPPSCount( static_cast<uint32_t>( stdPPSs_.size() ) )
+ , pStdPPSs( stdPPSs_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VideoEncodeInfoKHR & operator=( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265SessionParametersAddInfoEXT & operator=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeInfoKHR & operator=( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265SessionParametersAddInfoEXT & operator=( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdVPSCount( uint32_t stdVPSCount_ ) VULKAN_HPP_NOEXCEPT
{
- flags = flags_;
+ stdVPSCount = stdVPSCount_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) VULKAN_HPP_NOEXCEPT
{
- qualityLevel = qualityLevel_;
+ pStdVPSs = pStdVPSs_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ ) VULKAN_HPP_NOEXCEPT
- {
- dstBuffer = dstBuffer_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferOffset( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ ) VULKAN_HPP_NOEXCEPT
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeH265SessionParametersAddInfoEXT &
+ setStdVPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265VideoParameterSet> const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT
{
- dstBufferOffset = dstBufferOffset_;
+ stdVPSCount = static_cast<uint32_t>( stdVPSs_.size() );
+ pStdVPSs = stdVPSs_.data();
return *this;
}
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferRange( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdSPSCount( uint32_t stdSPSCount_ ) VULKAN_HPP_NOEXCEPT
{
- dstBufferRange = dstBufferRange_;
+ stdSPSCount = stdSPSCount_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR &
- setSrcPictureResource( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & srcPictureResource_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) VULKAN_HPP_NOEXCEPT
{
- srcPictureResource = srcPictureResource_;
+ pStdSPSs = pStdSPSs_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR &
- setPSetupReferenceSlot( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) VULKAN_HPP_NOEXCEPT
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeH265SessionParametersAddInfoEXT &
+ setStdSPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265SequenceParameterSet> const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT
{
- pSetupReferenceSlot = pSetupReferenceSlot_;
+ stdSPSCount = static_cast<uint32_t>( stdSPSs_.size() );
+ pStdSPSs = stdSPSs_.data();
return *this;
}
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdPPSCount( uint32_t stdPPSCount_ ) VULKAN_HPP_NOEXCEPT
{
- referenceSlotCount = referenceSlotCount_;
+ stdPPSCount = stdPPSCount_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR &
- setPReferenceSlots( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) VULKAN_HPP_NOEXCEPT
{
- pReferenceSlots = pReferenceSlots_;
+ pStdPPSs = pStdPPSs_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeInfoKHR & setReferenceSlots(
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265SessionParametersAddInfoEXT &
+ setStdPPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const StdVideoH265PictureParameterSet> const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT
{
- referenceSlotCount = static_cast<uint32_t>( referenceSlots_.size() );
- pReferenceSlots = referenceSlots_.data();
+ stdPPSCount = static_cast<uint32_t>( stdPPSs_.size() );
+ pStdPPSs = stdPPSs_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) VULKAN_HPP_NOEXCEPT
- {
- precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_;
- return *this;
- }
-# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
- operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeInfoKHR *>( this );
+ return *reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
}
- operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeInfoKHR *>( this );
+ return *reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR const &,
uint32_t const &,
- VULKAN_HPP_NAMESPACE::Buffer const &,
- VULKAN_HPP_NAMESPACE::DeviceSize const &,
- VULKAN_HPP_NAMESPACE::DeviceSize const &,
- VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const &,
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * const &,
+ const StdVideoH265VideoParameterSet * const &,
uint32_t const &,
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * const &,
- uint32_t const &>
+ const StdVideoH265SequenceParameterSet * const &,
+ uint32_t const &,
+ const StdVideoH265PictureParameterSet * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType,
- pNext,
- flags,
- qualityLevel,
- dstBuffer,
- dstBufferOffset,
- dstBufferRange,
- srcPictureResource,
- pSetupReferenceSlot,
- referenceSlotCount,
- pReferenceSlots,
- precedingExternallyEncodedBytes );
+ return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeInfoKHR const & ) const = default;
+ auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default;
# else
- bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( qualityLevel == rhs.qualityLevel ) &&
- ( dstBuffer == rhs.dstBuffer ) && ( dstBufferOffset == rhs.dstBufferOffset ) && ( dstBufferRange == rhs.dstBufferRange ) &&
- ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) &&
- ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) &&
- ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) &&
+ ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs );
# endif
}
- bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeInfoKHR;
- const void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags = {};
- uint32_t qualityLevel = {};
- VULKAN_HPP_NAMESPACE::Buffer dstBuffer = {};
- VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset = {};
- VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange = {};
- VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource = {};
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {};
- uint32_t referenceSlotCount = {};
- const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots = {};
- uint32_t precedingExternallyEncodedBytes = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT;
+ const void * pNext = {};
+ uint32_t stdVPSCount = {};
+ const StdVideoH265VideoParameterSet * pStdVPSs = {};
+ uint32_t stdSPSCount = {};
+ const StdVideoH265SequenceParameterSet * pStdSPSs = {};
+ uint32_t stdPPSCount = {};
+ const StdVideoH265PictureParameterSet * pStdPPSs = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeInfoKHR>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265SessionParametersAddInfoEXT>
{
- using Type = VideoEncodeInfoKHR;
+ using Type = VideoEncodeH265SessionParametersAddInfoEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeRateControlLayerInfoKHR
+ struct VideoEncodeH265SessionParametersCreateInfoEXT
{
- using NativeType = VkVideoEncodeRateControlLayerInfoKHR;
+ using NativeType = VkVideoEncodeH265SessionParametersCreateInfoEXT;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlLayerInfoKHR;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( uint64_t averageBitrate_ = {},
- uint64_t maxBitrate_ = {},
- uint32_t frameRateNumerator_ = {},
- uint32_t frameRateDenominator_ = {},
- uint32_t virtualBufferSizeInMs_ = {},
- uint32_t initialVirtualBufferSizeInMs_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR
+ VideoEncodeH265SessionParametersCreateInfoEXT( uint32_t maxStdVPSCount_ = {},
+ uint32_t maxStdSPSCount_ = {},
+ uint32_t maxStdPPSCount_ = {},
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , averageBitrate( averageBitrate_ )
- , maxBitrate( maxBitrate_ )
- , frameRateNumerator( frameRateNumerator_ )
- , frameRateDenominator( frameRateDenominator_ )
- , virtualBufferSizeInMs( virtualBufferSizeInMs_ )
- , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ )
+ , maxStdVPSCount( maxStdVPSCount_ )
+ , maxStdSPSCount( maxStdSPSCount_ )
+ , maxStdPPSCount( maxStdPPSCount_ )
+ , pParametersAddInfo( pParametersAddInfo_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR
+ VideoEncodeH265SessionParametersCreateInfoEXT( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VideoEncodeRateControlLayerInfoKHR( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeRateControlLayerInfoKHR( *reinterpret_cast<VideoEncodeRateControlLayerInfoKHR const *>( &rhs ) )
+ VideoEncodeH265SessionParametersCreateInfoEXT( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265SessionParametersCreateInfoEXT( *reinterpret_cast<VideoEncodeH265SessionParametersCreateInfoEXT const *>( &rhs ) )
{
}
- VideoEncodeRateControlLayerInfoKHR & operator=( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeRateControlLayerInfoKHR & operator=( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setAverageBitrate( uint64_t averageBitrate_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) VULKAN_HPP_NOEXCEPT
{
- averageBitrate = averageBitrate_;
+ maxStdVPSCount = maxStdVPSCount_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setMaxBitrate( uint64_t maxBitrate_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) VULKAN_HPP_NOEXCEPT
{
- maxBitrate = maxBitrate_;
+ maxStdSPSCount = maxStdSPSCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ maxStdPPSCount = maxStdPPSCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT &
+ setPParametersAddInfo( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pParametersAddInfo = pParametersAddInfo_;
return *this;
}
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
+ }
+
+ operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) &&
+ ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+# endif
+ }
+
+ bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT;
+ const void * pNext = {};
+ uint32_t maxStdVPSCount = {};
+ uint32_t maxStdSPSCount = {};
+ uint32_t maxStdPPSCount = {};
+ const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT>
+ {
+ using Type = VideoEncodeH265SessionParametersCreateInfoEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH265SessionParametersFeedbackInfoEXT
+ {
+ using NativeType = VkVideoEncodeH265SessionParametersFeedbackInfoEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersFeedbackInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 hasStdVPSOverrides_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , hasStdVPSOverrides( hasStdVPSOverrides_ )
+ , hasStdSPSOverrides( hasStdSPSOverrides_ )
+ , hasStdPPSOverrides( hasStdPPSOverrides_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR
+ VideoEncodeH265SessionParametersFeedbackInfoEXT( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH265SessionParametersFeedbackInfoEXT( VkVideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265SessionParametersFeedbackInfoEXT( *reinterpret_cast<VideoEncodeH265SessionParametersFeedbackInfoEXT const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeH265SessionParametersFeedbackInfoEXT & operator=( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH265SessionParametersFeedbackInfoEXT & operator=( VkVideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT const *>( &rhs );
+ return *this;
+ }
+
+ operator VkVideoEncodeH265SessionParametersFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoEXT *>( this );
+ }
+
+ operator VkVideoEncodeH265SessionParametersFeedbackInfoEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeH265SessionParametersFeedbackInfoEXT *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, hasStdVPSOverrides, hasStdSPSOverrides, hasStdPPSOverrides );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH265SessionParametersFeedbackInfoEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdVPSOverrides == rhs.hasStdVPSOverrides ) &&
+ ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) && ( hasStdPPSOverrides == rhs.hasStdPPSOverrides );
+# endif
+ }
+
+ bool operator!=( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdVPSOverrides = {};
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides = {};
+ VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT>
+ {
+ using Type = VideoEncodeH265SessionParametersFeedbackInfoEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeH265SessionParametersGetInfoEXT
+ {
+ using NativeType = VkVideoEncodeH265SessionParametersGetInfoEXT;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersGetInfoEXT;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 writeStdVPS_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ = {},
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ = {},
+ uint32_t stdVPSId_ = {},
+ uint32_t stdSPSId_ = {},
+ uint32_t stdPPSId_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , writeStdVPS( writeStdVPS_ )
+ , writeStdSPS( writeStdSPS_ )
+ , writeStdPPS( writeStdPPS_ )
+ , stdVPSId( stdVPSId_ )
+ , stdSPSId( stdSPSId_ )
+ , stdPPSId( stdPPSId_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoEXT( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeH265SessionParametersGetInfoEXT( VkVideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeH265SessionParametersGetInfoEXT( *reinterpret_cast<VideoEncodeH265SessionParametersGetInfoEXT const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeH265SessionParametersGetInfoEXT & operator=( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeH265SessionParametersGetInfoEXT & operator=( VkVideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setWriteStdVPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdVPS_ ) VULKAN_HPP_NOEXCEPT
+ {
+ writeStdVPS = writeStdVPS_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setWriteStdSPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ ) VULKAN_HPP_NOEXCEPT
+ {
+ writeStdSPS = writeStdSPS_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setWriteStdPPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ ) VULKAN_HPP_NOEXCEPT
+ {
+ writeStdPPS = writeStdPPS_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setStdVPSId( uint32_t stdVPSId_ ) VULKAN_HPP_NOEXCEPT
+ {
+ stdVPSId = stdVPSId_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setStdSPSId( uint32_t stdSPSId_ ) VULKAN_HPP_NOEXCEPT
+ {
+ stdSPSId = stdSPSId_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setStdPPSId( uint32_t stdPPSId_ ) VULKAN_HPP_NOEXCEPT
+ {
+ stdPPSId = stdPPSId_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeH265SessionParametersGetInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoEXT *>( this );
+ }
+
+ operator VkVideoEncodeH265SessionParametersGetInfoEXT &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeH265SessionParametersGetInfoEXT *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ VULKAN_HPP_NAMESPACE::Bool32 const &,
+ uint32_t const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, writeStdVPS, writeStdSPS, writeStdPPS, stdVPSId, stdSPSId, stdPPSId );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeH265SessionParametersGetInfoEXT const & ) const = default;
+# else
+ bool operator==( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdVPS == rhs.writeStdVPS ) && ( writeStdSPS == rhs.writeStdSPS ) &&
+ ( writeStdPPS == rhs.writeStdPPS ) && ( stdVPSId == rhs.stdVPSId ) && ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId );
+# endif
+ }
+
+ bool operator!=( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersGetInfoEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdVPS = {};
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS = {};
+ VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS = {};
+ uint32_t stdVPSId = {};
+ uint32_t stdSPSId = {};
+ uint32_t stdPPSId = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeH265SessionParametersGetInfoEXT>
+ {
+ using Type = VideoEncodeH265SessionParametersGetInfoEXT;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeInfoKHR
+ {
+ using NativeType = VkVideoEncodeInfoKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeInfoKHR;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ = {},
+ VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ = {},
+ VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ = {},
+ VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ = {},
+ VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_ = {},
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {},
+ uint32_t referenceSlotCount_ = {},
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ = {},
+ uint32_t precedingExternallyEncodedBytes_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , dstBuffer( dstBuffer_ )
+ , dstBufferOffset( dstBufferOffset_ )
+ , dstBufferRange( dstBufferRange_ )
+ , srcPictureResource( srcPictureResource_ )
+ , pSetupReferenceSlot( pSetupReferenceSlot_ )
+ , referenceSlotCount( referenceSlotCount_ )
+ , pReferenceSlots( pReferenceSlots_ )
+ , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeInfoKHR( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoEncodeInfoKHR( *reinterpret_cast<VideoEncodeInfoKHR const *>( &rhs ) ) {}
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_,
+ VULKAN_HPP_NAMESPACE::Buffer dstBuffer_,
+ VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_,
+ VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_,
+ VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_,
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> const & referenceSlots_,
+ uint32_t precedingExternallyEncodedBytes_ = {},
+ const void * pNext_ = nullptr )
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , dstBuffer( dstBuffer_ )
+ , dstBufferOffset( dstBufferOffset_ )
+ , dstBufferRange( dstBufferRange_ )
+ , srcPictureResource( srcPictureResource_ )
+ , pSetupReferenceSlot( pSetupReferenceSlot_ )
+ , referenceSlotCount( static_cast<uint32_t>( referenceSlots_.size() ) )
+ , pReferenceSlots( referenceSlots_.data() )
+ , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ )
+ {
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VideoEncodeInfoKHR & operator=( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeInfoKHR & operator=( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ ) VULKAN_HPP_NOEXCEPT
+ {
+ dstBuffer = dstBuffer_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferOffset( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ ) VULKAN_HPP_NOEXCEPT
+ {
+ dstBufferOffset = dstBufferOffset_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferRange( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ ) VULKAN_HPP_NOEXCEPT
+ {
+ dstBufferRange = dstBufferRange_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR &
+ setSrcPictureResource( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & srcPictureResource_ ) VULKAN_HPP_NOEXCEPT
+ {
+ srcPictureResource = srcPictureResource_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR &
+ setPSetupReferenceSlot( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pSetupReferenceSlot = pSetupReferenceSlot_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ referenceSlotCount = referenceSlotCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR &
+ setPReferenceSlots( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pReferenceSlots = pReferenceSlots_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeInfoKHR & setReferenceSlots(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR> const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT
+ {
+ referenceSlotCount = static_cast<uint32_t>( referenceSlots_.size() );
+ pReferenceSlots = referenceSlots_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) VULKAN_HPP_NOEXCEPT
+ {
+ precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeInfoKHR *>( this );
+ }
+
+ operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeInfoKHR *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::Buffer const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::DeviceSize const &,
+ VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const &,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType,
+ pNext,
+ flags,
+ dstBuffer,
+ dstBufferOffset,
+ dstBufferRange,
+ srcPictureResource,
+ pSetupReferenceSlot,
+ referenceSlotCount,
+ pReferenceSlots,
+ precedingExternallyEncodedBytes );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeInfoKHR const & ) const = default;
+# else
+ bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstBuffer == rhs.dstBuffer ) &&
+ ( dstBufferOffset == rhs.dstBufferOffset ) && ( dstBufferRange == rhs.dstBufferRange ) && ( srcPictureResource == rhs.srcPictureResource ) &&
+ ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) &&
+ ( pReferenceSlots == rhs.pReferenceSlots ) && ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes );
+# endif
+ }
+
+ bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeInfoKHR;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags = {};
+ VULKAN_HPP_NAMESPACE::Buffer dstBuffer = {};
+ VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset = {};
+ VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange = {};
+ VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource = {};
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {};
+ uint32_t referenceSlotCount = {};
+ const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots = {};
+ uint32_t precedingExternallyEncodedBytes = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeInfoKHR>
+ {
+ using Type = VideoEncodeInfoKHR;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeQualityLevelInfoKHR
+ {
+ using NativeType = VkVideoEncodeQualityLevelInfoKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelInfoKHR;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( uint32_t qualityLevel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , qualityLevel( qualityLevel_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeQualityLevelInfoKHR( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeQualityLevelInfoKHR( *reinterpret_cast<VideoEncodeQualityLevelInfoKHR const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeQualityLevelInfoKHR & operator=( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeQualityLevelInfoKHR & operator=( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) VULKAN_HPP_NOEXCEPT
+ {
+ qualityLevel = qualityLevel_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR *>( this );
+ }
+
+ operator VkVideoEncodeQualityLevelInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeQualityLevelInfoKHR *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, qualityLevel );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeQualityLevelInfoKHR const & ) const = default;
+# else
+ bool operator==( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( qualityLevel == rhs.qualityLevel );
+# endif
+ }
+
+ bool operator!=( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeQualityLevelInfoKHR;
+ const void * pNext = {};
+ uint32_t qualityLevel = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeQualityLevelInfoKHR>
+ {
+ using Type = VideoEncodeQualityLevelInfoKHR;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeQualityLevelPropertiesKHR
+ {
+ using NativeType = VkVideoEncodeQualityLevelPropertiesKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelPropertiesKHR;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelPropertiesKHR( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode_ =
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault,
+ uint32_t preferredRateControlLayerCount_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , preferredRateControlMode( preferredRateControlMode_ )
+ , preferredRateControlLayerCount( preferredRateControlLayerCount_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelPropertiesKHR( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeQualityLevelPropertiesKHR( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeQualityLevelPropertiesKHR( *reinterpret_cast<VideoEncodeQualityLevelPropertiesKHR const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeQualityLevelPropertiesKHR & operator=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeQualityLevelPropertiesKHR & operator=( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const *>( &rhs );
+ return *this;
+ }
+
+ operator VkVideoEncodeQualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeQualityLevelPropertiesKHR *>( this );
+ }
+
+ operator VkVideoEncodeQualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::
+ tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, preferredRateControlMode, preferredRateControlLayerCount );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeQualityLevelPropertiesKHR const & ) const = default;
+# else
+ bool operator==( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlMode == rhs.preferredRateControlMode ) &&
+ ( preferredRateControlLayerCount == rhs.preferredRateControlLayerCount );
+# endif
+ }
+
+ bool operator!=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeQualityLevelPropertiesKHR;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode =
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault;
+ uint32_t preferredRateControlLayerCount = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeQualityLevelPropertiesKHR>
+ {
+ using Type = VideoEncodeQualityLevelPropertiesKHR;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeRateControlLayerInfoKHR
+ {
+ using NativeType = VkVideoEncodeRateControlLayerInfoKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlLayerInfoKHR;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( uint64_t averageBitrate_ = {},
+ uint64_t maxBitrate_ = {},
+ uint32_t frameRateNumerator_ = {},
+ uint32_t frameRateDenominator_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , averageBitrate( averageBitrate_ )
+ , maxBitrate( maxBitrate_ )
+ , frameRateNumerator( frameRateNumerator_ )
+ , frameRateDenominator( frameRateDenominator_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeRateControlLayerInfoKHR( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeRateControlLayerInfoKHR( *reinterpret_cast<VideoEncodeRateControlLayerInfoKHR const *>( &rhs ) )
+ {
+ }
+
+ VideoEncodeRateControlLayerInfoKHR & operator=( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeRateControlLayerInfoKHR & operator=( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setAverageBitrate( uint64_t averageBitrate_ ) VULKAN_HPP_NOEXCEPT
+ {
+ averageBitrate = averageBitrate_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setMaxBitrate( uint64_t maxBitrate_ ) VULKAN_HPP_NOEXCEPT
+ {
+ maxBitrate = maxBitrate_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateNumerator( uint32_t frameRateNumerator_ ) VULKAN_HPP_NOEXCEPT
+ {
+ frameRateNumerator = frameRateNumerator_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateDenominator( uint32_t frameRateDenominator_ ) VULKAN_HPP_NOEXCEPT
+ {
+ frameRateDenominator = frameRateDenominator_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR *>( this );
+ }
+
+ operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &, uint64_t const &, uint32_t const &, uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, averageBitrate, maxBitrate, frameRateNumerator, frameRateDenominator );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default;
+# else
+ bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && ( maxBitrate == rhs.maxBitrate ) &&
+ ( frameRateNumerator == rhs.frameRateNumerator ) && ( frameRateDenominator == rhs.frameRateDenominator );
+# endif
+ }
+
+ bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlLayerInfoKHR;
+ const void * pNext = {};
+ uint64_t averageBitrate = {};
+ uint64_t maxBitrate = {};
+ uint32_t frameRateNumerator = {};
+ uint32_t frameRateDenominator = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeRateControlLayerInfoKHR>
+ {
+ using Type = VideoEncodeRateControlLayerInfoKHR;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeRateControlInfoKHR
+ {
+ using NativeType = VkVideoEncodeRateControlInfoKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlInfoKHR;
+
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR(
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault,
+ uint32_t layerCount_ = {},
+ const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ = {},
+ uint32_t virtualBufferSizeInMs_ = {},
+ uint32_t initialVirtualBufferSizeInMs_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , rateControlMode( rateControlMode_ )
+ , layerCount( layerCount_ )
+ , pLayers( pLayers_ )
+ , virtualBufferSizeInMs( virtualBufferSizeInMs_ )
+ , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ )
+ {
+ }
+
+ VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VideoEncodeRateControlInfoKHR( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeRateControlInfoKHR( *reinterpret_cast<VideoEncodeRateControlInfoKHR const *>( &rhs ) )
+ {
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeRateControlInfoKHR(
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_,
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_,
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> const & layers_,
+ uint32_t virtualBufferSizeInMs_ = {},
+ uint32_t initialVirtualBufferSizeInMs_ = {},
+ const void * pNext_ = nullptr )
+ : pNext( pNext_ )
+ , flags( flags_ )
+ , rateControlMode( rateControlMode_ )
+ , layerCount( static_cast<uint32_t>( layers_.size() ) )
+ , pLayers( layers_.data() )
+ , virtualBufferSizeInMs( virtualBufferSizeInMs_ )
+ , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ )
+ {
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VideoEncodeRateControlInfoKHR & operator=( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeRateControlInfoKHR & operator=( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const *>( &rhs );
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR &
+ setRateControlMode( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) VULKAN_HPP_NOEXCEPT
+ {
+ rateControlMode = rateControlMode_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setLayerCount( uint32_t layerCount_ ) VULKAN_HPP_NOEXCEPT
+ {
+ layerCount = layerCount_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR &
+ setPLayers( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ ) VULKAN_HPP_NOEXCEPT
+ {
+ pLayers = pLayers_;
+ return *this;
+ }
+
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ VideoEncodeRateControlInfoKHR & setLayers(
+ VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> const & layers_ ) VULKAN_HPP_NOEXCEPT
+ {
+ layerCount = static_cast<uint32_t>( layers_.size() );
+ pLayers = layers_.data();
+ return *this;
+ }
+# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ virtualBufferSizeInMs = virtualBufferSizeInMs_;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT
+ {
+ initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_;
+ return *this;
+ }
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+ operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>( this );
+ }
+
+ operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkVideoEncodeRateControlInfoKHR *>( this );
+ }
+
+# if defined( VULKAN_HPP_USE_REFLECT )
+# if 14 <= VULKAN_HPP_CPP_VERSION
+ auto
+# else
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+ const void * const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR const &,
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR const &,
+ uint32_t const &,
+ const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * const &,
+ uint32_t const &,
+ uint32_t const &>
+# endif
+ reflect() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayers, virtualBufferSizeInMs, initialVirtualBufferSizeInMs );
+ }
+# endif
+
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default;
+# else
+ bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+# if defined( VULKAN_HPP_USE_REFLECT )
+ return this->reflect() == rhs.reflect();
+# else
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlMode == rhs.rateControlMode ) &&
+ ( layerCount == rhs.layerCount ) && ( pLayers == rhs.pLayers ) && ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) &&
+ ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs );
+# endif
+ }
+
+ bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return !operator==( rhs );
+ }
+# endif
+
+ public:
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlInfoKHR;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault;
+ uint32_t layerCount = {};
+ const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers = {};
+ uint32_t virtualBufferSizeInMs = {};
+ uint32_t initialVirtualBufferSizeInMs = {};
+ };
+
+ template <>
+ struct CppType<StructureType, StructureType::eVideoEncodeRateControlInfoKHR>
+ {
+ using Type = VideoEncodeRateControlInfoKHR;
+ };
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+ struct VideoEncodeSessionParametersFeedbackInfoKHR
+ {
+ using NativeType = VkVideoEncodeSessionParametersFeedbackInfoKHR;
+
+ static const bool allowDuplicate = false;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR;
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateNumerator( uint32_t frameRateNumerator_ ) VULKAN_HPP_NOEXCEPT
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+ VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( VULKAN_HPP_NAMESPACE::Bool32 hasOverrides_ = {},
+ void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ : pNext( pNext_ )
+ , hasOverrides( hasOverrides_ )
{
- frameRateNumerator = frameRateNumerator_;
- return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateDenominator( uint32_t frameRateDenominator_ ) VULKAN_HPP_NOEXCEPT
- {
- frameRateDenominator = frameRateDenominator_;
- return *this;
- }
+ VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeSessionParametersFeedbackInfoKHR( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeSessionParametersFeedbackInfoKHR( *reinterpret_cast<VideoEncodeSessionParametersFeedbackInfoKHR const *>( &rhs ) )
{
- virtualBufferSizeInMs = virtualBufferSizeInMs_;
- return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+ VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_;
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const *>( &rhs );
return *this;
}
-# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeSessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR *>( this );
+ return *reinterpret_cast<const VkVideoEncodeSessionParametersFeedbackInfoKHR *>( this );
}
- operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeSessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR *>( this );
+ return *reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
- uint64_t const &,
- uint64_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &,
- uint32_t const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie(
- sType, pNext, averageBitrate, maxBitrate, frameRateNumerator, frameRateDenominator, virtualBufferSizeInMs, initialVirtualBufferSizeInMs );
+ return std::tie( sType, pNext, hasOverrides );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default;
+ auto operator<=>( VideoEncodeSessionParametersFeedbackInfoKHR const & ) const = default;
# else
- bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && ( maxBitrate == rhs.maxBitrate ) &&
- ( frameRateNumerator == rhs.frameRateNumerator ) && ( frameRateDenominator == rhs.frameRateDenominator ) &&
- ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) && ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasOverrides == rhs.hasOverrides );
# endif
}
- bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlLayerInfoKHR;
- const void * pNext = {};
- uint64_t averageBitrate = {};
- uint64_t maxBitrate = {};
- uint32_t frameRateNumerator = {};
- uint32_t frameRateDenominator = {};
- uint32_t virtualBufferSizeInMs = {};
- uint32_t initialVirtualBufferSizeInMs = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::Bool32 hasOverrides = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeRateControlLayerInfoKHR>
+ struct CppType<StructureType, StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR>
{
- using Type = VideoEncodeRateControlLayerInfoKHR;
+ using Type = VideoEncodeSessionParametersFeedbackInfoKHR;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
- struct VideoEncodeRateControlInfoKHR
+ struct VideoEncodeSessionParametersGetInfoKHR
{
- using NativeType = VkVideoEncodeRateControlInfoKHR;
+ using NativeType = VkVideoEncodeSessionParametersGetInfoKHR;
static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlInfoKHR;
+ static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersGetInfoKHR;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR(
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault,
- uint32_t layerCount_ = {},
- const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters_ = {},
+ const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
- , flags( flags_ )
- , rateControlMode( rateControlMode_ )
- , layerCount( layerCount_ )
- , pLayers( pLayers_ )
+ , videoSessionParameters( videoSessionParameters_ )
{
}
- VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VideoEncodeRateControlInfoKHR( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- : VideoEncodeRateControlInfoKHR( *reinterpret_cast<VideoEncodeRateControlInfoKHR const *>( &rhs ) )
- {
- }
+ VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeRateControlInfoKHR(
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_,
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_,
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> const & layers_,
- const void * pNext_ = nullptr )
- : pNext( pNext_ ), flags( flags_ ), rateControlMode( rateControlMode_ ), layerCount( static_cast<uint32_t>( layers_.size() ) ), pLayers( layers_.data() )
+ VideoEncodeSessionParametersGetInfoKHR( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ : VideoEncodeSessionParametersGetInfoKHR( *reinterpret_cast<VideoEncodeSessionParametersGetInfoKHR const *>( &rhs ) )
{
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- VideoEncodeRateControlInfoKHR & operator=( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+ VideoEncodeSessionParametersGetInfoKHR & operator=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
- VideoEncodeRateControlInfoKHR & operator=( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ VideoEncodeSessionParametersGetInfoKHR & operator=( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const *>( &rhs );
+ *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
- {
- flags = flags_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR &
- setRateControlMode( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) VULKAN_HPP_NOEXCEPT
- {
- rateControlMode = rateControlMode_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setLayerCount( uint32_t layerCount_ ) VULKAN_HPP_NOEXCEPT
- {
- layerCount = layerCount_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR &
- setPLayers( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ ) VULKAN_HPP_NOEXCEPT
- {
- pLayers = pLayers_;
- return *this;
- }
-
-# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
- VideoEncodeRateControlInfoKHR & setLayers(
- VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR> const & layers_ ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR &
+ setVideoSessionParameters( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters_ ) VULKAN_HPP_NOEXCEPT
{
- layerCount = static_cast<uint32_t>( layers_.size() );
- pLayers = layers_.data();
+ videoSessionParameters = videoSessionParameters_;
return *this;
}
-# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
- operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeSessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>( this );
+ return *reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( this );
}
- operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT
+ operator VkVideoEncodeSessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT
{
- return *reinterpret_cast<VkVideoEncodeRateControlInfoKHR *>( this );
+ return *reinterpret_cast<VkVideoEncodeSessionParametersGetInfoKHR *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR const &,
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR const &,
- uint32_t const &,
- const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * const &>
+ std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
- return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayers );
+ return std::tie( sType, pNext, videoSessionParameters );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default;
+ auto operator<=>( VideoEncodeSessionParametersGetInfoKHR const & ) const = default;
# else
- bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator==( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlMode == rhs.rateControlMode ) &&
- ( layerCount == rhs.layerCount ) && ( pLayers == rhs.pLayers );
+ return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoSessionParameters == rhs.videoSessionParameters );
# endif
}
- bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
+ bool operator!=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlInfoKHR;
- const void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault;
- uint32_t layerCount = {};
- const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeSessionParametersGetInfoKHR;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters = {};
};
template <>
- struct CppType<StructureType, StructureType::eVideoEncodeRateControlInfoKHR>
+ struct CppType<StructureType, StructureType::eVideoEncodeSessionParametersGetInfoKHR>
{
- using Type = VideoEncodeRateControlInfoKHR;
+ using Type = VideoEncodeSessionParametersGetInfoKHR;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
using Type = VideoFormatPropertiesKHR;
};
- struct VideoProfileInfoKHR
- {
- using NativeType = VkVideoProfileInfoKHR;
-
- static const bool allowDuplicate = false;
- static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileInfoKHR;
-
-#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR(
- VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone,
- VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ = {},
- VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ = {},
- VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ = {},
- const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
- : pNext( pNext_ )
- , videoCodecOperation( videoCodecOperation_ )
- , chromaSubsampling( chromaSubsampling_ )
- , lumaBitDepth( lumaBitDepth_ )
- , chromaBitDepth( chromaBitDepth_ )
- {
- }
-
- VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VideoProfileInfoKHR( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoProfileInfoKHR( *reinterpret_cast<VideoProfileInfoKHR const *>( &rhs ) )
- {
- }
-
- VideoProfileInfoKHR & operator=( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
-
- VideoProfileInfoKHR & operator=( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const *>( &rhs );
- return *this;
- }
-
-#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
- VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
- {
- pNext = pNext_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR &
- setVideoCodecOperation( VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) VULKAN_HPP_NOEXCEPT
- {
- videoCodecOperation = videoCodecOperation_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR &
- setChromaSubsampling( VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) VULKAN_HPP_NOEXCEPT
- {
- chromaSubsampling = chromaSubsampling_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setLumaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) VULKAN_HPP_NOEXCEPT
- {
- lumaBitDepth = lumaBitDepth_;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) VULKAN_HPP_NOEXCEPT
- {
- chromaBitDepth = chromaBitDepth_;
- return *this;
- }
-#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
- operator VkVideoProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<const VkVideoProfileInfoKHR *>( this );
- }
-
- operator VkVideoProfileInfoKHR &() VULKAN_HPP_NOEXCEPT
- {
- return *reinterpret_cast<VkVideoProfileInfoKHR *>( this );
- }
-
-#if defined( VULKAN_HPP_USE_REFLECT )
-# if 14 <= VULKAN_HPP_CPP_VERSION
- auto
-# else
- std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
- const void * const &,
- VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR const &,
- VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR const &,
- VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &,
- VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &>
-# endif
- reflect() const VULKAN_HPP_NOEXCEPT
- {
- return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth );
- }
-#endif
-
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( VideoProfileInfoKHR const & ) const = default;
-#else
- bool operator==( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
-# if defined( VULKAN_HPP_USE_REFLECT )
- return this->reflect() == rhs.reflect();
-# else
- return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) &&
- ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && ( chromaBitDepth == rhs.chromaBitDepth );
-# endif
- }
-
- bool operator!=( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return !operator==( rhs );
- }
-#endif
-
- public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoProfileInfoKHR;
- const void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone;
- VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling = {};
- VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth = {};
- VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth = {};
- };
-
- template <>
- struct CppType<StructureType, StructureType::eVideoProfileInfoKHR>
- {
- using Type = VideoProfileInfoKHR;
- };
-
struct VideoProfileListInfoKHR
{
using NativeType = VkVideoProfileListInfoKHR;
projects / platform / upstream / Vulkan-Hpp.git / commitdiff