From 47520a10252d55b4e6c7098e2c9736b89f37f0af Mon Sep 17 00:00:00 2001 From: GitHub Date: Sat, 19 Feb 2022 00:07:27 +0000 Subject: [PATCH] Update Vulkan-Headers to v1.3.206 --- Vulkan-Headers | 2 +- vulkan/vulkan.hpp | 14 +- vulkan/vulkan_enums.hpp | 461 ++++++++++++-- vulkan/vulkan_handles.hpp | 2 + vulkan/vulkan_hash.hpp | 91 ++- vulkan/vulkan_structs.hpp | 1272 +++++++++++++++++++------------------ 6 files changed, 1165 insertions(+), 677 deletions(-) diff --git a/Vulkan-Headers b/Vulkan-Headers index b32da53..aa18f18 160000 --- a/Vulkan-Headers +++ b/Vulkan-Headers @@ -1 +1 @@ -Subproject commit b32da5329b50e3cb96229aaecba9ded032fe29cc +Subproject commit aa18f182ebba65438b1cfdbd571f020bb2e34d04 diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 86eb346..b29442b 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -119,7 +119,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 205, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 206, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -8205,7 +8205,7 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_encode_h264 === template <> - struct StructExtends + struct StructExtends { enum { @@ -8321,7 +8321,7 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_encode_h265 === template <> - struct StructExtends + struct StructExtends { enum { @@ -10599,6 +10599,14 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum diff --git a/vulkan/vulkan_enums.hpp b/vulkan/vulkan_enums.hpp index 9377442..4b56c63 100644 --- a/vulkan/vulkan_enums.hpp +++ b/vulkan/vulkan_enums.hpp @@ -442,6 +442,7 @@ namespace VULKAN_HPP_NAMESPACE eVideoEncodeH264ProfileEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT, eVideoEncodeH264RateControlInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT, eVideoEncodeH264RateControlLayerInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT, + eVideoEncodeH264ReferenceListsEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT, eVideoEncodeH265CapabilitiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT, eVideoEncodeH265SessionCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT, eVideoEncodeH265SessionParametersCreateInfoEXT = @@ -815,6 +816,7 @@ namespace VULKAN_HPP_NAMESPACE eVideoEncodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR, eVideoEncodeRateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR, eVideoEncodeRateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR, + eVideoEncodeCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, eDeviceDiagnosticsConfigCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, @@ -1437,6 +1439,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eVideoEncodeH264ProfileEXT: return "VideoEncodeH264ProfileEXT"; case StructureType::eVideoEncodeH264RateControlInfoEXT: return "VideoEncodeH264RateControlInfoEXT"; case StructureType::eVideoEncodeH264RateControlLayerInfoEXT: return "VideoEncodeH264RateControlLayerInfoEXT"; + case StructureType::eVideoEncodeH264ReferenceListsEXT: return "VideoEncodeH264ReferenceListsEXT"; case StructureType::eVideoEncodeH265CapabilitiesEXT: return "VideoEncodeH265CapabilitiesEXT"; case StructureType::eVideoEncodeH265SessionCreateInfoEXT: return "VideoEncodeH265SessionCreateInfoEXT"; case StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT: @@ -1855,6 +1858,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eVideoEncodeInfoKHR: return "VideoEncodeInfoKHR"; case StructureType::eVideoEncodeRateControlInfoKHR: return "VideoEncodeRateControlInfoKHR"; case StructureType::eVideoEncodeRateControlLayerInfoKHR: return "VideoEncodeRateControlLayerInfoKHR"; + case StructureType::eVideoEncodeCapabilitiesKHR: return "VideoEncodeCapabilitiesKHR"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV: return "PhysicalDeviceDiagnosticsConfigFeaturesNV"; @@ -6513,34 +6517,58 @@ namespace VULKAN_HPP_NAMESPACE enum class VideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT { - eCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT, - eCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT, - eWeightedBiPredImplicit = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT, - eTransform8X8 = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT, - eChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT, - eSecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT, - eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT, - eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT, - eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT, - eMultipleSlicePerFrame = VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT, - eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT + eDirect8X8Inference = VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_BIT_EXT, + eSeparateColourPlane = VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT, + eQpprimeYZeroTransformBypass = VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT, + eScalingLists = VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT, + eHrdCompliance = VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT, + eChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT, + eSecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT, + ePicInitQpMinus26 = VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT, + eWeightedPred = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT, + eWeightedBipredExplicit = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT, + eWeightedBipredImplicit = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT, + eWeightedPredNoTable = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT, + eTransform8X8 = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT, + eCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT, + eCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT, + eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT, + eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT, + eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT, + eDisableDirectSpatialMvPred = VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT, + eMultipleSlicePerFrame = VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT, + eSliceMbCount = VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT, + eRowUnalignedSlice = VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT, + eDifferentSliceType = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT }; VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagBitsEXT value ) { switch ( value ) { - case VideoEncodeH264CapabilityFlagBitsEXT::eCabac: return "Cabac"; - case VideoEncodeH264CapabilityFlagBitsEXT::eCavlc: return "Cavlc"; - case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit: return "WeightedBiPredImplicit"; - case VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8: return "Transform8X8"; + case VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8Inference: return "Direct8X8Inference"; + case VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane: return "SeparateColourPlane"; + case VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass: return "QpprimeYZeroTransformBypass"; + case VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists: return "ScalingLists"; + case VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance: return "HrdCompliance"; case VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset: return "ChromaQpOffset"; case VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset: return "SecondChromaQpOffset"; + case VideoEncodeH264CapabilityFlagBitsEXT::ePicInitQpMinus26: return "PicInitQpMinus26"; + case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPred: return "WeightedPred"; + case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredExplicit: return "WeightedBipredExplicit"; + case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredImplicit: return "WeightedBipredImplicit"; + case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPredNoTable: return "WeightedPredNoTable"; + case VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8: return "Transform8X8"; + case VideoEncodeH264CapabilityFlagBitsEXT::eCabac: return "Cabac"; + case VideoEncodeH264CapabilityFlagBitsEXT::eCavlc: return "Cavlc"; case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled: return "DeblockingFilterDisabled"; case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled"; case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial"; + case VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred: return "DisableDirectSpatialMvPred"; case VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame: return "MultipleSlicePerFrame"; - case VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize: return "EvenlyDistributedSliceSize"; + case VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount: return "SliceMbCount"; + case VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice: return "RowUnalignedSlice"; + case VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType: return "DifferentSliceType"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6619,6 +6647,68 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_encode_h265 === + enum class VideoEncodeH265CapabilityFlagBitsEXT : VkVideoEncodeH265CapabilityFlagsEXT + { + eSeparateColourPlane = VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT, + eScalingLists = VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT, + eSampleAdaptiveOffsetEnabled = VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT, + ePcmEnable = VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT, + eSpsTemporalMvpEnabled = VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT, + eHrdCompliance = VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT, + eInitQpMinus26 = VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT, + eLog2ParallelMergeLevelMinus2 = VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT, + eSignDataHidingEnabled = VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT, + eTransformSkipEnabled = VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT, + ePpsSliceChromaQpOffsetsPresent = VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT, + eWeightedPred = VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT, + eWeightedBipred = VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT, + eWeightedPredNoTable = VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT, + eTransquantBypassEnabled = VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT, + eEntropyCodingSyncEnabled = VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT, + eDeblockingFilterOverrideEnabled = VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT, + eMultipleTilePerFrame = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT, + eMultipleSlicePerTile = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT, + eMultipleTilePerSlice = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT, + eSliceSegmentCtbCount = VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT, + eRowUnalignedSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT, + eDependentSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT, + eDifferentSliceType = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagBitsEXT value ) + { + switch ( value ) + { + case VideoEncodeH265CapabilityFlagBitsEXT::eSeparateColourPlane: return "SeparateColourPlane"; + case VideoEncodeH265CapabilityFlagBitsEXT::eScalingLists: return "ScalingLists"; + case VideoEncodeH265CapabilityFlagBitsEXT::eSampleAdaptiveOffsetEnabled: return "SampleAdaptiveOffsetEnabled"; + case VideoEncodeH265CapabilityFlagBitsEXT::ePcmEnable: return "PcmEnable"; + case VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled: return "SpsTemporalMvpEnabled"; + case VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance: return "HrdCompliance"; + case VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26: return "InitQpMinus26"; + case VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2: return "Log2ParallelMergeLevelMinus2"; + case VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled: return "SignDataHidingEnabled"; + case VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled: return "TransformSkipEnabled"; + case VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent: + return "PpsSliceChromaQpOffsetsPresent"; + case VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred: return "WeightedPred"; + case VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred: return "WeightedBipred"; + case VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable: return "WeightedPredNoTable"; + case VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled: return "TransquantBypassEnabled"; + case VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled: return "EntropyCodingSyncEnabled"; + case VideoEncodeH265CapabilityFlagBitsEXT::eDeblockingFilterOverrideEnabled: + return "DeblockingFilterOverrideEnabled"; + case VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame: return "MultipleTilePerFrame"; + case VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile: return "MultipleSlicePerTile"; + case VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice: return "MultipleTilePerSlice"; + case VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount: return "SliceSegmentCtbCount"; + case VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment: return "RowUnalignedSliceSegment"; + case VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment: return "DependentSliceSegment"; + case VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType: return "DifferentSliceType"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + enum class VideoEncodeH265InputModeFlagBitsEXT : VkVideoEncodeH265InputModeFlagsEXT { eFrame = VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT, @@ -6657,7 +6747,6 @@ namespace VULKAN_HPP_NAMESPACE enum class VideoEncodeH265CtbSizeFlagBitsEXT : VkVideoEncodeH265CtbSizeFlagsEXT { - e8 = VK_VIDEO_ENCODE_H265_CTB_SIZE_8_BIT_EXT, e16 = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT, e32 = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT, e64 = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT @@ -6667,7 +6756,6 @@ namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case VideoEncodeH265CtbSizeFlagBitsEXT::e8: return "8"; case VideoEncodeH265CtbSizeFlagBitsEXT::e16: return "16"; case VideoEncodeH265CtbSizeFlagBitsEXT::e32: return "32"; case VideoEncodeH265CtbSizeFlagBitsEXT::e64: return "64"; @@ -6675,6 +6763,26 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class VideoEncodeH265TransformBlockSizeFlagBitsEXT : VkVideoEncodeH265TransformBlockSizeFlagsEXT + { + e4 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT, + e8 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT, + e16 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT, + e32 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT + }; + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265TransformBlockSizeFlagBitsEXT value ) + { + switch ( value ) + { + case VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4: return "4"; + case VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8: return "8"; + case VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16: return "16"; + case VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32: return "32"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + enum class VideoEncodeH265RateControlStructureFlagBitsEXT : VkVideoEncodeH265RateControlStructureFlagsEXT { eUnknown = VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT, @@ -6693,15 +6801,6 @@ namespace VULKAN_HPP_NAMESPACE } } - enum class VideoEncodeH265CapabilityFlagBitsEXT : VkVideoEncodeH265CapabilityFlagsEXT - { - }; - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagBitsEXT ) - { - return "(void)"; - } - enum class VideoEncodeH265CreateFlagBitsEXT : VkVideoEncodeH265CreateFlagsEXT { }; @@ -8181,6 +8280,22 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class VideoEncodeCapabilityFlagBitsKHR : VkVideoEncodeCapabilityFlagsKHR + { + eDefault = VK_VIDEO_ENCODE_CAPABILITY_DEFAULT_KHR, + ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeCapabilityFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeCapabilityFlagBitsKHR::eDefault: return "Default"; + case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes: return "PrecedingExternallyEncodedBytes"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + enum class VideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR { eDefault = VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR, @@ -20993,17 +21108,29 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) | + allFlags = VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8Inference ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::ePicInitQpMinus26 ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPred ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredExplicit ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredImplicit ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPredNoTable ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) | - VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice ) | + VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType ) }; }; @@ -21037,28 +21164,52 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) - result += "Cabac | "; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) - result += "Cavlc | "; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit ) - result += "WeightedBiPredImplicit | "; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) - result += "Transform8X8 | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8Inference ) + result += "Direct8X8Inference | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane ) + result += "SeparateColourPlane | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass ) + result += "QpprimeYZeroTransformBypass | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists ) + result += "ScalingLists | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance ) + result += "HrdCompliance | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) result += "ChromaQpOffset | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) result += "SecondChromaQpOffset | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::ePicInitQpMinus26 ) + result += "PicInitQpMinus26 | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPred ) + result += "WeightedPred | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredExplicit ) + result += "WeightedBipredExplicit | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredImplicit ) + result += "WeightedBipredImplicit | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPredNoTable ) + result += "WeightedPredNoTable | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) + result += "Transform8X8 | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) + result += "Cabac | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) + result += "Cavlc | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled ) result += "DeblockingFilterDisabled | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) result += "DeblockingFilterEnabled | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) result += "DeblockingFilterPartial | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred ) + result += "DisableDirectSpatialMvPred | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) result += "MultipleSlicePerFrame | "; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) - result += "EvenlyDistributedSliceSize | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount ) + result += "SliceMbCount | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice ) + result += "RowUnalignedSlice | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType ) + result += "DifferentSliceType | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -21277,9 +21428,118 @@ namespace VULKAN_HPP_NAMESPACE using VideoEncodeH265CapabilityFlagsEXT = Flags; - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsEXT ) + template <> + struct FlagTraits { - return "{}"; + enum : VkFlags + { + allFlags = VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSeparateColourPlane ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eScalingLists ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSampleAdaptiveOffsetEnabled ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::ePcmEnable ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26 ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2 ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDeblockingFilterOverrideEnabled ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment ) | + VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType ) + }; + }; + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilityFlagsEXT operator|( + VideoEncodeH265CapabilityFlagBitsEXT bit0, VideoEncodeH265CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeH265CapabilityFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilityFlagsEXT operator&( + VideoEncodeH265CapabilityFlagBitsEXT bit0, VideoEncodeH265CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeH265CapabilityFlagsEXT( bit0 ) & bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilityFlagsEXT operator^( + VideoEncodeH265CapabilityFlagBitsEXT bit0, VideoEncodeH265CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeH265CapabilityFlagsEXT( bit0 ) ^ bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilityFlagsEXT + operator~( VideoEncodeH265CapabilityFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT + { + return ~( VideoEncodeH265CapabilityFlagsEXT( bits ) ); + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsEXT value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSeparateColourPlane ) + result += "SeparateColourPlane | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eScalingLists ) + result += "ScalingLists | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSampleAdaptiveOffsetEnabled ) + result += "SampleAdaptiveOffsetEnabled | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::ePcmEnable ) + result += "PcmEnable | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled ) + result += "SpsTemporalMvpEnabled | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance ) + result += "HrdCompliance | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26 ) + result += "InitQpMinus26 | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2 ) + result += "Log2ParallelMergeLevelMinus2 | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled ) + result += "SignDataHidingEnabled | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled ) + result += "TransformSkipEnabled | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent ) + result += "PpsSliceChromaQpOffsetsPresent | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred ) + result += "WeightedPred | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred ) + result += "WeightedBipred | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable ) + result += "WeightedPredNoTable | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled ) + result += "TransquantBypassEnabled | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled ) + result += "EntropyCodingSyncEnabled | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDeblockingFilterOverrideEnabled ) + result += "DeblockingFilterOverrideEnabled | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame ) + result += "MultipleTilePerFrame | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile ) + result += "MultipleSlicePerTile | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice ) + result += "MultipleTilePerSlice | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount ) + result += "SliceSegmentCtbCount | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment ) + result += "RowUnalignedSliceSegment | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment ) + result += "DependentSliceSegment | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType ) + result += "DifferentSliceType | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } using VideoEncodeH265InputModeFlagsEXT = Flags; @@ -21402,8 +21662,8 @@ namespace VULKAN_HPP_NAMESPACE { enum : VkFlags { - allFlags = VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e8 ) | VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e16 ) | - VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e32 ) | VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e64 ) + allFlags = VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e16 ) | VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e32 ) | + VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e64 ) }; }; @@ -21437,8 +21697,6 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e8 ) - result += "8 | "; if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e16 ) result += "16 | "; if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e32 ) @@ -21449,6 +21707,65 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + using VideoEncodeH265TransformBlockSizeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + enum : VkFlags + { + allFlags = VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 ) | + VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 ) | + VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 ) | + VkFlags( VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32 ) + }; + }; + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsEXT + operator|( VideoEncodeH265TransformBlockSizeFlagBitsEXT bit0, + VideoEncodeH265TransformBlockSizeFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeH265TransformBlockSizeFlagsEXT( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsEXT + operator&( VideoEncodeH265TransformBlockSizeFlagBitsEXT bit0, + VideoEncodeH265TransformBlockSizeFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeH265TransformBlockSizeFlagsEXT( bit0 ) & bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsEXT + operator^( VideoEncodeH265TransformBlockSizeFlagBitsEXT bit0, + VideoEncodeH265TransformBlockSizeFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeH265TransformBlockSizeFlagsEXT( bit0 ) ^ bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsEXT + operator~( VideoEncodeH265TransformBlockSizeFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT + { + return ~( VideoEncodeH265TransformBlockSizeFlagsEXT( bits ) ); + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265TransformBlockSizeFlagsEXT value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 ) + result += "4 | "; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 ) + result += "8 | "; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 ) + result += "16 | "; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32 ) + result += "32 | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } + using VideoEncodeH265RateControlStructureFlagsEXT = Flags; template <> @@ -22521,6 +22838,54 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + using VideoEncodeCapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + enum : VkFlags + { + allFlags = VkFlags( VideoEncodeCapabilityFlagBitsKHR::eDefault ) | + VkFlags( VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes ) + }; + }; + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeCapabilityFlagsKHR + operator|( VideoEncodeCapabilityFlagBitsKHR bit0, VideoEncodeCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeCapabilityFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeCapabilityFlagsKHR + operator&( VideoEncodeCapabilityFlagBitsKHR bit0, VideoEncodeCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeCapabilityFlagsKHR( bit0 ) & bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeCapabilityFlagsKHR + operator^( VideoEncodeCapabilityFlagBitsKHR bit0, VideoEncodeCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return VideoEncodeCapabilityFlagsKHR( bit0 ) ^ bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeCapabilityFlagsKHR + operator~( VideoEncodeCapabilityFlagBitsKHR bits ) VULKAN_HPP_NOEXCEPT + { + return ~( VideoEncodeCapabilityFlagsKHR( bits ) ); + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeCapabilityFlagsKHR value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes ) + result += "PrecedingExternallyEncodedBytes | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } + using VideoEncodeRateControlFlagsKHR = Flags; template <> diff --git a/vulkan/vulkan_handles.hpp b/vulkan/vulkan_handles.hpp index 00d8887..40791a3 100644 --- a/vulkan/vulkan_handles.hpp +++ b/vulkan/vulkan_handles.hpp @@ -583,6 +583,7 @@ namespace VULKAN_HPP_NAMESPACE struct VideoEncodeH264SessionParametersCreateInfoEXT; struct VideoEncodeH264SessionParametersAddInfoEXT; struct VideoEncodeH264VclFrameInfoEXT; + struct VideoEncodeH264ReferenceListsEXT; struct VideoEncodeH264EmitPictureParametersEXT; struct VideoEncodeH264DpbSlotInfoEXT; struct VideoEncodeH264NaluSliceEXT; @@ -1182,6 +1183,7 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === struct VideoEncodeInfoKHR; + struct VideoEncodeCapabilitiesKHR; struct VideoEncodeRateControlInfoKHR; struct VideoEncodeRateControlLayerInfoKHR; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ diff --git a/vulkan/vulkan_hash.hpp b/vulkan/vulkan_hash.hpp index e1b22a9..14b3525 100644 --- a/vulkan/vulkan_hash.hpp +++ b/vulkan/vulkan_hash.hpp @@ -12289,6 +12289,26 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.qualityLevelCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.inputImageDataFillAlignment ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -12303,13 +12323,14 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.flags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.inputModeFlags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.outputModeFlags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.minPictureSizeInMbs ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxPictureSizeInMbs ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.inputImageDataAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForP ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForB ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxNumL1Reference ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.qualityLevelCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxPPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxL1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.motionVectorsOverPicBoundariesFlag ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBytesPerPicDenom ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBitsPerMbDenom ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthHorizontal ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthVertical ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.stdExtensionVersion ); return seed; } @@ -12327,7 +12348,7 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.slotIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pStdPictureInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pStdReferenceInfo ); return seed; } }; @@ -12368,6 +12389,26 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT const & + videoEncodeH264ReferenceListsEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsEXT.referenceList0EntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsEXT.pReferenceList0Entries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsEXT.referenceList1EntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsEXT.pReferenceList1Entries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ReferenceListsEXT.pMemMgmtCtrlOperations ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -12378,12 +12419,9 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.mbCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.refFinalList0EntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pRefFinalList0Entries ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.refFinalList1EntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pRefFinalList1Entries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pReferenceFinalLists ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd ); return seed; } }; @@ -12531,10 +12569,7 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList0EntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList0Entries ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList1EntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pRefDefaultFinalList1Entries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pReferenceFinalLists ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo ); @@ -12558,12 +12593,22 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.inputModeFlags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.outputModeFlags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.ctbSizes ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.inputImageDataAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForP ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForB ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumL1Reference ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumSubLayers ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.qualityLevelCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.transformBlockSizes ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxPPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxBPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxL1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxSubLayersCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minLog2MinLumaCodingBlockSizeMinus3 ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxLog2MinLumaCodingBlockSizeMinus3 ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minLog2MinLumaTransformBlockSizeMinus2 ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxLog2MinLumaTransformBlockSizeMinus2 ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minMaxTransformHierarchyDepthInter ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxMaxTransformHierarchyDepthInter ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minMaxTransformHierarchyDepthIntra ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxMaxTransformHierarchyDepthIntra ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxDiffCuQpDeltaDepth ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minMaxNumMergeCand ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxMaxNumMergeCand ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.stdExtensionVersion ); return seed; } diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp index cd89a30..357a292 100644 --- a/vulkan/vulkan_structs.hpp +++ b/vulkan/vulkan_structs.hpp @@ -64764,284 +64764,6 @@ namespace VULKAN_HPP_NAMESPACE return *this; } -#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct8BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct8BitUnsignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct8BitUnsignedAccelerated = integerDotProduct8BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & setIntegerDotProduct8BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct8BitSignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct8BitSignedAccelerated = integerDotProduct8BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct8BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct8BitMixedSignednessAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct8BitMixedSignednessAccelerated = integerDotProduct8BitMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct4x8BitPackedUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct4x8BitPackedUnsignedAccelerated = integerDotProduct4x8BitPackedUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct4x8BitPackedSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct4x8BitPackedSignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct4x8BitPackedSignedAccelerated = integerDotProduct4x8BitPackedSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct4x8BitPackedMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct4x8BitPackedMixedSignednessAccelerated = - integerDotProduct4x8BitPackedMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct16BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct16BitUnsignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct16BitUnsignedAccelerated = integerDotProduct16BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct16BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct16BitSignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct16BitSignedAccelerated = integerDotProduct16BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct16BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct16BitMixedSignednessAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct16BitMixedSignednessAccelerated = integerDotProduct16BitMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct32BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct32BitUnsignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct32BitUnsignedAccelerated = integerDotProduct32BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct32BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct32BitSignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct32BitSignedAccelerated = integerDotProduct32BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct32BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct32BitMixedSignednessAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct32BitMixedSignednessAccelerated = integerDotProduct32BitMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct64BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct64BitUnsignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct64BitUnsignedAccelerated = integerDotProduct64BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct64BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct64BitSignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct64BitSignedAccelerated = integerDotProduct64BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProduct64BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProduct64BitMixedSignednessAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProduct64BitMixedSignednessAccelerated = integerDotProduct64BitMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating8BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = - integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating8BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated_ ) VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating8BitSignedAccelerated = - integerDotProductAccumulatingSaturating8BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = - integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = - integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = - integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = - integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating16BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = - integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating16BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating16BitSignedAccelerated = - integerDotProductAccumulatingSaturating16BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = - integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating32BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = - integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating32BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating32BitSignedAccelerated = - integerDotProductAccumulatingSaturating32BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = - integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating64BitUnsignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = - integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating64BitSignedAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating64BitSignedAccelerated = - integerDotProductAccumulatingSaturating64BitSignedAccelerated_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductProperties & - setIntegerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated( - VULKAN_HPP_NAMESPACE::Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ ) - VULKAN_HPP_NOEXCEPT - { - integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = - integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_; - return *this; - } -#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - explicit operator VkPhysicalDeviceShaderIntegerDotProductProperties const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); @@ -94583,6 +94305,161 @@ namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeCapabilitiesKHR + { + using NativeType = VkVideoEncodeCapabilitiesKHR; + + static const bool allowDuplicate = false; + 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_ = {}, + uint8_t rateControlLayerCount_ = {}, + uint8_t qualityLevelCount_ = {}, + VULKAN_HPP_NAMESPACE::Extent2D inputImageDataFillAlignment_ = {} ) VULKAN_HPP_NOEXCEPT + : flags( flags_ ) + , rateControlModes( rateControlModes_ ) + , rateControlLayerCount( rateControlLayerCount_ ) + , qualityLevelCount( qualityLevelCount_ ) + , inputImageDataFillAlignment( inputImageDataFillAlignment_ ) + {} + + VULKAN_HPP_CONSTEXPR + VideoEncodeCapabilitiesKHR( VideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeCapabilitiesKHR( VkVideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + {} +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeCapabilitiesKHR & operator=( VideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeCapabilitiesKHR & operator=( VkVideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & + setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & setRateControlModes( + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes_ ) VULKAN_HPP_NOEXCEPT + { + rateControlModes = rateControlModes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & + setRateControlLayerCount( uint8_t rateControlLayerCount_ ) VULKAN_HPP_NOEXCEPT + { + rateControlLayerCount = rateControlLayerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & + setQualityLevelCount( uint8_t qualityLevelCount_ ) VULKAN_HPP_NOEXCEPT + { + qualityLevelCount = qualityLevelCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & setInputImageDataFillAlignment( + VULKAN_HPP_NAMESPACE::Extent2D const & inputImageDataFillAlignment_ ) VULKAN_HPP_NOEXCEPT + { + inputImageDataFillAlignment = inputImageDataFillAlignment_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + explicit operator VkVideoEncodeCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + explicit operator VkVideoEncodeCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, rateControlModes, rateControlLayerCount, qualityLevelCount, inputImageDataFillAlignment ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeCapabilitiesKHR const & ) const = default; +# else + bool operator==( VideoEncodeCapabilitiesKHR 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 ) && + ( rateControlModes == rhs.rateControlModes ) && ( rateControlLayerCount == rhs.rateControlLayerCount ) && + ( qualityLevelCount == rhs.qualityLevelCount ) && + ( inputImageDataFillAlignment == rhs.inputImageDataFillAlignment ); +# endif + } + + bool operator!=( VideoEncodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeCapabilitiesKHR; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes = {}; + uint8_t rateControlLayerCount = {}; + uint8_t qualityLevelCount = {}; + VULKAN_HPP_NAMESPACE::Extent2D inputImageDataFillAlignment = {}; + }; + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR ) == + sizeof( VkVideoEncodeCapabilitiesKHR ), + "struct and wrapper have different size!" ); + VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); + VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeCapabilitiesKHR is not nothrow_move_constructible!" ); + + template <> + struct CppType + { + using Type = VideoEncodeCapabilitiesKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + #if defined( VK_ENABLE_BETA_EXTENSIONS ) struct VideoEncodeH264CapabilitiesEXT { @@ -94593,27 +94470,29 @@ namespace VULKAN_HPP_NAMESPACE # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT( - VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_ = {}, - VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs_ = {}, - VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs_ = {}, - VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment_ = {}, - uint8_t maxNumL0ReferenceForP_ = {}, - uint8_t maxNumL0ReferenceForB_ = {}, - uint8_t maxNumL1Reference_ = {}, - uint8_t qualityLevelCount_ = {}, - VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_ = {}, + uint8_t maxPPictureL0ReferenceCount_ = {}, + uint8_t maxBPictureL0ReferenceCount_ = {}, + uint8_t maxL1ReferenceCount_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag_ = {}, + uint32_t maxBytesPerPicDenom_ = {}, + uint32_t maxBitsPerMbDenom_ = {}, + uint32_t log2MaxMvLengthHorizontal_ = {}, + uint32_t log2MaxMvLengthVertical_ = {}, + VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) , inputModeFlags( inputModeFlags_ ) , outputModeFlags( outputModeFlags_ ) - , minPictureSizeInMbs( minPictureSizeInMbs_ ) - , maxPictureSizeInMbs( maxPictureSizeInMbs_ ) - , inputImageDataAlignment( inputImageDataAlignment_ ) - , maxNumL0ReferenceForP( maxNumL0ReferenceForP_ ) - , maxNumL0ReferenceForB( maxNumL0ReferenceForB_ ) - , maxNumL1Reference( maxNumL1Reference_ ) - , qualityLevelCount( qualityLevelCount_ ) + , maxPPictureL0ReferenceCount( maxPPictureL0ReferenceCount_ ) + , maxBPictureL0ReferenceCount( maxBPictureL0ReferenceCount_ ) + , maxL1ReferenceCount( maxL1ReferenceCount_ ) + , motionVectorsOverPicBoundariesFlag( motionVectorsOverPicBoundariesFlag_ ) + , maxBytesPerPicDenom( maxBytesPerPicDenom_ ) + , maxBitsPerMbDenom( maxBitsPerMbDenom_ ) + , log2MaxMvLengthHorizontal( log2MaxMvLengthHorizontal_ ) + , log2MaxMvLengthVertical( log2MaxMvLengthVertical_ ) , stdExtensionVersion( stdExtensionVersion_ ) {} @@ -94663,51 +94542,58 @@ namespace VULKAN_HPP_NAMESPACE } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & - setMinPictureSizeInMbs( VULKAN_HPP_NAMESPACE::Extent2D const & minPictureSizeInMbs_ ) VULKAN_HPP_NOEXCEPT + setMaxPPictureL0ReferenceCount( uint8_t maxPPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT { - minPictureSizeInMbs = minPictureSizeInMbs_; + maxPPictureL0ReferenceCount = maxPPictureL0ReferenceCount_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & - setMaxPictureSizeInMbs( VULKAN_HPP_NAMESPACE::Extent2D const & maxPictureSizeInMbs_ ) VULKAN_HPP_NOEXCEPT + setMaxBPictureL0ReferenceCount( uint8_t maxBPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT { - maxPictureSizeInMbs = maxPictureSizeInMbs_; + maxBPictureL0ReferenceCount = maxBPictureL0ReferenceCount_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & - setInputImageDataAlignment( VULKAN_HPP_NAMESPACE::Extent2D const & inputImageDataAlignment_ ) VULKAN_HPP_NOEXCEPT + setMaxL1ReferenceCount( uint8_t maxL1ReferenceCount_ ) VULKAN_HPP_NOEXCEPT { - inputImageDataAlignment = inputImageDataAlignment_; + maxL1ReferenceCount = maxL1ReferenceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setMotionVectorsOverPicBoundariesFlag( + VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag_ ) VULKAN_HPP_NOEXCEPT + { + motionVectorsOverPicBoundariesFlag = motionVectorsOverPicBoundariesFlag_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & - setMaxNumL0ReferenceForP( uint8_t maxNumL0ReferenceForP_ ) VULKAN_HPP_NOEXCEPT + setMaxBytesPerPicDenom( uint32_t maxBytesPerPicDenom_ ) VULKAN_HPP_NOEXCEPT { - maxNumL0ReferenceForP = maxNumL0ReferenceForP_; + maxBytesPerPicDenom = maxBytesPerPicDenom_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & - setMaxNumL0ReferenceForB( uint8_t maxNumL0ReferenceForB_ ) VULKAN_HPP_NOEXCEPT + setMaxBitsPerMbDenom( uint32_t maxBitsPerMbDenom_ ) VULKAN_HPP_NOEXCEPT { - maxNumL0ReferenceForB = maxNumL0ReferenceForB_; + maxBitsPerMbDenom = maxBitsPerMbDenom_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & - setMaxNumL1Reference( uint8_t maxNumL1Reference_ ) VULKAN_HPP_NOEXCEPT + setLog2MaxMvLengthHorizontal( uint32_t log2MaxMvLengthHorizontal_ ) VULKAN_HPP_NOEXCEPT { - maxNumL1Reference = maxNumL1Reference_; + log2MaxMvLengthHorizontal = log2MaxMvLengthHorizontal_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & - setQualityLevelCount( uint8_t qualityLevelCount_ ) VULKAN_HPP_NOEXCEPT + setLog2MaxMvLengthVertical( uint32_t log2MaxMvLengthVertical_ ) VULKAN_HPP_NOEXCEPT { - qualityLevelCount = qualityLevelCount_; + log2MaxMvLengthVertical = log2MaxMvLengthVertical_; return *this; } @@ -94738,13 +94624,14 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT const &, VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT const &, VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT const &, - VULKAN_HPP_NAMESPACE::Extent2D const &, - VULKAN_HPP_NAMESPACE::Extent2D const &, - VULKAN_HPP_NAMESPACE::Extent2D const &, - uint8_t const &, uint8_t const &, uint8_t const &, uint8_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, VULKAN_HPP_NAMESPACE::ExtensionProperties const &> # endif reflect() const VULKAN_HPP_NOEXCEPT @@ -94754,13 +94641,14 @@ namespace VULKAN_HPP_NAMESPACE flags, inputModeFlags, outputModeFlags, - minPictureSizeInMbs, - maxPictureSizeInMbs, - inputImageDataAlignment, - maxNumL0ReferenceForP, - maxNumL0ReferenceForB, - maxNumL1Reference, - qualityLevelCount, + maxPPictureL0ReferenceCount, + maxBPictureL0ReferenceCount, + maxL1ReferenceCount, + motionVectorsOverPicBoundariesFlag, + maxBytesPerPicDenom, + maxBitsPerMbDenom, + log2MaxMvLengthHorizontal, + log2MaxMvLengthVertical, stdExtensionVersion ); } # endif @@ -94775,11 +94663,14 @@ namespace VULKAN_HPP_NAMESPACE # else return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) && - ( minPictureSizeInMbs == rhs.minPictureSizeInMbs ) && ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && - ( inputImageDataAlignment == rhs.inputImageDataAlignment ) && - ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) && - ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) && - ( qualityLevelCount == rhs.qualityLevelCount ) && ( stdExtensionVersion == rhs.stdExtensionVersion ); + ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && + ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && + ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && + ( motionVectorsOverPicBoundariesFlag == rhs.motionVectorsOverPicBoundariesFlag ) && + ( maxBytesPerPicDenom == rhs.maxBytesPerPicDenom ) && ( maxBitsPerMbDenom == rhs.maxBitsPerMbDenom ) && + ( log2MaxMvLengthHorizontal == rhs.log2MaxMvLengthHorizontal ) && + ( log2MaxMvLengthVertical == rhs.log2MaxMvLengthVertical ) && + ( stdExtensionVersion == rhs.stdExtensionVersion ); # endif } @@ -94793,16 +94684,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT; const void * pNext = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags = {}; - VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs = {}; - VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs = {}; - VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment = {}; - uint8_t maxNumL0ReferenceForP = {}; - uint8_t maxNumL0ReferenceForB = {}; - uint8_t maxNumL1Reference = {}; - uint8_t qualityLevelCount = {}; - VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags = {}; + uint8_t maxPPictureL0ReferenceCount = {}; + uint8_t maxBPictureL0ReferenceCount = {}; + uint8_t maxL1ReferenceCount = {}; + VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag = {}; + uint32_t maxBytesPerPicDenom = {}; + uint32_t maxBitsPerMbDenom = {}; + uint32_t log2MaxMvLengthHorizontal = {}; + uint32_t log2MaxMvLengthVertical = {}; + VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT ) == sizeof( VkVideoEncodeH264CapabilitiesEXT ), @@ -94829,11 +94721,10 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264DpbSlotInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeH264DpbSlotInfoEXT( int8_t slotIndex_ = {}, - const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {} ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH264DpbSlotInfoEXT( + int8_t slotIndex_ = {}, const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ = {} ) VULKAN_HPP_NOEXCEPT : slotIndex( slotIndex_ ) - , pStdPictureInfo( pStdPictureInfo_ ) + , pStdReferenceInfo( pStdReferenceInfo_ ) {} VULKAN_HPP_CONSTEXPR @@ -94867,9 +94758,9 @@ namespace VULKAN_HPP_NAMESPACE } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoEXT & - setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT + setPStdReferenceInfo( const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ ) VULKAN_HPP_NOEXCEPT { - pStdPictureInfo = pStdPictureInfo_; + pStdReferenceInfo = pStdReferenceInfo_; return *this; } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ @@ -94891,11 +94782,11 @@ namespace VULKAN_HPP_NAMESPACE std::tuple + const StdVideoEncodeH264ReferenceInfo * const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, slotIndex, pStdPictureInfo ); + return std::tie( sType, pNext, slotIndex, pStdReferenceInfo ); } # endif @@ -94908,7 +94799,7 @@ namespace VULKAN_HPP_NAMESPACE return this->reflect() == rhs.reflect(); # else return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && - ( pStdPictureInfo == rhs.pStdPictureInfo ); + ( pStdReferenceInfo == rhs.pStdReferenceInfo ); # endif } @@ -94919,10 +94810,10 @@ namespace VULKAN_HPP_NAMESPACE # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264DpbSlotInfoEXT; - const void * pNext = {}; - int8_t slotIndex = {}; - const StdVideoEncodeH264PictureInfo * pStdPictureInfo = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264DpbSlotInfoEXT; + const void * pNext = {}; + int8_t slotIndex = {}; + const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT ) == sizeof( VkVideoEncodeH264DpbSlotInfoEXT ), @@ -95215,6 +95106,207 @@ namespace VULKAN_HPP_NAMESPACE "VideoEncodeH264FrameSizeEXT is not nothrow_move_constructible!" ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH264ReferenceListsEXT + { + using NativeType = VkVideoEncodeH264ReferenceListsEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264ReferenceListsEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264ReferenceListsEXT( + uint8_t referenceList0EntryCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pReferenceList0Entries_ = {}, + uint8_t referenceList1EntryCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pReferenceList1Entries_ = {}, + const StdVideoEncodeH264RefMemMgmtCtrlOperations * pMemMgmtCtrlOperations_ = {} ) VULKAN_HPP_NOEXCEPT + : referenceList0EntryCount( referenceList0EntryCount_ ) + , pReferenceList0Entries( pReferenceList0Entries_ ) + , referenceList1EntryCount( referenceList1EntryCount_ ) + , pReferenceList1Entries( pReferenceList1Entries_ ) + , pMemMgmtCtrlOperations( pMemMgmtCtrlOperations_ ) + {} + + VULKAN_HPP_CONSTEXPR + VideoEncodeH264ReferenceListsEXT( VideoEncodeH264ReferenceListsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264ReferenceListsEXT( VkVideoEncodeH264ReferenceListsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264ReferenceListsEXT( *reinterpret_cast( &rhs ) ) + {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264ReferenceListsEXT( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + referenceList0Entries_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + referenceList1Entries_ = {}, + const StdVideoEncodeH264RefMemMgmtCtrlOperations * pMemMgmtCtrlOperations_ = {} ) + : referenceList0EntryCount( static_cast( referenceList0Entries_.size() ) ) + , pReferenceList0Entries( referenceList0Entries_.data() ) + , referenceList1EntryCount( static_cast( referenceList1Entries_.size() ) ) + , pReferenceList1Entries( referenceList1Entries_.data() ) + , pMemMgmtCtrlOperations( pMemMgmtCtrlOperations_ ) + {} +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH264ReferenceListsEXT & + operator=( VideoEncodeH264ReferenceListsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264ReferenceListsEXT & operator=( VkVideoEncodeH264ReferenceListsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ReferenceListsEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ReferenceListsEXT & + setReferenceList0EntryCount( uint8_t referenceList0EntryCount_ ) VULKAN_HPP_NOEXCEPT + { + referenceList0EntryCount = referenceList0EntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ReferenceListsEXT & setPReferenceList0Entries( + const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pReferenceList0Entries_ ) VULKAN_HPP_NOEXCEPT + { + pReferenceList0Entries = pReferenceList0Entries_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264ReferenceListsEXT & setReferenceList0Entries( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + referenceList0Entries_ ) VULKAN_HPP_NOEXCEPT + { + referenceList0EntryCount = static_cast( referenceList0Entries_.size() ); + pReferenceList0Entries = referenceList0Entries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ReferenceListsEXT & + setReferenceList1EntryCount( uint8_t referenceList1EntryCount_ ) VULKAN_HPP_NOEXCEPT + { + referenceList1EntryCount = referenceList1EntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ReferenceListsEXT & setPReferenceList1Entries( + const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pReferenceList1Entries_ ) VULKAN_HPP_NOEXCEPT + { + pReferenceList1Entries = pReferenceList1Entries_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264ReferenceListsEXT & setReferenceList1Entries( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & + referenceList1Entries_ ) VULKAN_HPP_NOEXCEPT + { + referenceList1EntryCount = static_cast( referenceList1Entries_.size() ); + pReferenceList1Entries = referenceList1Entries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ReferenceListsEXT & setPMemMgmtCtrlOperations( + const StdVideoEncodeH264RefMemMgmtCtrlOperations * pMemMgmtCtrlOperations_ ) VULKAN_HPP_NOEXCEPT + { + pMemMgmtCtrlOperations = pMemMgmtCtrlOperations_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + explicit operator VkVideoEncodeH264ReferenceListsEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + explicit operator VkVideoEncodeH264ReferenceListsEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + referenceList0EntryCount, + pReferenceList0Entries, + referenceList1EntryCount, + pReferenceList1Entries, + pMemMgmtCtrlOperations ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264ReferenceListsEXT const & ) const = default; +# else + bool operator==( VideoEncodeH264ReferenceListsEXT 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 ) && + ( referenceList0EntryCount == rhs.referenceList0EntryCount ) && + ( pReferenceList0Entries == rhs.pReferenceList0Entries ) && + ( referenceList1EntryCount == rhs.referenceList1EntryCount ) && + ( pReferenceList1Entries == rhs.pReferenceList1Entries ) && + ( pMemMgmtCtrlOperations == rhs.pMemMgmtCtrlOperations ); +# endif + } + + bool operator!=( VideoEncodeH264ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264ReferenceListsEXT; + const void * pNext = {}; + uint8_t referenceList0EntryCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pReferenceList0Entries = {}; + uint8_t referenceList1EntryCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pReferenceList1Entries = {}; + const StdVideoEncodeH264RefMemMgmtCtrlOperations * pMemMgmtCtrlOperations = {}; + }; + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT ) == + sizeof( VkVideoEncodeH264ReferenceListsEXT ), + "struct and wrapper have different size!" ); + VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); + VULKAN_HPP_STATIC_ASSERT( + std::is_nothrow_move_constructible::value, + "VideoEncodeH264ReferenceListsEXT is not nothrow_move_constructible!" ); + + template <> + struct CppType + { + using Type = VideoEncodeH264ReferenceListsEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + #if defined( VK_ENABLE_BETA_EXTENSIONS ) struct VideoEncodeH264NaluSliceEXT { @@ -95225,18 +95317,12 @@ namespace VULKAN_HPP_NAMESPACE # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceEXT( - const StdVideoEncodeH264SliceHeader * pSliceHeaderStd_ = {}, - uint32_t mbCount_ = {}, - uint8_t refFinalList0EntryCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefFinalList0Entries_ = {}, - uint8_t refFinalList1EntryCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefFinalList1Entries_ = {} ) VULKAN_HPP_NOEXCEPT - : pSliceHeaderStd( pSliceHeaderStd_ ) - , mbCount( mbCount_ ) - , refFinalList0EntryCount( refFinalList0EntryCount_ ) - , pRefFinalList0Entries( pRefFinalList0Entries_ ) - , refFinalList1EntryCount( refFinalList1EntryCount_ ) - , pRefFinalList1Entries( pRefFinalList1Entries_ ) + uint32_t mbCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * pReferenceFinalLists_ = {}, + const StdVideoEncodeH264SliceHeader * pSliceHeaderStd_ = {} ) VULKAN_HPP_NOEXCEPT + : mbCount( mbCount_ ) + , pReferenceFinalLists( pReferenceFinalLists_ ) + , pSliceHeaderStd( pSliceHeaderStd_ ) {} VULKAN_HPP_CONSTEXPR @@ -95245,24 +95331,7 @@ namespace VULKAN_HPP_NAMESPACE VideoEncodeH264NaluSliceEXT( VkVideoEncodeH264NaluSliceEXT const & rhs ) VULKAN_HPP_NOEXCEPT : VideoEncodeH264NaluSliceEXT( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264NaluSliceEXT( - const StdVideoEncodeH264SliceHeader * pSliceHeaderStd_, - uint32_t mbCount_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refFinalList0Entries_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refFinalList1Entries_ = {} ) - : pSliceHeaderStd( pSliceHeaderStd_ ) - , mbCount( mbCount_ ) - , refFinalList0EntryCount( static_cast( refFinalList0Entries_.size() ) ) - , pRefFinalList0Entries( refFinalList0Entries_.data() ) - , refFinalList1EntryCount( static_cast( refFinalList1Entries_.size() ) ) - , pRefFinalList1Entries( refFinalList1Entries_.data() ) - {} -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ VideoEncodeH264NaluSliceEXT & operator=( VideoEncodeH264NaluSliceEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; @@ -95279,69 +95348,26 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceEXT & - setPSliceHeaderStd( const StdVideoEncodeH264SliceHeader * pSliceHeaderStd_ ) VULKAN_HPP_NOEXCEPT - { - pSliceHeaderStd = pSliceHeaderStd_; - return *this; - } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceEXT & setMbCount( uint32_t mbCount_ ) VULKAN_HPP_NOEXCEPT { mbCount = mbCount_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceEXT & - setRefFinalList0EntryCount( uint8_t refFinalList0EntryCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceEXT & setPReferenceFinalLists( + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * pReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT { - refFinalList0EntryCount = refFinalList0EntryCount_; + pReferenceFinalLists = pReferenceFinalLists_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceEXT & setPRefFinalList0Entries( - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefFinalList0Entries_ ) VULKAN_HPP_NOEXCEPT - { - pRefFinalList0Entries = pRefFinalList0Entries_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264NaluSliceEXT & setRefFinalList0Entries( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refFinalList0Entries_ ) VULKAN_HPP_NOEXCEPT - { - refFinalList0EntryCount = static_cast( refFinalList0Entries_.size() ); - pRefFinalList0Entries = refFinalList0Entries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceEXT & - setRefFinalList1EntryCount( uint8_t refFinalList1EntryCount_ ) VULKAN_HPP_NOEXCEPT + setPSliceHeaderStd( const StdVideoEncodeH264SliceHeader * pSliceHeaderStd_ ) VULKAN_HPP_NOEXCEPT { - refFinalList1EntryCount = refFinalList1EntryCount_; + pSliceHeaderStd = pSliceHeaderStd_; return *this; } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceEXT & setPRefFinalList1Entries( - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefFinalList1Entries_ ) VULKAN_HPP_NOEXCEPT - { - pRefFinalList1Entries = pRefFinalList1Entries_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264NaluSliceEXT & setRefFinalList1Entries( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refFinalList1Entries_ ) VULKAN_HPP_NOEXCEPT - { - refFinalList1EntryCount = static_cast( refFinalList1Entries_.size() ); - pRefFinalList1Entries = refFinalList1Entries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ explicit operator VkVideoEncodeH264NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT { @@ -95359,23 +95385,13 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuple + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * const &, + const StdVideoEncodeH264SliceHeader * const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, - pNext, - pSliceHeaderStd, - mbCount, - refFinalList0EntryCount, - pRefFinalList0Entries, - refFinalList1EntryCount, - pRefFinalList1Entries ); + return std::tie( sType, pNext, mbCount, pReferenceFinalLists, pSliceHeaderStd ); } # endif @@ -95387,11 +95403,8 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ) && - ( mbCount == rhs.mbCount ) && ( refFinalList0EntryCount == rhs.refFinalList0EntryCount ) && - ( pRefFinalList0Entries == rhs.pRefFinalList0Entries ) && - ( refFinalList1EntryCount == rhs.refFinalList1EntryCount ) && - ( pRefFinalList1Entries == rhs.pRefFinalList1Entries ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mbCount == rhs.mbCount ) && + ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ); # endif } @@ -95402,14 +95415,11 @@ namespace VULKAN_HPP_NAMESPACE # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264NaluSliceEXT; - const void * pNext = {}; - const StdVideoEncodeH264SliceHeader * pSliceHeaderStd = {}; - uint32_t mbCount = {}; - uint8_t refFinalList0EntryCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefFinalList0Entries = {}; - uint8_t refFinalList1EntryCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefFinalList1Entries = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264NaluSliceEXT; + const void * pNext = {}; + uint32_t mbCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * pReferenceFinalLists = {}; + const StdVideoEncodeH264SliceHeader * pSliceHeaderStd = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT ) == sizeof( VkVideoEncodeH264NaluSliceEXT ), @@ -96477,17 +96487,11 @@ namespace VULKAN_HPP_NAMESPACE # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) VULKAN_HPP_CONSTEXPR VideoEncodeH264VclFrameInfoEXT( - uint8_t refDefaultFinalList0EntryCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefDefaultFinalList0Entries_ = {}, - uint8_t refDefaultFinalList1EntryCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefDefaultFinalList1Entries_ = {}, - uint32_t naluSliceEntryCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT * pNaluSliceEntries_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pCurrentPictureInfo_ = {} ) VULKAN_HPP_NOEXCEPT - : refDefaultFinalList0EntryCount( refDefaultFinalList0EntryCount_ ) - , pRefDefaultFinalList0Entries( pRefDefaultFinalList0Entries_ ) - , refDefaultFinalList1EntryCount( refDefaultFinalList1EntryCount_ ) - , pRefDefaultFinalList1Entries( pRefDefaultFinalList1Entries_ ) + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * pReferenceFinalLists_ = {}, + uint32_t naluSliceEntryCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT * pNaluSliceEntries_ = {}, + const StdVideoEncodeH264PictureInfo * pCurrentPictureInfo_ = {} ) VULKAN_HPP_NOEXCEPT + : pReferenceFinalLists( pReferenceFinalLists_ ) , naluSliceEntryCount( naluSliceEntryCount_ ) , pNaluSliceEntries( pNaluSliceEntries_ ) , pCurrentPictureInfo( pCurrentPictureInfo_ ) @@ -96502,17 +96506,11 @@ namespace VULKAN_HPP_NAMESPACE # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) VideoEncodeH264VclFrameInfoEXT( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refDefaultFinalList0Entries_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refDefaultFinalList1Entries_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * pReferenceFinalLists_, VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - naluSliceEntries_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pCurrentPictureInfo_ = {} ) - : refDefaultFinalList0EntryCount( static_cast( refDefaultFinalList0Entries_.size() ) ) - , pRefDefaultFinalList0Entries( refDefaultFinalList0Entries_.data() ) - , refDefaultFinalList1EntryCount( static_cast( refDefaultFinalList1Entries_.size() ) ) - , pRefDefaultFinalList1Entries( refDefaultFinalList1Entries_.data() ) + naluSliceEntries_, + const StdVideoEncodeH264PictureInfo * pCurrentPictureInfo_ = {} ) + : pReferenceFinalLists( pReferenceFinalLists_ ) , naluSliceEntryCount( static_cast( naluSliceEntries_.size() ) ) , pNaluSliceEntries( naluSliceEntries_.data() ) , pCurrentPictureInfo( pCurrentPictureInfo_ ) @@ -96536,56 +96534,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & - setRefDefaultFinalList0EntryCount( uint8_t refDefaultFinalList0EntryCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPReferenceFinalLists( + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * pReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT { - refDefaultFinalList0EntryCount = refDefaultFinalList0EntryCount_; + pReferenceFinalLists = pReferenceFinalLists_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPRefDefaultFinalList0Entries( - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefDefaultFinalList0Entries_ ) VULKAN_HPP_NOEXCEPT - { - pRefDefaultFinalList0Entries = pRefDefaultFinalList0Entries_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264VclFrameInfoEXT & setRefDefaultFinalList0Entries( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refDefaultFinalList0Entries_ ) VULKAN_HPP_NOEXCEPT - { - refDefaultFinalList0EntryCount = static_cast( refDefaultFinalList0Entries_.size() ); - pRefDefaultFinalList0Entries = refDefaultFinalList0Entries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & - setRefDefaultFinalList1EntryCount( uint8_t refDefaultFinalList1EntryCount_ ) VULKAN_HPP_NOEXCEPT - { - refDefaultFinalList1EntryCount = refDefaultFinalList1EntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPRefDefaultFinalList1Entries( - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefDefaultFinalList1Entries_ ) VULKAN_HPP_NOEXCEPT - { - pRefDefaultFinalList1Entries = pRefDefaultFinalList1Entries_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264VclFrameInfoEXT & setRefDefaultFinalList1Entries( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & - refDefaultFinalList1Entries_ ) VULKAN_HPP_NOEXCEPT - { - refDefaultFinalList1EntryCount = static_cast( refDefaultFinalList1Entries_.size() ); - pRefDefaultFinalList1Entries = refDefaultFinalList1Entries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) VULKAN_HPP_NOEXCEPT { @@ -96611,8 +96566,8 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPCurrentPictureInfo( - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pCurrentPictureInfo_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & + setPCurrentPictureInfo( const StdVideoEncodeH264PictureInfo * pCurrentPictureInfo_ ) VULKAN_HPP_NOEXCEPT { pCurrentPictureInfo = pCurrentPictureInfo_; return *this; @@ -96635,25 +96590,15 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuple + const StdVideoEncodeH264PictureInfo * const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, - pNext, - refDefaultFinalList0EntryCount, - pRefDefaultFinalList0Entries, - refDefaultFinalList1EntryCount, - pRefDefaultFinalList1Entries, - naluSliceEntryCount, - pNaluSliceEntries, - pCurrentPictureInfo ); + return std::tie( + sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo ); } # endif @@ -96665,11 +96610,7 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( refDefaultFinalList0EntryCount == rhs.refDefaultFinalList0EntryCount ) && - ( pRefDefaultFinalList0Entries == rhs.pRefDefaultFinalList0Entries ) && - ( refDefaultFinalList1EntryCount == rhs.refDefaultFinalList1EntryCount ) && - ( pRefDefaultFinalList1Entries == rhs.pRefDefaultFinalList1Entries ) && + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && ( pCurrentPictureInfo == rhs.pCurrentPictureInfo ); # endif @@ -96682,15 +96623,12 @@ namespace VULKAN_HPP_NAMESPACE # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264VclFrameInfoEXT; - const void * pNext = {}; - uint8_t refDefaultFinalList0EntryCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefDefaultFinalList0Entries = {}; - uint8_t refDefaultFinalList1EntryCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pRefDefaultFinalList1Entries = {}; - uint32_t naluSliceEntryCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT * pNaluSliceEntries = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * pCurrentPictureInfo = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264VclFrameInfoEXT; + const void * pNext = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT * pReferenceFinalLists = {}; + uint32_t naluSliceEntryCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT * pNaluSliceEntries = {}; + const StdVideoEncodeH264PictureInfo * pCurrentPictureInfo = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT ) == sizeof( VkVideoEncodeH264VclFrameInfoEXT ), @@ -96718,27 +96656,47 @@ namespace VULKAN_HPP_NAMESPACE # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT( - VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT inputModeFlags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT outputModeFlags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes_ = {}, - VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment_ = {}, - uint8_t maxNumL0ReferenceForP_ = {}, - uint8_t maxNumL0ReferenceForB_ = {}, - uint8_t maxNumL1Reference_ = {}, - uint8_t maxNumSubLayers_ = {}, - uint8_t qualityLevelCount_ = {}, - VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT inputModeFlags_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT outputModeFlags_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes_ = {}, + uint8_t maxPPictureL0ReferenceCount_ = {}, + uint8_t maxBPictureL0ReferenceCount_ = {}, + uint8_t maxL1ReferenceCount_ = {}, + uint8_t maxSubLayersCount_ = {}, + uint8_t minLog2MinLumaCodingBlockSizeMinus3_ = {}, + uint8_t maxLog2MinLumaCodingBlockSizeMinus3_ = {}, + uint8_t minLog2MinLumaTransformBlockSizeMinus2_ = {}, + uint8_t maxLog2MinLumaTransformBlockSizeMinus2_ = {}, + uint8_t minMaxTransformHierarchyDepthInter_ = {}, + uint8_t maxMaxTransformHierarchyDepthInter_ = {}, + uint8_t minMaxTransformHierarchyDepthIntra_ = {}, + uint8_t maxMaxTransformHierarchyDepthIntra_ = {}, + uint8_t maxDiffCuQpDeltaDepth_ = {}, + uint8_t minMaxNumMergeCand_ = {}, + uint8_t maxMaxNumMergeCand_ = {}, + VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) , inputModeFlags( inputModeFlags_ ) , outputModeFlags( outputModeFlags_ ) , ctbSizes( ctbSizes_ ) - , inputImageDataAlignment( inputImageDataAlignment_ ) - , maxNumL0ReferenceForP( maxNumL0ReferenceForP_ ) - , maxNumL0ReferenceForB( maxNumL0ReferenceForB_ ) - , maxNumL1Reference( maxNumL1Reference_ ) - , maxNumSubLayers( maxNumSubLayers_ ) - , qualityLevelCount( qualityLevelCount_ ) + , 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_ ) , stdExtensionVersion( stdExtensionVersion_ ) {} @@ -96794,45 +96752,115 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & - setInputImageDataAlignment( VULKAN_HPP_NAMESPACE::Extent2D const & inputImageDataAlignment_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setTransformBlockSizes( + VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes_ ) VULKAN_HPP_NOEXCEPT { - inputImageDataAlignment = inputImageDataAlignment_; + transformBlockSizes = transformBlockSizes_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & - setMaxNumL0ReferenceForP( uint8_t maxNumL0ReferenceForP_ ) VULKAN_HPP_NOEXCEPT + setMaxPPictureL0ReferenceCount( uint8_t maxPPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT { - maxNumL0ReferenceForP = maxNumL0ReferenceForP_; + maxPPictureL0ReferenceCount = maxPPictureL0ReferenceCount_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & - setMaxNumL0ReferenceForB( uint8_t maxNumL0ReferenceForB_ ) VULKAN_HPP_NOEXCEPT + setMaxBPictureL0ReferenceCount( uint8_t maxBPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT { - maxNumL0ReferenceForB = maxNumL0ReferenceForB_; + maxBPictureL0ReferenceCount = maxBPictureL0ReferenceCount_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & - setMaxNumL1Reference( uint8_t maxNumL1Reference_ ) VULKAN_HPP_NOEXCEPT + setMaxL1ReferenceCount( uint8_t maxL1ReferenceCount_ ) VULKAN_HPP_NOEXCEPT { - maxNumL1Reference = maxNumL1Reference_; + maxL1ReferenceCount = maxL1ReferenceCount_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & - setMaxNumSubLayers( uint8_t maxNumSubLayers_ ) VULKAN_HPP_NOEXCEPT + setMaxSubLayersCount( uint8_t maxSubLayersCount_ ) VULKAN_HPP_NOEXCEPT { - maxNumSubLayers = maxNumSubLayers_; + maxSubLayersCount = maxSubLayersCount_; return *this; } VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & - setQualityLevelCount( uint8_t qualityLevelCount_ ) VULKAN_HPP_NOEXCEPT + setMinLog2MinLumaCodingBlockSizeMinus3( uint8_t minLog2MinLumaCodingBlockSizeMinus3_ ) VULKAN_HPP_NOEXCEPT { - qualityLevelCount = qualityLevelCount_; + minLog2MinLumaCodingBlockSizeMinus3 = minLog2MinLumaCodingBlockSizeMinus3_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMaxLog2MinLumaCodingBlockSizeMinus3( uint8_t maxLog2MinLumaCodingBlockSizeMinus3_ ) VULKAN_HPP_NOEXCEPT + { + maxLog2MinLumaCodingBlockSizeMinus3 = maxLog2MinLumaCodingBlockSizeMinus3_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMinLog2MinLumaTransformBlockSizeMinus2( uint8_t minLog2MinLumaTransformBlockSizeMinus2_ ) VULKAN_HPP_NOEXCEPT + { + minLog2MinLumaTransformBlockSizeMinus2 = minLog2MinLumaTransformBlockSizeMinus2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMaxLog2MinLumaTransformBlockSizeMinus2( uint8_t maxLog2MinLumaTransformBlockSizeMinus2_ ) VULKAN_HPP_NOEXCEPT + { + maxLog2MinLumaTransformBlockSizeMinus2 = maxLog2MinLumaTransformBlockSizeMinus2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMinMaxTransformHierarchyDepthInter( uint8_t minMaxTransformHierarchyDepthInter_ ) VULKAN_HPP_NOEXCEPT + { + minMaxTransformHierarchyDepthInter = minMaxTransformHierarchyDepthInter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMaxMaxTransformHierarchyDepthInter( uint8_t maxMaxTransformHierarchyDepthInter_ ) VULKAN_HPP_NOEXCEPT + { + maxMaxTransformHierarchyDepthInter = maxMaxTransformHierarchyDepthInter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMinMaxTransformHierarchyDepthIntra( uint8_t minMaxTransformHierarchyDepthIntra_ ) VULKAN_HPP_NOEXCEPT + { + minMaxTransformHierarchyDepthIntra = minMaxTransformHierarchyDepthIntra_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMaxMaxTransformHierarchyDepthIntra( uint8_t maxMaxTransformHierarchyDepthIntra_ ) VULKAN_HPP_NOEXCEPT + { + maxMaxTransformHierarchyDepthIntra = maxMaxTransformHierarchyDepthIntra_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMaxDiffCuQpDeltaDepth( uint8_t maxDiffCuQpDeltaDepth_ ) VULKAN_HPP_NOEXCEPT + { + maxDiffCuQpDeltaDepth = maxDiffCuQpDeltaDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMinMaxNumMergeCand( uint8_t minMaxNumMergeCand_ ) VULKAN_HPP_NOEXCEPT + { + minMaxNumMergeCand = minMaxNumMergeCand_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & + setMaxMaxNumMergeCand( uint8_t maxMaxNumMergeCand_ ) VULKAN_HPP_NOEXCEPT + { + maxMaxNumMergeCand = maxMaxNumMergeCand_; return *this; } @@ -96864,7 +96892,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT const &, VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT const &, VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT const &, - VULKAN_HPP_NAMESPACE::Extent2D const &, + VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, + uint8_t const &, uint8_t const &, uint8_t const &, uint8_t const &, @@ -96880,12 +96918,22 @@ namespace VULKAN_HPP_NAMESPACE inputModeFlags, outputModeFlags, ctbSizes, - inputImageDataAlignment, - maxNumL0ReferenceForP, - maxNumL0ReferenceForB, - maxNumL1Reference, - maxNumSubLayers, - qualityLevelCount, + transformBlockSizes, + maxPPictureL0ReferenceCount, + maxBPictureL0ReferenceCount, + maxL1ReferenceCount, + maxSubLayersCount, + minLog2MinLumaCodingBlockSizeMinus3, + maxLog2MinLumaCodingBlockSizeMinus3, + minLog2MinLumaTransformBlockSizeMinus2, + maxLog2MinLumaTransformBlockSizeMinus2, + minMaxTransformHierarchyDepthInter, + maxMaxTransformHierarchyDepthInter, + minMaxTransformHierarchyDepthIntra, + maxMaxTransformHierarchyDepthIntra, + maxDiffCuQpDeltaDepth, + minMaxNumMergeCand, + maxMaxNumMergeCand, stdExtensionVersion ); } # endif @@ -96900,10 +96948,20 @@ namespace VULKAN_HPP_NAMESPACE # else return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) && - ( ctbSizes == rhs.ctbSizes ) && ( inputImageDataAlignment == rhs.inputImageDataAlignment ) && - ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) && - ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) && - ( maxNumSubLayers == rhs.maxNumSubLayers ) && ( qualityLevelCount == rhs.qualityLevelCount ) && + ( 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 ) && ( stdExtensionVersion == rhs.stdExtensionVersion ); # endif } @@ -96918,16 +96976,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265CapabilitiesEXT; const void * pNext = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT inputModeFlags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT outputModeFlags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes = {}; - VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment = {}; - uint8_t maxNumL0ReferenceForP = {}; - uint8_t maxNumL0ReferenceForB = {}; - uint8_t maxNumL1Reference = {}; - uint8_t maxNumSubLayers = {}; - uint8_t qualityLevelCount = {}; - VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT inputModeFlags = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT outputModeFlags = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes = {}; + uint8_t maxPPictureL0ReferenceCount = {}; + uint8_t maxBPictureL0ReferenceCount = {}; + uint8_t maxL1ReferenceCount = {}; + uint8_t maxSubLayersCount = {}; + uint8_t minLog2MinLumaCodingBlockSizeMinus3 = {}; + uint8_t maxLog2MinLumaCodingBlockSizeMinus3 = {}; + uint8_t minLog2MinLumaTransformBlockSizeMinus2 = {}; + uint8_t maxLog2MinLumaTransformBlockSizeMinus2 = {}; + uint8_t minMaxTransformHierarchyDepthInter = {}; + uint8_t maxMaxTransformHierarchyDepthInter = {}; + uint8_t minMaxTransformHierarchyDepthIntra = {}; + uint8_t maxMaxTransformHierarchyDepthIntra = {}; + uint8_t maxDiffCuQpDeltaDepth = {}; + uint8_t minMaxNumMergeCand = {}; + uint8_t maxMaxNumMergeCand = {}; + VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT ) == sizeof( VkVideoEncodeH265CapabilitiesEXT ),