mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Update Vulkan-Headers to v1.3.206

Browse Source
This commit is contained in:
GitHub 2022-02-19 00:07:27 +00:00
parent 5de7d1d341
commit 47520a1025
6 changed files with 1165 additions and 677 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit b32da5329b50e3cb96229aaecba9ded032fe29cc Subproject commit aa18f182ebba65438b1cfdbd571f020bb2e34d04

14
vulkan/vulkan.hpp
View File

@ -119,7 +119,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span> # include <span>
#endif #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. // 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 // 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 ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h264 === //=== VK_EXT_video_encode_h264 ===
template <> template <>
struct StructExtends<VideoEncodeH264CapabilitiesEXT, VideoCapabilitiesKHR> struct StructExtends<VideoEncodeH264CapabilitiesEXT, VideoEncodeCapabilitiesKHR>
{ {
enum enum
{ {
@ -8321,7 +8321,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h265 === //=== VK_EXT_video_encode_h265 ===
template <> template <>
struct StructExtends<VideoEncodeH265CapabilitiesEXT, VideoCapabilitiesKHR> struct StructExtends<VideoEncodeH265CapabilitiesEXT, VideoEncodeCapabilitiesKHR>
{ {
enum enum
{ {
@ -10599,6 +10599,14 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_encode_queue === //=== VK_KHR_video_encode_queue ===
template <> template <>
struct StructExtends<VideoEncodeCapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR> struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR>
{ {
enum enum

447
vulkan/vulkan_enums.hpp
View File

@ -442,6 +442,7 @@ namespace VULKAN_HPP_NAMESPACE
eVideoEncodeH264ProfileEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT, eVideoEncodeH264ProfileEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT,
eVideoEncodeH264RateControlInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT, eVideoEncodeH264RateControlInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT,
eVideoEncodeH264RateControlLayerInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_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, eVideoEncodeH265CapabilitiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT,
eVideoEncodeH265SessionCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT, eVideoEncodeH265SessionCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT,
eVideoEncodeH265SessionParametersCreateInfoEXT = eVideoEncodeH265SessionParametersCreateInfoEXT =
@ -815,6 +816,7 @@ namespace VULKAN_HPP_NAMESPACE
eVideoEncodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR, eVideoEncodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR,
eVideoEncodeRateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR, eVideoEncodeRateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
eVideoEncodeRateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_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*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
eDeviceDiagnosticsConfigCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_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::eVideoEncodeH264ProfileEXT: return "VideoEncodeH264ProfileEXT";
case StructureType::eVideoEncodeH264RateControlInfoEXT: return "VideoEncodeH264RateControlInfoEXT"; case StructureType::eVideoEncodeH264RateControlInfoEXT: return "VideoEncodeH264RateControlInfoEXT";
case StructureType::eVideoEncodeH264RateControlLayerInfoEXT: return "VideoEncodeH264RateControlLayerInfoEXT"; case StructureType::eVideoEncodeH264RateControlLayerInfoEXT: return "VideoEncodeH264RateControlLayerInfoEXT";
case StructureType::eVideoEncodeH264ReferenceListsEXT: return "VideoEncodeH264ReferenceListsEXT";
case StructureType::eVideoEncodeH265CapabilitiesEXT: return "VideoEncodeH265CapabilitiesEXT"; case StructureType::eVideoEncodeH265CapabilitiesEXT: return "VideoEncodeH265CapabilitiesEXT";
case StructureType::eVideoEncodeH265SessionCreateInfoEXT: return "VideoEncodeH265SessionCreateInfoEXT"; case StructureType::eVideoEncodeH265SessionCreateInfoEXT: return "VideoEncodeH265SessionCreateInfoEXT";
case StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT: case StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT:
@ -1855,6 +1858,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eVideoEncodeInfoKHR: return "VideoEncodeInfoKHR"; case StructureType::eVideoEncodeInfoKHR: return "VideoEncodeInfoKHR";
case StructureType::eVideoEncodeRateControlInfoKHR: return "VideoEncodeRateControlInfoKHR"; case StructureType::eVideoEncodeRateControlInfoKHR: return "VideoEncodeRateControlInfoKHR";
case StructureType::eVideoEncodeRateControlLayerInfoKHR: return "VideoEncodeRateControlLayerInfoKHR"; case StructureType::eVideoEncodeRateControlLayerInfoKHR: return "VideoEncodeRateControlLayerInfoKHR";
case StructureType::eVideoEncodeCapabilitiesKHR: return "VideoEncodeCapabilitiesKHR";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV: case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV:
return "PhysicalDeviceDiagnosticsConfigFeaturesNV"; return "PhysicalDeviceDiagnosticsConfigFeaturesNV";
@ -6513,34 +6517,58 @@ namespace VULKAN_HPP_NAMESPACE
enum class VideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT enum class VideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT
{ {
eCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT, eDirect8X8Inference = VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_BIT_EXT,
eCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT, eSeparateColourPlane = VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT,
eWeightedBiPredImplicit = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT, eQpprimeYZeroTransformBypass = VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT,
eTransform8X8 = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_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, eChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT,
eSecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_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, eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT, eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_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, eMultipleSlicePerFrame = VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT,
eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_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 ) VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagBitsEXT value )
{ {
switch ( value ) switch ( value )
{ {
case VideoEncodeH264CapabilityFlagBitsEXT::eCabac: return "Cabac"; case VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8Inference: return "Direct8X8Inference";
case VideoEncodeH264CapabilityFlagBitsEXT::eCavlc: return "Cavlc"; case VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane: return "SeparateColourPlane";
case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit: return "WeightedBiPredImplicit"; case VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass: return "QpprimeYZeroTransformBypass";
case VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8: return "Transform8X8"; case VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists: return "ScalingLists";
case VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance: return "HrdCompliance";
case VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset: return "ChromaQpOffset"; case VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset: return "ChromaQpOffset";
case VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset: return "SecondChromaQpOffset"; 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::eDeblockingFilterDisabled: return "DeblockingFilterDisabled";
case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled"; case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled";
case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial"; case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial";
case VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred: return "DisableDirectSpatialMvPred";
case VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame: return "MultipleSlicePerFrame"; 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<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@ -6619,6 +6647,68 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h265 === //=== 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<uint32_t>( value ) ) + " )";
}
}
enum class VideoEncodeH265InputModeFlagBitsEXT : VkVideoEncodeH265InputModeFlagsEXT enum class VideoEncodeH265InputModeFlagBitsEXT : VkVideoEncodeH265InputModeFlagsEXT
{ {
eFrame = VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT, eFrame = VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT,
@ -6657,7 +6747,6 @@ namespace VULKAN_HPP_NAMESPACE
enum class VideoEncodeH265CtbSizeFlagBitsEXT : VkVideoEncodeH265CtbSizeFlagsEXT enum class VideoEncodeH265CtbSizeFlagBitsEXT : VkVideoEncodeH265CtbSizeFlagsEXT
{ {
e8 = VK_VIDEO_ENCODE_H265_CTB_SIZE_8_BIT_EXT,
e16 = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT, e16 = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT,
e32 = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT, e32 = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT,
e64 = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT e64 = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT
@ -6667,7 +6756,6 @@ namespace VULKAN_HPP_NAMESPACE
{ {
switch ( value ) switch ( value )
{ {
case VideoEncodeH265CtbSizeFlagBitsEXT::e8: return "8";
case VideoEncodeH265CtbSizeFlagBitsEXT::e16: return "16"; case VideoEncodeH265CtbSizeFlagBitsEXT::e16: return "16";
case VideoEncodeH265CtbSizeFlagBitsEXT::e32: return "32"; case VideoEncodeH265CtbSizeFlagBitsEXT::e32: return "32";
case VideoEncodeH265CtbSizeFlagBitsEXT::e64: return "64"; 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<uint32_t>( value ) ) + " )";
}
}
enum class VideoEncodeH265RateControlStructureFlagBitsEXT : VkVideoEncodeH265RateControlStructureFlagsEXT enum class VideoEncodeH265RateControlStructureFlagBitsEXT : VkVideoEncodeH265RateControlStructureFlagsEXT
{ {
eUnknown = VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT, 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 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<uint32_t>( value ) ) + " )";
}
}
enum class VideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR enum class VideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR
{ {
eDefault = VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR, eDefault = VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR,
@ -20993,17 +21108,29 @@ namespace VULKAN_HPP_NAMESPACE
{ {
enum : VkFlags enum : VkFlags
{ {
allFlags = VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) | allFlags = VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8Inference ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) | 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::eDeblockingFilterDisabled ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice ) |
VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType )
}; };
}; };
@ -21037,28 +21164,52 @@ namespace VULKAN_HPP_NAMESPACE
return "{}"; return "{}";
std::string result; std::string result;
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8Inference )
result += "Cabac | "; result += "Direct8X8Inference | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane )
result += "Cavlc | "; result += "SeparateColourPlane | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass )
result += "WeightedBiPredImplicit | "; result += "QpprimeYZeroTransformBypass | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists )
result += "Transform8X8 | "; result += "ScalingLists | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance )
result += "HrdCompliance | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset )
result += "ChromaQpOffset | "; result += "ChromaQpOffset | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset )
result += "SecondChromaQpOffset | "; 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 ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled )
result += "DeblockingFilterDisabled | "; result += "DeblockingFilterDisabled | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled )
result += "DeblockingFilterEnabled | "; result += "DeblockingFilterEnabled | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial )
result += "DeblockingFilterPartial | "; result += "DeblockingFilterPartial | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred )
result += "DisableDirectSpatialMvPred | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame )
result += "MultipleSlicePerFrame | "; result += "MultipleSlicePerFrame | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount )
result += "EvenlyDistributedSliceSize | "; result += "SliceMbCount | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice )
result += "RowUnalignedSlice | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType )
result += "DifferentSliceType | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@ -21277,9 +21428,118 @@ namespace VULKAN_HPP_NAMESPACE
using VideoEncodeH265CapabilityFlagsEXT = Flags<VideoEncodeH265CapabilityFlagBitsEXT>; using VideoEncodeH265CapabilityFlagsEXT = Flags<VideoEncodeH265CapabilityFlagBitsEXT>;
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsEXT ) template <>
struct FlagTraits<VideoEncodeH265CapabilityFlagBitsEXT>
{ {
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 "{}"; 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<VideoEncodeH265InputModeFlagBitsEXT>; using VideoEncodeH265InputModeFlagsEXT = Flags<VideoEncodeH265InputModeFlagBitsEXT>;
@ -21402,8 +21662,8 @@ namespace VULKAN_HPP_NAMESPACE
{ {
enum : VkFlags enum : VkFlags
{ {
allFlags = VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e8 ) | VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e16 ) | allFlags = VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e16 ) | VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e32 ) |
VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e32 ) | VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e64 ) VkFlags( VideoEncodeH265CtbSizeFlagBitsEXT::e64 )
}; };
}; };
@ -21437,8 +21697,6 @@ namespace VULKAN_HPP_NAMESPACE
return "{}"; return "{}";
std::string result; std::string result;
if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e8 )
result += "8 | ";
if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e16 ) if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e16 )
result += "16 | "; result += "16 | ";
if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e32 ) if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e32 )
@ -21449,6 +21707,65 @@ namespace VULKAN_HPP_NAMESPACE
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
using VideoEncodeH265TransformBlockSizeFlagsEXT = Flags<VideoEncodeH265TransformBlockSizeFlagBitsEXT>;
template <>
struct FlagTraits<VideoEncodeH265TransformBlockSizeFlagBitsEXT>
{
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<VideoEncodeH265RateControlStructureFlagBitsEXT>; using VideoEncodeH265RateControlStructureFlagsEXT = Flags<VideoEncodeH265RateControlStructureFlagBitsEXT>;
template <> template <>
@ -22521,6 +22838,54 @@ namespace VULKAN_HPP_NAMESPACE
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
using VideoEncodeCapabilityFlagsKHR = Flags<VideoEncodeCapabilityFlagBitsKHR>;
template <>
struct FlagTraits<VideoEncodeCapabilityFlagBitsKHR>
{
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<VideoEncodeRateControlFlagBitsKHR>; using VideoEncodeRateControlFlagsKHR = Flags<VideoEncodeRateControlFlagBitsKHR>;
template <> template <>

2
vulkan/vulkan_handles.hpp
View File

@ -583,6 +583,7 @@ namespace VULKAN_HPP_NAMESPACE
struct VideoEncodeH264SessionParametersCreateInfoEXT; struct VideoEncodeH264SessionParametersCreateInfoEXT;
struct VideoEncodeH264SessionParametersAddInfoEXT; struct VideoEncodeH264SessionParametersAddInfoEXT;
struct VideoEncodeH264VclFrameInfoEXT; struct VideoEncodeH264VclFrameInfoEXT;
struct VideoEncodeH264ReferenceListsEXT;
struct VideoEncodeH264EmitPictureParametersEXT; struct VideoEncodeH264EmitPictureParametersEXT;
struct VideoEncodeH264DpbSlotInfoEXT; struct VideoEncodeH264DpbSlotInfoEXT;
struct VideoEncodeH264NaluSliceEXT; struct VideoEncodeH264NaluSliceEXT;
@ -1182,6 +1183,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_encode_queue === //=== VK_KHR_video_encode_queue ===
struct VideoEncodeInfoKHR; struct VideoEncodeInfoKHR;
struct VideoEncodeCapabilitiesKHR;
struct VideoEncodeRateControlInfoKHR; struct VideoEncodeRateControlInfoKHR;
struct VideoEncodeRateControlLayerInfoKHR; struct VideoEncodeRateControlLayerInfoKHR;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/

91
vulkan/vulkan_hash.hpp
View File

@ -12289,6 +12289,26 @@ namespace std
}; };
# endif /*VK_ENABLE_BETA_EXTENSIONS*/ # endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>
{
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 ) # if defined( VK_ENABLE_BETA_EXTENSIONS )
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT>
@ -12303,13 +12323,14 @@ namespace std
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.flags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.flags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.inputModeFlags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.inputModeFlags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.outputModeFlags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.outputModeFlags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.minPictureSizeInMbs ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxPPictureL0ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxPictureSizeInMbs ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBPictureL0ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.inputImageDataAlignment ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxL1ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForP ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.motionVectorsOverPicBoundariesFlag );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxNumL0ReferenceForB ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBytesPerPicDenom );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxNumL1Reference ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxBitsPerMbDenom );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.qualityLevelCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthHorizontal );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthVertical );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.stdExtensionVersion ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.stdExtensionVersion );
return seed; return seed;
} }
@ -12327,7 +12348,7 @@ namespace std
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.slotIndex ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.slotIndex );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pStdPictureInfo ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoEXT.pStdReferenceInfo );
return seed; return seed;
} }
}; };
@ -12368,6 +12389,26 @@ namespace std
}; };
# endif /*VK_ENABLE_BETA_EXTENSIONS*/ # endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT>
{
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 ) # if defined( VK_ENABLE_BETA_EXTENSIONS )
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT> struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT>
@ -12378,12 +12419,9 @@ namespace std
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pNext ); 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.mbCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.refFinalList0EntryCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pReferenceFinalLists );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pRefFinalList0Entries ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.refFinalList1EntryCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceEXT.pRefFinalList1Entries );
return seed; return seed;
} }
}; };
@ -12531,10 +12569,7 @@ namespace std
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.refDefaultFinalList0EntryCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pReferenceFinalLists );
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.naluSliceEntryCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo ); 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.inputModeFlags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.outputModeFlags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.outputModeFlags );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.ctbSizes ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.ctbSizes );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.inputImageDataAlignment ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.transformBlockSizes );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForP ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxPPictureL0ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumL0ReferenceForB ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxBPictureL0ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumL1Reference ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxL1ReferenceCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxNumSubLayers ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxSubLayersCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.qualityLevelCount ); 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 ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.stdExtensionVersion );
return seed; return seed;
} }

1210
vulkan/vulkan_structs.hpp
View File

File diff suppressed because it is too large Load Diff