From cb71b646f1389822409a281252689492a18905b9 Mon Sep 17 00:00:00 2001 From: Jon Leech Date: Fri, 9 Jun 2023 20:55:33 -0700 Subject: Update for Vulkan-Docs 1.3.253 --- .../vk_video/vulkan_video_codec_h264std_encode.h | 55 +- .../vk_video/vulkan_video_codec_h265std_encode.h | 102 +- include/vulkan/vulkan.hpp | 231 +- include/vulkan/vulkan_beta.h | 435 +- include/vulkan/vulkan_core.h | 56 +- include/vulkan/vulkan_enums.hpp | 321 +- include/vulkan/vulkan_funcs.hpp | 235 ++ include/vulkan/vulkan_handles.hpp | 86 +- include/vulkan/vulkan_hash.hpp | 395 +- include/vulkan/vulkan_raii.hpp | 249 +- include/vulkan/vulkan_static_assertions.hpp | 124 +- include/vulkan/vulkan_structs.hpp | 4383 ++++++++++++++------ include/vulkan/vulkan_to_string.hpp | 416 +- registry/generator.py | 24 + registry/genvk.py | 20 + registry/reg.py | 99 +- registry/validusage.json | 552 ++- registry/video.xml | 113 +- registry/vk.xml | 819 +++- 19 files changed, 6360 insertions(+), 2355 deletions(-) diff --git a/include/vk_video/vulkan_video_codec_h264std_encode.h b/include/vk_video/vulkan_video_codec_h264std_encode.h index d4edb40..47c30f7 100644 --- a/include/vk_video/vulkan_video_codec_h264std_encode.h +++ b/include/vk_video/vulkan_video_codec_h264std_encode.h @@ -21,9 +21,9 @@ extern "C" { #define vulkan_video_codec_h264std_encode 1 // Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_9 VK_MAKE_VIDEO_STD_VERSION(0, 9, 9) +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10) -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_9 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_10 #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode" typedef struct StdVideoEncodeH264WeightTableFlags { uint32_t luma_weight_l0_flag; @@ -49,24 +49,27 @@ typedef struct StdVideoEncodeH264WeightTable { typedef struct StdVideoEncodeH264SliceHeaderFlags { uint32_t direct_spatial_mv_pred_flag : 1; uint32_t num_ref_idx_active_override_flag : 1; - uint32_t no_output_of_prior_pics_flag : 1; - uint32_t adaptive_ref_pic_marking_mode_flag : 1; - uint32_t no_prior_references_available_flag : 1; + uint32_t reserved : 30; } StdVideoEncodeH264SliceHeaderFlags; typedef struct StdVideoEncodeH264PictureInfoFlags { - uint32_t idr_flag : 1; - uint32_t is_reference_flag : 1; - uint32_t used_for_long_term_reference : 1; + uint32_t IdrPicFlag : 1; + uint32_t is_reference : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t long_term_reference_flag : 1; + uint32_t adaptive_ref_pic_marking_mode_flag : 1; + uint32_t reserved : 27; } StdVideoEncodeH264PictureInfoFlags; typedef struct StdVideoEncodeH264ReferenceInfoFlags { uint32_t used_for_long_term_reference : 1; + uint32_t reserved : 31; } StdVideoEncodeH264ReferenceInfoFlags; typedef struct StdVideoEncodeH264ReferenceListsInfoFlags { uint32_t ref_pic_list_modification_flag_l0 : 1; uint32_t ref_pic_list_modification_flag_l1 : 1; + uint32_t reserved : 30; } StdVideoEncodeH264ReferenceListsInfoFlags; typedef struct StdVideoEncodeH264RefListModEntry { @@ -85,51 +88,51 @@ typedef struct StdVideoEncodeH264RefPicMarkingEntry { typedef struct StdVideoEncodeH264ReferenceListsInfo { StdVideoEncodeH264ReferenceListsInfoFlags flags; - uint8_t refPicList0EntryCount; - uint8_t refPicList1EntryCount; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; uint8_t refList0ModOpCount; uint8_t refList1ModOpCount; uint8_t refPicMarkingOpCount; uint8_t reserved1[7]; - const uint8_t* pRefPicList0Entries; - const uint8_t* pRefPicList1Entries; const StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; const StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; } StdVideoEncodeH264ReferenceListsInfo; typedef struct StdVideoEncodeH264PictureInfo { - StdVideoEncodeH264PictureInfoFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint16_t reserved1; - StdVideoH264PictureType pictureType; - uint32_t frame_num; - int32_t PicOrderCnt; + StdVideoEncodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint16_t idr_pic_id; + StdVideoH264PictureType primary_pic_type; + uint32_t frame_num; + int32_t PicOrderCnt; + uint8_t temporal_id; + uint8_t reserved1[3]; + const StdVideoEncodeH264ReferenceListsInfo* pRefLists; } StdVideoEncodeH264PictureInfo; typedef struct StdVideoEncodeH264ReferenceInfo { StdVideoEncodeH264ReferenceInfoFlags flags; - StdVideoH264PictureType pictureType; + StdVideoH264PictureType primary_pic_type; uint32_t FrameNum; int32_t PicOrderCnt; uint16_t long_term_pic_num; uint16_t long_term_frame_idx; + uint8_t temporal_id; } StdVideoEncodeH264ReferenceInfo; typedef struct StdVideoEncodeH264SliceHeader { StdVideoEncodeH264SliceHeaderFlags flags; uint32_t first_mb_in_slice; StdVideoH264SliceType slice_type; - uint16_t idr_pic_id; - uint8_t num_ref_idx_l0_active_minus1; - uint8_t num_ref_idx_l1_active_minus1; - StdVideoH264CabacInitIdc cabac_init_idc; - StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; int8_t slice_alpha_c0_offset_div2; int8_t slice_beta_offset_div2; uint16_t reserved1; - uint32_t reserved2; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; const StdVideoEncodeH264WeightTable* pWeightTable; } StdVideoEncodeH264SliceHeader; diff --git a/include/vk_video/vulkan_video_codec_h265std_encode.h b/include/vk_video/vulkan_video_codec_h265std_encode.h index 1a42b95..d736390 100644 --- a/include/vk_video/vulkan_video_codec_h265std_encode.h +++ b/include/vk_video/vulkan_video_codec_h265std_encode.h @@ -21,9 +21,9 @@ extern "C" { #define vulkan_video_codec_h265std_encode 1 // Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10) +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_11 VK_MAKE_VIDEO_STD_VERSION(0, 9, 11) -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_10 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_11 #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode" typedef struct StdVideoEncodeH265WeightTableFlags { uint16_t luma_weight_l0_flag; @@ -48,11 +48,7 @@ typedef struct StdVideoEncodeH265WeightTable { typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags { uint32_t first_slice_segment_in_pic_flag : 1; - uint32_t no_output_of_prior_pics_flag : 1; uint32_t dependent_slice_segment_flag : 1; - uint32_t pic_output_flag : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; - uint32_t slice_temporal_mvp_enable_flag : 1; uint32_t slice_sao_luma_flag : 1; uint32_t slice_sao_chroma_flag : 1; uint32_t num_ref_idx_active_override_flag : 1; @@ -63,81 +59,89 @@ typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags { uint32_t slice_deblocking_filter_disabled_flag : 1; uint32_t collocated_from_l0_flag : 1; uint32_t slice_loop_filter_across_slices_enabled_flag : 1; + uint32_t reserved : 20; } StdVideoEncodeH265SliceSegmentHeaderFlags; -typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics { - uint8_t num_long_term_sps; - uint8_t num_long_term_pics; - uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; - uint8_t poc_lsb_lt[STD_VIDEO_H265_MAX_LONG_TERM_PICS]; - uint16_t used_by_curr_pic_lt_flag; - uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC]; - uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC]; -} StdVideoEncodeH265SliceSegmentLongTermRefPics; - typedef struct StdVideoEncodeH265SliceSegmentHeader { - StdVideoEncodeH265SliceSegmentHeaderFlags flags; - StdVideoH265SliceType slice_type; - uint32_t slice_segment_address; - uint8_t short_term_ref_pic_set_idx; - uint8_t collocated_ref_idx; - uint8_t num_ref_idx_l0_active_minus1; - uint8_t num_ref_idx_l1_active_minus1; - uint8_t MaxNumMergeCand; - int8_t slice_cb_qp_offset; - int8_t slice_cr_qp_offset; - int8_t slice_beta_offset_div2; - int8_t slice_tc_offset_div2; - int8_t slice_act_y_qp_offset; - int8_t slice_act_cb_qp_offset; - int8_t slice_act_cr_qp_offset; - const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; - const StdVideoEncodeH265SliceSegmentLongTermRefPics* pLongTermRefPics; - const StdVideoEncodeH265WeightTable* pWeightTable; + StdVideoEncodeH265SliceSegmentHeaderFlags flags; + StdVideoH265SliceType slice_type; + uint32_t slice_segment_address; + uint8_t collocated_ref_idx; + uint8_t MaxNumMergeCand; + int8_t slice_cb_qp_offset; + int8_t slice_cr_qp_offset; + int8_t slice_beta_offset_div2; + int8_t slice_tc_offset_div2; + int8_t slice_act_y_qp_offset; + int8_t slice_act_cb_qp_offset; + int8_t slice_act_cr_qp_offset; + uint8_t reserved1[3]; + const StdVideoEncodeH265WeightTable* pWeightTable; } StdVideoEncodeH265SliceSegmentHeader; typedef struct StdVideoEncodeH265ReferenceListsInfoFlags { uint32_t ref_pic_list_modification_flag_l0 : 1; uint32_t ref_pic_list_modification_flag_l1 : 1; + uint32_t reserved : 30; } StdVideoEncodeH265ReferenceListsInfoFlags; typedef struct StdVideoEncodeH265ReferenceListsInfo { StdVideoEncodeH265ReferenceListsInfoFlags flags; uint8_t num_ref_idx_l0_active_minus1; uint8_t num_ref_idx_l1_active_minus1; - uint16_t reserved1; - const uint8_t* pRefPicList0Entries; - const uint8_t* pRefPicList1Entries; - const uint8_t* pRefList0Modifications; - const uint8_t* pRefList1Modifications; + uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + uint8_t list_entry_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + uint8_t list_entry_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; } StdVideoEncodeH265ReferenceListsInfo; typedef struct StdVideoEncodeH265PictureInfoFlags { - uint32_t is_reference_flag : 1; + uint32_t is_reference : 1; uint32_t IrapPicFlag : 1; - uint32_t long_term_flag : 1; + uint32_t used_for_long_term_reference : 1; uint32_t discardable_flag : 1; uint32_t cross_layer_bla_flag : 1; + uint32_t pic_output_flag : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; + uint32_t slice_temporal_mvp_enabled_flag : 1; + uint32_t reserved : 23; } StdVideoEncodeH265PictureInfoFlags; +typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics { + uint8_t num_long_term_sps; + uint8_t num_long_term_pics; + uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; + uint8_t poc_lsb_lt[STD_VIDEO_H265_MAX_LONG_TERM_PICS]; + uint16_t used_by_curr_pic_lt_flag; + uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC]; + uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC]; +} StdVideoEncodeH265SliceSegmentLongTermRefPics; + typedef struct StdVideoEncodeH265PictureInfo { - StdVideoEncodeH265PictureInfoFlags flags; - StdVideoH265PictureType PictureType; - uint8_t sps_video_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - uint8_t pps_pic_parameter_set_id; - uint8_t TemporalId; - int32_t PicOrderCntVal; + StdVideoEncodeH265PictureInfoFlags flags; + StdVideoH265PictureType pic_type; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t short_term_ref_pic_set_idx; + int32_t PicOrderCntVal; + uint8_t TemporalId; + uint8_t reserved1[7]; + const StdVideoEncodeH265ReferenceListsInfo* pRefLists; + const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; + const StdVideoEncodeH265SliceSegmentLongTermRefPics* pLongTermRefPics; } StdVideoEncodeH265PictureInfo; typedef struct StdVideoEncodeH265ReferenceInfoFlags { uint32_t used_for_long_term_reference : 1; uint32_t unused_for_reference : 1; + uint32_t reserved : 30; } StdVideoEncodeH265ReferenceInfoFlags; typedef struct StdVideoEncodeH265ReferenceInfo { StdVideoEncodeH265ReferenceInfoFlags flags; - StdVideoH265PictureType PictureType; + StdVideoH265PictureType pic_type; int32_t PicOrderCntVal; uint8_t TemporalId; } StdVideoEncodeH265ReferenceInfo; diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 16867fd..4b1d70c 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 252, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 253, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for non-dispatchable 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 @@ -4968,6 +4968,23 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === + VkResult + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( physicalDevice, pQualityLevelInfo, pQualityLevelProperties ); + } + + VkResult vkGetEncodedVideoSessionParametersKHR( VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, + size_t * pDataSize, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetEncodedVideoSessionParametersKHR( device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData ); + } + void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT { return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo ); @@ -8238,6 +8255,22 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum @@ -8254,7 +8287,23 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> - struct StructExtends + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends { enum { @@ -8294,7 +8343,7 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> - struct StructExtends + struct StructExtends { enum { @@ -8309,6 +8358,14 @@ namespace VULKAN_HPP_NAMESPACE value = true }; }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ # if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -8322,6 +8379,22 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum @@ -8338,7 +8411,23 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> - struct StructExtends + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends { enum { @@ -8378,7 +8467,7 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> - struct StructExtends + struct StructExtends { enum { @@ -8393,6 +8482,14 @@ namespace VULKAN_HPP_NAMESPACE value = true }; }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_KHR_video_decode_h264 === @@ -10728,7 +10825,23 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> - struct StructExtends + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends { enum { @@ -13165,8 +13278,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; #else - PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_XLIB_KHR*/ #if defined( VK_USE_PLATFORM_XCB_KHR ) @@ -13174,8 +13287,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; #else - PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_XCB_KHR*/ #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) @@ -13183,15 +13296,15 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; #else - PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #if defined( VK_USE_PLATFORM_ANDROID_KHR ) //=== VK_KHR_android_surface === PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; #else - PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; + PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -13199,8 +13312,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; #else - PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_EXT_debug_report === @@ -13266,7 +13379,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_GGP_stream_descriptor_surface === PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; #else - PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; + PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; #endif /*VK_USE_PLATFORM_GGP*/ //=== VK_NV_external_memory_capabilities === @@ -13276,7 +13389,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_external_memory_win32 === PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; #else - PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_get_physical_device_properties2 === @@ -13297,7 +13410,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NN_vi_surface === PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; #else - PFN_dummy vkCreateViSurfaceNN_placeholder = 0; + PFN_dummy vkCreateViSurfaceNN_placeholder = 0; #endif /*VK_USE_PLATFORM_VI_NN*/ //=== VK_KHR_maintenance1 === @@ -13314,8 +13427,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; #else - PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_external_memory_fd === @@ -13330,8 +13443,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; #else - PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; + PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_external_semaphore_fd === @@ -13362,8 +13475,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; #else - PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; - PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; + PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; + PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ //=== VK_EXT_display_surface_counter === @@ -13404,8 +13517,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; #else - PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; + PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_external_fence_fd === @@ -13432,14 +13545,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_MVK_ios_surface === PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; #else - PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; + PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; #endif /*VK_USE_PLATFORM_IOS_MVK*/ #if defined( VK_USE_PLATFORM_MACOS_MVK ) //=== VK_MVK_macos_surface === PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; #else - PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; + PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; #endif /*VK_USE_PLATFORM_MACOS_MVK*/ //=== VK_EXT_debug_utils === @@ -13460,8 +13573,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; #else - PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; - PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; + PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; + PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ //=== VK_EXT_sample_locations === @@ -13589,14 +13702,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_FUCHSIA_imagepipe_surface === PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; #else - PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; + PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_surface === PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; #else - PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; + PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; #endif /*VK_USE_PLATFORM_METAL_EXT*/ //=== VK_KHR_fragment_shading_rate === @@ -13625,10 +13738,10 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; #else - PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; - PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; + PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_EXT_headless_surface === @@ -13698,16 +13811,20 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === - PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0; + PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0; + PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; #else - PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR_placeholder = 0; + PFN_dummy vkGetEncodedVideoSessionParametersKHR_placeholder = 0; + PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; #else - PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; + PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; #endif /*VK_USE_PLATFORM_METAL_EXT*/ //=== VK_KHR_synchronization2 === @@ -13760,8 +13877,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; #else - PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; - PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; + PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; + PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) @@ -13769,8 +13886,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; #else - PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; + PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ //=== VK_EXT_vertex_input_dynamic_state === @@ -13781,8 +13898,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; #else - PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; + PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -13790,8 +13907,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; #else - PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; #endif /*VK_USE_PLATFORM_FUCHSIA*/ #if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -13802,11 +13919,11 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; #else - PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; + PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; #endif /*VK_USE_PLATFORM_FUCHSIA*/ //=== VK_HUAWEI_subpass_shading === @@ -13834,8 +13951,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; #else - PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; + PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ //=== VK_EXT_color_write_enable === @@ -14951,6 +15068,10 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) ); + vkGetEncodedVideoSessionParametersKHR = + PFN_vkGetEncodedVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkGetEncodedVideoSessionParametersKHR" ) ); vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -15937,6 +16058,8 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === + vkGetEncodedVideoSessionParametersKHR = + PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) ); vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ diff --git a/include/vulkan/vulkan_beta.h b/include/vulkan/vulkan_beta.h index b0729cc..f67a6a6 100644 --- a/include/vulkan/vulkan_beta.h +++ b/include/vulkan/vulkan_beta.h @@ -51,7 +51,7 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { #define VK_KHR_video_encode_queue 1 -#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 8 +#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 9 #define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" typedef enum VkVideoEncodeTuningModeKHR { @@ -82,6 +82,7 @@ typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; typedef enum VkVideoEncodeFeedbackFlagBitsKHR { VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004, VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoEncodeFeedbackFlagBitsKHR; typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; @@ -109,7 +110,6 @@ typedef struct VkVideoEncodeInfoKHR { VkStructureType sType; const void* pNext; VkVideoEncodeFlagsKHR flags; - uint32_t qualityLevel; VkBuffer dstBuffer; VkDeviceSize dstBufferOffset; VkDeviceSize dstBufferRange; @@ -126,8 +126,9 @@ typedef struct VkVideoEncodeCapabilitiesKHR { VkVideoEncodeCapabilityFlagsKHR flags; VkVideoEncodeRateControlModeFlagsKHR rateControlModes; uint32_t maxRateControlLayers; + uint64_t maxBitrate; uint32_t maxQualityLevels; - VkExtent2D inputImageDataFillAlignment; + VkExtent2D encodeInputPictureGranularity; VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; } VkVideoEncodeCapabilitiesKHR; @@ -152,8 +153,6 @@ typedef struct VkVideoEncodeRateControlLayerInfoKHR { uint64_t maxBitrate; uint32_t frameRateNumerator; uint32_t frameRateDenominator; - uint32_t virtualBufferSizeInMs; - uint32_t initialVirtualBufferSizeInMs; } VkVideoEncodeRateControlLayerInfoKHR; typedef struct VkVideoEncodeRateControlInfoKHR { @@ -163,11 +162,59 @@ typedef struct VkVideoEncodeRateControlInfoKHR { VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; uint32_t layerCount; const VkVideoEncodeRateControlLayerInfoKHR* pLayers; + uint32_t virtualBufferSizeInMs; + uint32_t initialVirtualBufferSizeInMs; } VkVideoEncodeRateControlInfoKHR; +typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext; + const VkVideoProfileInfoKHR* pVideoProfile; + uint32_t qualityLevel; +} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; + +typedef struct VkVideoEncodeQualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; + uint32_t preferredRateControlLayerCount; +} VkVideoEncodeQualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t qualityLevel; +} VkVideoEncodeQualityLevelInfoKHR; + +typedef struct VkVideoEncodeSessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersKHR videoSessionParameters; +} VkVideoEncodeSessionParametersGetInfoKHR; + +typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext; + VkBool32 hasOverrides; +} VkVideoEncodeSessionParametersFeedbackInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); #ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR( + VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData); + VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); @@ -177,60 +224,100 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( #define VK_EXT_video_encode_h264 1 #include "vk_video/vulkan_video_codec_h264std.h" #include "vk_video/vulkan_video_codec_h264std_encode.h" -#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 10 +#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 11 #define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264" -typedef enum VkVideoEncodeH264RateControlStructureEXT { - VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH264RateControlStructureEXT; - typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT { - VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020, - VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000040, - VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000080, - VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000100, - VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00000200, - VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0x00000400, - VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0x00000800, - VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00001000, - VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00002000, - VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00004000, - VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00008000, - VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00010000, - VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00020000, - VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00040000, - VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0x00080000, - VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00100000, - VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0x00200000, - VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00400000, - VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00800000, - VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x01000000, - VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT = 0x02000000, + VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT = 0x00000100, VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkVideoEncodeH264CapabilityFlagBitsEXT; typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; + +typedef enum VkVideoEncodeH264StdFlagBitsEXT { + VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT = 0x00000100, + VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT = 0x00000200, + VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT = 0x00000400, + VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT = 0x00000800, + VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT = 0x00001000, + VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT = 0x00002000, + VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00008000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00010000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00020000, + VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264StdFlagBitsEXT; +typedef VkFlags VkVideoEncodeH264StdFlagsEXT; + +typedef enum VkVideoEncodeH264RateControlFlagBitsEXT { + VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264RateControlFlagBitsEXT; +typedef VkFlags VkVideoEncodeH264RateControlFlagsEXT; typedef struct VkVideoEncodeH264CapabilitiesEXT { VkStructureType sType; void* pNext; VkVideoEncodeH264CapabilityFlagsEXT flags; + StdVideoH264LevelIdc maxLevelIdc; + uint32_t maxSliceCount; uint32_t maxPPictureL0ReferenceCount; uint32_t maxBPictureL0ReferenceCount; uint32_t maxL1ReferenceCount; - VkBool32 motionVectorsOverPicBoundariesFlag; - uint32_t maxBytesPerPicDenom; - uint32_t maxBitsPerMbDenom; - uint32_t log2MaxMvLengthHorizontal; - uint32_t log2MaxMvLengthVertical; + uint32_t maxTemporalLayerCount; + VkBool32 expectDyadicTemporalLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH264StdFlagsEXT stdSyntaxFlags; } VkVideoEncodeH264CapabilitiesEXT; +typedef struct VkVideoEncodeH264QpEXT { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH264QpEXT; + +typedef struct VkVideoEncodeH264QualityLevelPropertiesEXT { + VkStructureType sType; + void* pNext; + VkVideoEncodeH264RateControlFlagsEXT preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeH264QpEXT preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; + VkBool32 preferredStdEntropyCodingModeFlag; +} VkVideoEncodeH264QualityLevelPropertiesEXT; + +typedef struct VkVideoEncodeH264SessionCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 useMaxLevelIdc; + StdVideoH264LevelIdc maxLevelIdc; +} VkVideoEncodeH264SessionCreateInfoEXT; + typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT { VkStructureType sType; const void* pNext; @@ -248,22 +335,37 @@ typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT { const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo; } VkVideoEncodeH264SessionParametersCreateInfoEXT; +typedef struct VkVideoEncodeH264SessionParametersGetInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdSPSId; + uint32_t stdPPSId; +} VkVideoEncodeH264SessionParametersGetInfoEXT; + +typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoEXT { + VkStructureType sType; + void* pNext; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; +} VkVideoEncodeH264SessionParametersFeedbackInfoEXT; + typedef struct VkVideoEncodeH264NaluSliceInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t mbCount; - const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists; - const StdVideoEncodeH264SliceHeader* pStdSliceHeader; + VkStructureType sType; + const void* pNext; + int32_t constantQp; + const StdVideoEncodeH264SliceHeader* pStdSliceHeader; } VkVideoEncodeH264NaluSliceInfoEXT; -typedef struct VkVideoEncodeH264VclFrameInfoEXT { - VkStructureType sType; - const void* pNext; - const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists; - uint32_t naluSliceEntryCount; - const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries; - const StdVideoEncodeH264PictureInfo* pStdPictureInfo; -} VkVideoEncodeH264VclFrameInfoEXT; +typedef struct VkVideoEncodeH264PictureInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t naluSliceEntryCount; + const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo; + VkBool32 generatePrefixNalu; +} VkVideoEncodeH264PictureInfoEXT; typedef struct VkVideoEncodeH264DpbSlotInfoEXT { VkStructureType sType; @@ -278,21 +380,15 @@ typedef struct VkVideoEncodeH264ProfileInfoEXT { } VkVideoEncodeH264ProfileInfoEXT; typedef struct VkVideoEncodeH264RateControlInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - VkVideoEncodeH264RateControlStructureEXT rateControlStructure; - uint32_t temporalLayerCount; + VkStructureType sType; + const void* pNext; + VkVideoEncodeH264RateControlFlagsEXT flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t temporalLayerCount; } VkVideoEncodeH264RateControlInfoEXT; -typedef struct VkVideoEncodeH264QpEXT { - int32_t qpI; - int32_t qpP; - int32_t qpB; -} VkVideoEncodeH264QpEXT; - typedef struct VkVideoEncodeH264FrameSizeEXT { uint32_t frameISize; uint32_t framePSize; @@ -302,9 +398,6 @@ typedef struct VkVideoEncodeH264FrameSizeEXT { typedef struct VkVideoEncodeH264RateControlLayerInfoEXT { VkStructureType sType; const void* pNext; - uint32_t temporalLayerId; - VkBool32 useInitialRcQp; - VkVideoEncodeH264QpEXT initialRcQp; VkBool32 useMinQp; VkVideoEncodeH264QpEXT minQp; VkBool32 useMaxQp; @@ -313,53 +406,62 @@ typedef struct VkVideoEncodeH264RateControlLayerInfoEXT { VkVideoEncodeH264FrameSizeEXT maxFrameSize; } VkVideoEncodeH264RateControlLayerInfoEXT; +typedef struct VkVideoEncodeH264GopRemainingFrameInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; +} VkVideoEncodeH264GopRemainingFrameInfoEXT; + #define VK_EXT_video_encode_h265 1 #include "vk_video/vulkan_video_codec_h265std.h" #include "vk_video/vulkan_video_codec_h265std_encode.h" -#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 10 +#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 11 #define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265" -typedef enum VkVideoEncodeH265RateControlStructureEXT { - VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH265RateControlStructureEXT; - typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT { - VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020, - VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0x00000040, - VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000080, - VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0x00000100, - VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0x00000200, - VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0x00000400, - VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000800, - VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00001000, - VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00002000, - VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00004000, - VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00008000, - VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00010000, - VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00020000, - VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00040000, - VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00080000, - VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00100000, - VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00200000, - VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00400000, - VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00800000, - VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x01000000, - VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x02000000, - VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT = 0x04000000, + VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT = 0x00000100, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT = 0x00000200, VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkVideoEncodeH265CapabilityFlagBitsEXT; typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; +typedef enum VkVideoEncodeH265StdFlagBitsEXT { + VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000100, + VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT = 0x00000200, + VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT = 0x00000400, + VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT = 0x00000800, + VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT = 0x00001000, + VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT = 0x00002000, + VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000, + VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT = 0x00008000, + VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT = 0x00010000, + VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT = 0x00020000, + VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT = 0x00040000, + VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH265StdFlagBitsEXT; +typedef VkFlags VkVideoEncodeH265StdFlagsEXT; + typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT { VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001, VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002, @@ -376,29 +478,63 @@ typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT { VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkVideoEncodeH265TransformBlockSizeFlagBitsEXT; typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; + +typedef enum VkVideoEncodeH265RateControlFlagBitsEXT { + VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH265RateControlFlagBitsEXT; +typedef VkFlags VkVideoEncodeH265RateControlFlagsEXT; typedef struct VkVideoEncodeH265CapabilitiesEXT { VkStructureType sType; void* pNext; VkVideoEncodeH265CapabilityFlagsEXT flags; + StdVideoH265LevelIdc maxLevelIdc; + uint32_t maxSliceSegmentCount; + VkExtent2D maxTiles; VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes; VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes; uint32_t maxPPictureL0ReferenceCount; uint32_t maxBPictureL0ReferenceCount; uint32_t maxL1ReferenceCount; - uint32_t maxSubLayersCount; - uint32_t minLog2MinLumaCodingBlockSizeMinus3; - uint32_t maxLog2MinLumaCodingBlockSizeMinus3; - uint32_t minLog2MinLumaTransformBlockSizeMinus2; - uint32_t maxLog2MinLumaTransformBlockSizeMinus2; - uint32_t minMaxTransformHierarchyDepthInter; - uint32_t maxMaxTransformHierarchyDepthInter; - uint32_t minMaxTransformHierarchyDepthIntra; - uint32_t maxMaxTransformHierarchyDepthIntra; - uint32_t maxDiffCuQpDeltaDepth; - uint32_t minMaxNumMergeCand; - uint32_t maxMaxNumMergeCand; + uint32_t maxSubLayerCount; + VkBool32 expectDyadicTemporalSubLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH265StdFlagsEXT stdSyntaxFlags; } VkVideoEncodeH265CapabilitiesEXT; +typedef struct VkVideoEncodeH265SessionCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 useMaxLevelIdc; + StdVideoH265LevelIdc maxLevelIdc; +} VkVideoEncodeH265SessionCreateInfoEXT; + +typedef struct VkVideoEncodeH265QpEXT { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH265QpEXT; + +typedef struct VkVideoEncodeH265QualityLevelPropertiesEXT { + VkStructureType sType; + void* pNext; + VkVideoEncodeH265RateControlFlagsEXT preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredSubLayerCount; + VkVideoEncodeH265QpEXT preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; +} VkVideoEncodeH265QualityLevelPropertiesEXT; + typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT { VkStructureType sType; const void* pNext; @@ -419,22 +555,39 @@ typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT { const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo; } VkVideoEncodeH265SessionParametersCreateInfoEXT; +typedef struct VkVideoEncodeH265SessionParametersGetInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 writeStdVPS; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdVPSId; + uint32_t stdSPSId; + uint32_t stdPPSId; +} VkVideoEncodeH265SessionParametersGetInfoEXT; + +typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoEXT { + VkStructureType sType; + void* pNext; + VkBool32 hasStdVPSOverrides; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; +} VkVideoEncodeH265SessionParametersFeedbackInfoEXT; + typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT { VkStructureType sType; const void* pNext; - uint32_t ctbCount; - const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists; + int32_t constantQp; const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader; } VkVideoEncodeH265NaluSliceSegmentInfoEXT; -typedef struct VkVideoEncodeH265VclFrameInfoEXT { +typedef struct VkVideoEncodeH265PictureInfoEXT { VkStructureType sType; const void* pNext; - const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists; uint32_t naluSliceSegmentEntryCount; const VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries; const StdVideoEncodeH265PictureInfo* pStdPictureInfo; -} VkVideoEncodeH265VclFrameInfoEXT; +} VkVideoEncodeH265PictureInfoEXT; typedef struct VkVideoEncodeH265DpbSlotInfoEXT { VkStructureType sType; @@ -449,21 +602,15 @@ typedef struct VkVideoEncodeH265ProfileInfoEXT { } VkVideoEncodeH265ProfileInfoEXT; typedef struct VkVideoEncodeH265RateControlInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - VkVideoEncodeH265RateControlStructureEXT rateControlStructure; - uint32_t subLayerCount; + VkStructureType sType; + const void* pNext; + VkVideoEncodeH265RateControlFlagsEXT flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t subLayerCount; } VkVideoEncodeH265RateControlInfoEXT; -typedef struct VkVideoEncodeH265QpEXT { - int32_t qpI; - int32_t qpP; - int32_t qpB; -} VkVideoEncodeH265QpEXT; - typedef struct VkVideoEncodeH265FrameSizeEXT { uint32_t frameISize; uint32_t framePSize; @@ -473,9 +620,6 @@ typedef struct VkVideoEncodeH265FrameSizeEXT { typedef struct VkVideoEncodeH265RateControlLayerInfoEXT { VkStructureType sType; const void* pNext; - uint32_t temporalId; - VkBool32 useInitialRcQp; - VkVideoEncodeH265QpEXT initialRcQp; VkBool32 useMinQp; VkVideoEncodeH265QpEXT minQp; VkBool32 useMaxQp; @@ -484,6 +628,15 @@ typedef struct VkVideoEncodeH265RateControlLayerInfoEXT { VkVideoEncodeH265FrameSizeEXT maxFrameSize; } VkVideoEncodeH265RateControlLayerInfoEXT; +typedef struct VkVideoEncodeH265GopRemainingFrameInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; +} VkVideoEncodeH265GopRemainingFrameInfoEXT; + #define VK_NV_displacement_micromap 1 diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 0db6741..4d2dc3f 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -68,7 +68,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 252 +#define VK_HEADER_VERSION 253 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -476,7 +476,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT = 1000038003, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004, @@ -484,6 +484,9 @@ typedef enum VkStructureType { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005, #endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT = 1000038006, +#endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007, #endif @@ -493,6 +496,18 @@ typedef enum VkStructureType { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009, #endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT = 1000038010, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT = 1000038011, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT = 1000038012, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT = 1000038013, +#endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000, #endif @@ -503,7 +518,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT = 1000039003, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004, @@ -511,6 +526,9 @@ typedef enum VkStructureType { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005, #endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT = 1000039006, +#endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007, #endif @@ -519,6 +537,18 @@ typedef enum VkStructureType { #endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT = 1000039011, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT = 1000039012, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT = 1000039013, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT = 1000039014, #endif VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, @@ -825,6 +855,21 @@ typedef enum VkStructureType { #endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299006, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR = 1000299007, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299008, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR = 1000299009, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010, #endif VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, @@ -7922,6 +7967,9 @@ typedef VkFlags VkVideoCapabilityFlagsKHR; typedef enum VkVideoSessionCreateFlagBitsKHR { VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR = 0x00000002, +#endif VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoSessionCreateFlagBitsKHR; typedef VkFlags VkVideoSessionCreateFlagsKHR; @@ -7935,7 +7983,7 @@ typedef enum VkVideoCodingControlFlagBitsKHR { VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR = 0x00000004, + VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR = 0x00000004, #endif VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoCodingControlFlagBitsKHR; diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp index 7061515..bb1f30b 100644 --- a/include/vulkan/vulkan_enums.hpp +++ b/include/vulkan/vulkan_enums.hpp @@ -368,24 +368,34 @@ namespace VULKAN_HPP_NAMESPACE eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX, eImageViewAddressPropertiesNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX, #if defined( VK_ENABLE_BETA_EXTENSIONS ) - eVideoEncodeH264CapabilitiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT, - eVideoEncodeH264SessionParametersCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT, - eVideoEncodeH264SessionParametersAddInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT, - eVideoEncodeH264VclFrameInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT, - eVideoEncodeH264DpbSlotInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, - eVideoEncodeH264NaluSliceInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT, - eVideoEncodeH264ProfileInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_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, - eVideoEncodeH265CapabilitiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT, - eVideoEncodeH265SessionParametersCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT, - eVideoEncodeH265SessionParametersAddInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT, - eVideoEncodeH265VclFrameInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT, - eVideoEncodeH265DpbSlotInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT, - eVideoEncodeH265NaluSliceSegmentInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT, - eVideoEncodeH265ProfileInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT, - eVideoEncodeH265RateControlInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT, - eVideoEncodeH265RateControlLayerInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT, + eVideoEncodeH264CapabilitiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT, + eVideoEncodeH264SessionParametersCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT, + eVideoEncodeH264SessionParametersAddInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT, + eVideoEncodeH264PictureInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT, + eVideoEncodeH264DpbSlotInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, + eVideoEncodeH264NaluSliceInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT, + eVideoEncodeH264GopRemainingFrameInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT, + eVideoEncodeH264ProfileInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_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, + eVideoEncodeH264SessionCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT, + eVideoEncodeH264QualityLevelPropertiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT, + eVideoEncodeH264SessionParametersGetInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT, + eVideoEncodeH264SessionParametersFeedbackInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT, + eVideoEncodeH265CapabilitiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT, + eVideoEncodeH265SessionParametersCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT, + eVideoEncodeH265SessionParametersAddInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT, + eVideoEncodeH265PictureInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT, + eVideoEncodeH265DpbSlotInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT, + eVideoEncodeH265NaluSliceSegmentInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT, + eVideoEncodeH265GopRemainingFrameInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT, + eVideoEncodeH265ProfileInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT, + eVideoEncodeH265RateControlInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT, + eVideoEncodeH265RateControlLayerInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT, + eVideoEncodeH265SessionCreateInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT, + eVideoEncodeH265QualityLevelPropertiesEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT, + eVideoEncodeH265SessionParametersGetInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT, + eVideoEncodeH265SessionParametersFeedbackInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ eVideoDecodeH264CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, eVideoDecodeH264PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, @@ -839,12 +849,17 @@ namespace VULKAN_HPP_NAMESPACE ePrivateDataSlotCreateInfoEXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT, ePhysicalDevicePipelineCreationCacheControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) - 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, - eVideoEncodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR, - eQueryPoolVideoEncodeFeedbackCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR, + 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, + eVideoEncodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR, + eQueryPoolVideoEncodeFeedbackCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR, + ePhysicalDeviceVideoEncodeQualityLevelInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, + eVideoEncodeQualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR, + eVideoEncodeQualityLevelInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, + eVideoEncodeSessionParametersGetInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR, + eVideoEncodeSessionParametersFeedbackInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_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, @@ -4362,7 +4377,10 @@ namespace VULKAN_HPP_NAMESPACE enum class VideoSessionCreateFlagBitsKHR : VkVideoSessionCreateFlagsKHR { - eProtectedContent = VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR + eProtectedContent = VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eAllowEncodeParameterOptimizations = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; using VideoSessionCreateFlagsKHR = Flags; @@ -4371,15 +4389,19 @@ namespace VULKAN_HPP_NAMESPACE struct FlagTraits { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = VideoSessionCreateFlagBitsKHR::eProtectedContent; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = VideoSessionCreateFlagBitsKHR::eProtectedContent +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ; }; enum class VideoCodingControlFlagBitsKHR : VkVideoCodingControlFlagsKHR { eReset = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR, #if defined( VK_ENABLE_BETA_EXTENSIONS ) - eEncodeRateControl = VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, - eEncodeRateControlLayer = VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR + eEncodeRateControl = VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, + eEncodeQualityLevel = VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; @@ -4392,7 +4414,7 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodingControlFlagsKHR allFlags = VideoCodingControlFlagBitsKHR::eReset #if defined( VK_ENABLE_BETA_EXTENSIONS ) | VideoCodingControlFlagBitsKHR::eEncodeRateControl | - VideoCodingControlFlagBitsKHR::eEncodeRateControlLayer + VideoCodingControlFlagBitsKHR::eEncodeQualityLevel #endif /*VK_ENABLE_BETA_EXTENSIONS*/ ; }; @@ -4512,32 +4534,15 @@ namespace VULKAN_HPP_NAMESPACE enum class VideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT { - eDirect8X8InferenceEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT, - eDirect8X8InferenceDisabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_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, - eBFrameInL1List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT, - eDifferentReferenceFinalLists = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT + eHrdCompliance = VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT, + ePredictionWeightTableGenerated = VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT, + eRowUnalignedSlice = VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT, + eDifferentSliceType = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT, + eBFrameInL0List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT, + eBFrameInL1List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT, + ePerPictureTypeMinMaxQp = VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT, + ePerSliceConstantQp = VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT, + eGeneratePrefixNalu = VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT }; using VideoEncodeH264CapabilityFlagsEXT = Flags; @@ -4547,26 +4552,72 @@ namespace VULKAN_HPP_NAMESPACE { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT allFlags = - VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceEnabled | VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceDisabled | - VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane | VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass | - VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists | VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance | - VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset | VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset | - VideoEncodeH264CapabilityFlagBitsEXT::ePicInitQpMinus26 | VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPred | - VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredExplicit | VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredImplicit | - VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPredNoTable | VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 | - VideoEncodeH264CapabilityFlagBitsEXT::eCabac | VideoEncodeH264CapabilityFlagBitsEXT::eCavlc | - VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled | VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled | - VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial | VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred | - VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame | VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount | + VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance | VideoEncodeH264CapabilityFlagBitsEXT::ePredictionWeightTableGenerated | VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice | VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType | - VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List | VideoEncodeH264CapabilityFlagBitsEXT::eDifferentReferenceFinalLists; + VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL0List | VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List | + VideoEncodeH264CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp | VideoEncodeH264CapabilityFlagBitsEXT::ePerSliceConstantQp | + VideoEncodeH264CapabilityFlagBitsEXT::eGeneratePrefixNalu; + }; + + enum class VideoEncodeH264StdFlagBitsEXT : VkVideoEncodeH264StdFlagsEXT + { + eSeparateColorPlaneFlagSet = VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT, + eQpprimeYZeroTransformBypassFlagSet = VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT, + eScalingMatrixPresentFlagSet = VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT, + eChromaQpIndexOffset = VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT, + eSecondChromaQpIndexOffset = VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT, + ePicInitQpMinus26 = VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT, + eWeightedPredFlagSet = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT, + eWeightedBipredIdcExplicit = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT, + eWeightedBipredIdcImplicit = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT, + eTransform8X8ModeFlagSet = VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT, + eDirectSpatialMvPredFlagUnset = VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT, + eEntropyCodingModeFlagUnset = VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT, + eEntropyCodingModeFlagSet = VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT, + eDirect8X8InferenceFlagUnset = VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT, + eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT, + eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT, + eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT, + eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT + }; + + using VideoEncodeH264StdFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264StdFlagsEXT allFlags = + VideoEncodeH264StdFlagBitsEXT::eSeparateColorPlaneFlagSet | VideoEncodeH264StdFlagBitsEXT::eQpprimeYZeroTransformBypassFlagSet | + VideoEncodeH264StdFlagBitsEXT::eScalingMatrixPresentFlagSet | VideoEncodeH264StdFlagBitsEXT::eChromaQpIndexOffset | + VideoEncodeH264StdFlagBitsEXT::eSecondChromaQpIndexOffset | VideoEncodeH264StdFlagBitsEXT::ePicInitQpMinus26 | + VideoEncodeH264StdFlagBitsEXT::eWeightedPredFlagSet | VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcExplicit | + VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcImplicit | VideoEncodeH264StdFlagBitsEXT::eTransform8X8ModeFlagSet | + VideoEncodeH264StdFlagBitsEXT::eDirectSpatialMvPredFlagUnset | VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagUnset | + VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagSet | VideoEncodeH264StdFlagBitsEXT::eDirect8X8InferenceFlagUnset | + VideoEncodeH264StdFlagBitsEXT::eConstrainedIntraPredFlagSet | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled | + VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled | VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial; }; - enum class VideoEncodeH264RateControlStructureEXT + enum class VideoEncodeH264RateControlFlagBitsEXT : VkVideoEncodeH264RateControlFlagsEXT { - eUnknown = VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT, - eFlat = VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT, - eDyadic = VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT + eAttemptHrdCompliance = VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT, + eRegularGop = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT, + eReferencePatternFlat = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT, + eReferencePatternDyadic = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT, + eTemporalLayerPatternDyadic = VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT + }; + + using VideoEncodeH264RateControlFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264RateControlFlagsEXT allFlags = + VideoEncodeH264RateControlFlagBitsEXT::eAttemptHrdCompliance | VideoEncodeH264RateControlFlagBitsEXT::eRegularGop | + VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternFlat | VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternDyadic | + VideoEncodeH264RateControlFlagBitsEXT::eTemporalLayerPatternDyadic; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -4575,33 +4626,16 @@ namespace VULKAN_HPP_NAMESPACE 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, - eTransformSkipDisabled = VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_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, - eBFrameInL1List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT, - eDifferentReferenceFinalLists = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT + eHrdCompliance = VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT, + ePredictionWeightTableGenerated = VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT, + eRowUnalignedSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT, + eDifferentSliceSegmentType = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT, + eBFrameInL0List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT, + eBFrameInL1List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT, + ePerPictureTypeMinMaxQp = VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT, + ePerSliceSegmentConstantQp = VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT, + eMultipleTilesPerSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT, + eMultipleSliceSegmentsPerTile = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT }; using VideoEncodeH265CapabilityFlagsEXT = Flags; @@ -4611,20 +4645,53 @@ namespace VULKAN_HPP_NAMESPACE { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CapabilityFlagsEXT allFlags = - VideoEncodeH265CapabilityFlagBitsEXT::eSeparateColourPlane | VideoEncodeH265CapabilityFlagBitsEXT::eScalingLists | - VideoEncodeH265CapabilityFlagBitsEXT::eSampleAdaptiveOffsetEnabled | VideoEncodeH265CapabilityFlagBitsEXT::ePcmEnable | - VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled | VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance | - VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26 | VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2 | - VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled | VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled | - VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipDisabled | VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent | - VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred | VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred | - VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable | VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled | - VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled | VideoEncodeH265CapabilityFlagBitsEXT::eDeblockingFilterOverrideEnabled | - VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame | VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile | - VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice | VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount | - VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment | VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment | - VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType | VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List | - VideoEncodeH265CapabilityFlagBitsEXT::eDifferentReferenceFinalLists; + VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance | VideoEncodeH265CapabilityFlagBitsEXT::ePredictionWeightTableGenerated | + VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment | VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceSegmentType | + VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL0List | VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List | + VideoEncodeH265CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp | VideoEncodeH265CapabilityFlagBitsEXT::ePerSliceSegmentConstantQp | + VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilesPerSliceSegment | VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSliceSegmentsPerTile; + }; + + enum class VideoEncodeH265StdFlagBitsEXT : VkVideoEncodeH265StdFlagsEXT + { + eSeparateColorPlaneFlagSet = VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT, + eSampleAdaptiveOffsetEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT, + eScalingListDataPresentFlagSet = VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT, + ePcmEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT, + eSpsTemporalMvpEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT, + eInitQpMinus26 = VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT, + eWeightedPredFlagSet = VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT, + eWeightedBipredFlagSet = VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT, + eLog2ParallelMergeLevelMinus2 = VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT, + eSignDataHidingEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT, + eTransformSkipEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT, + eTransformSkipEnabledFlagUnset = VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT, + ePpsSliceChromaQpOffsetsPresentFlagSet = VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT, + eTransquantBypassEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT, + eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT, + eEntropyCodingSyncEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT, + eDeblockingFilterOverrideEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT, + eDependentSliceSegmentsEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT, + eDependentSliceSegmentFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT + }; + + using VideoEncodeH265StdFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265StdFlagsEXT allFlags = + VideoEncodeH265StdFlagBitsEXT::eSeparateColorPlaneFlagSet | VideoEncodeH265StdFlagBitsEXT::eSampleAdaptiveOffsetEnabledFlagSet | + VideoEncodeH265StdFlagBitsEXT::eScalingListDataPresentFlagSet | VideoEncodeH265StdFlagBitsEXT::ePcmEnabledFlagSet | + VideoEncodeH265StdFlagBitsEXT::eSpsTemporalMvpEnabledFlagSet | VideoEncodeH265StdFlagBitsEXT::eInitQpMinus26 | + VideoEncodeH265StdFlagBitsEXT::eWeightedPredFlagSet | VideoEncodeH265StdFlagBitsEXT::eWeightedBipredFlagSet | + VideoEncodeH265StdFlagBitsEXT::eLog2ParallelMergeLevelMinus2 | VideoEncodeH265StdFlagBitsEXT::eSignDataHidingEnabledFlagSet | + VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagSet | VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagUnset | + VideoEncodeH265StdFlagBitsEXT::ePpsSliceChromaQpOffsetsPresentFlagSet | VideoEncodeH265StdFlagBitsEXT::eTransquantBypassEnabledFlagSet | + VideoEncodeH265StdFlagBitsEXT::eConstrainedIntraPredFlagSet | VideoEncodeH265StdFlagBitsEXT::eEntropyCodingSyncEnabledFlagSet | + VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet | VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet | + VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet; }; enum class VideoEncodeH265CtbSizeFlagBitsEXT : VkVideoEncodeH265CtbSizeFlagsEXT @@ -4663,11 +4730,25 @@ namespace VULKAN_HPP_NAMESPACE VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32; }; - enum class VideoEncodeH265RateControlStructureEXT + enum class VideoEncodeH265RateControlFlagBitsEXT : VkVideoEncodeH265RateControlFlagsEXT + { + eAttemptHrdCompliance = VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT, + eRegularGop = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT, + eReferencePatternFlat = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT, + eReferencePatternDyadic = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT, + eTemporalSubLayerPatternDyadic = VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT + }; + + using VideoEncodeH265RateControlFlagsEXT = Flags; + + template <> + struct FlagTraits { - eUnknown = VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT, - eFlat = VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT, - eDyadic = VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265RateControlFlagsEXT allFlags = + VideoEncodeH265RateControlFlagBitsEXT::eAttemptHrdCompliance | VideoEncodeH265RateControlFlagBitsEXT::eRegularGop | + VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternFlat | VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternDyadic | + VideoEncodeH265RateControlFlagBitsEXT::eTemporalSubLayerPatternDyadic; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -5786,7 +5867,8 @@ namespace VULKAN_HPP_NAMESPACE enum class VideoEncodeFeedbackFlagBitsKHR : VkVideoEncodeFeedbackFlagsKHR { estreamBufferOffsetBit = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR, - estreamBytesWrittenBit = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR + estreamBytesWrittenBit = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR, + estreamHasOverridesBit = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR }; using VideoEncodeFeedbackFlagsKHR = Flags; @@ -5795,8 +5877,9 @@ namespace VULKAN_HPP_NAMESPACE struct FlagTraits { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFeedbackFlagsKHR allFlags = - VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit | VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFeedbackFlagsKHR allFlags = VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit | + VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit | + VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit; }; enum class VideoEncodeUsageFlagBitsKHR : VkVideoEncodeUsageFlagsKHR diff --git a/include/vulkan/vulkan_funcs.hpp b/include/vulkan/vulkan_funcs.hpp index 3f47e10..e5531ac 100644 --- a/include/vulkan/vulkan_funcs.hpp +++ b/include/vulkan/vulkan_funcs.hpp @@ -18492,6 +18492,241 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, + reinterpret_cast( pQualityLevelInfo ), + reinterpret_cast( pQualityLevelProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; + VkResult result = + d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return createResultValueType( static_cast( result ), qualityLevelProperties ); + } + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + StructureChain structureChain; + VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = + structureChain.template get(); + VkResult result = + d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return createResultValueType( static_cast( result ), structureChain ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, + size_t * pDataSize, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( pVideoSessionParametersInfo ), + reinterpret_cast( pFeedbackInfo ), + pDataSize, + pData ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>>::type + Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::pair> data_; + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; + std::vector & data = data_.second; + size_t dataSize; + VkResult result; + do + { + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + data.resize( dataSize ); + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return createResultValueType( static_cast( result ), data_ ); + } + + template ::value, int>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>>::type + Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Uint8_tAllocator & uint8_tAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::pair> data_( + std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; + std::vector & data = data_.second; + size_t dataSize; + VkResult result; + do + { + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + data.resize( dataSize ); + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return createResultValueType( static_cast( result ), data_ ); + } + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, std::vector>>::type + Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::pair, std::vector> data_; + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = + data_.first.template get(); + std::vector & data = data_.second; + size_t dataSize; + VkResult result; + do + { + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + structureChains.resize( dataSize ); + data.resize( dataSize ); + for ( size_t i = 0; i < dataSize; i++ ) + { + data[i].pNext = structureChains[i].template get().pNext; + } + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return createResultValueType( static_cast( result ), data_ ); + } + + template ::value, int>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, std::vector>>::type + Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + StructureChainAllocator & structureChainAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::pair, std::vector> data_( + std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = + data_.first.template get(); + std::vector & data = data_.second; + size_t dataSize; + VkResult result; + do + { + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + structureChains.resize( dataSize ); + data.resize( dataSize ); + for ( size_t i = 0; i < dataSize; i++ ) + { + data[i].pNext = structureChains[i].template get().pNext; + } + result = d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return createResultValueType( static_cast( result ), data_ ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + template VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index 3630ac9..ca0bafc 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -578,9 +578,13 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_encode_h264 === struct VideoEncodeH264CapabilitiesEXT; + struct VideoEncodeH264QualityLevelPropertiesEXT; + struct VideoEncodeH264SessionCreateInfoEXT; struct VideoEncodeH264SessionParametersCreateInfoEXT; struct VideoEncodeH264SessionParametersAddInfoEXT; - struct VideoEncodeH264VclFrameInfoEXT; + struct VideoEncodeH264SessionParametersGetInfoEXT; + struct VideoEncodeH264SessionParametersFeedbackInfoEXT; + struct VideoEncodeH264PictureInfoEXT; struct VideoEncodeH264DpbSlotInfoEXT; struct VideoEncodeH264NaluSliceInfoEXT; struct VideoEncodeH264ProfileInfoEXT; @@ -588,14 +592,19 @@ namespace VULKAN_HPP_NAMESPACE struct VideoEncodeH264RateControlLayerInfoEXT; struct VideoEncodeH264QpEXT; struct VideoEncodeH264FrameSizeEXT; + struct VideoEncodeH264GopRemainingFrameInfoEXT; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_EXT_video_encode_h265 === struct VideoEncodeH265CapabilitiesEXT; + struct VideoEncodeH265SessionCreateInfoEXT; + struct VideoEncodeH265QualityLevelPropertiesEXT; struct VideoEncodeH265SessionParametersCreateInfoEXT; struct VideoEncodeH265SessionParametersAddInfoEXT; - struct VideoEncodeH265VclFrameInfoEXT; + struct VideoEncodeH265SessionParametersGetInfoEXT; + struct VideoEncodeH265SessionParametersFeedbackInfoEXT; + struct VideoEncodeH265PictureInfoEXT; struct VideoEncodeH265DpbSlotInfoEXT; struct VideoEncodeH265NaluSliceSegmentInfoEXT; struct VideoEncodeH265ProfileInfoEXT; @@ -603,6 +612,7 @@ namespace VULKAN_HPP_NAMESPACE struct VideoEncodeH265RateControlLayerInfoEXT; struct VideoEncodeH265QpEXT; struct VideoEncodeH265FrameSizeEXT; + struct VideoEncodeH265GopRemainingFrameInfoEXT; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_KHR_video_decode_h264 === @@ -1211,6 +1221,11 @@ namespace VULKAN_HPP_NAMESPACE struct VideoEncodeUsageInfoKHR; struct VideoEncodeRateControlInfoKHR; struct VideoEncodeRateControlLayerInfoKHR; + struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR; + struct VideoEncodeQualityLevelPropertiesKHR; + struct VideoEncodeQualityLevelInfoKHR; + struct VideoEncodeSessionParametersGetInfoKHR; + struct VideoEncodeSessionParametersFeedbackInfoKHR; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_NV_device_diagnostics_config === @@ -11983,6 +11998,53 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + + template + VULKAN_HPP_NODISCARD Result + getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, + size_t * pDataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>>::type + getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B2 = Uint8_tAllocator, + typename std::enable_if::value, int>::type = 0> + VULKAN_HPP_NODISCARD + typename ResultValueType>>::type + getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Uint8_tAllocator & uint8_tAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type + getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B2 = StructureChainAllocator, + typename std::enable_if::value, int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type + getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + StructureChainAllocator & structureChainAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -14092,6 +14154,26 @@ namespace VULKAN_HPP_NAMESPACE # endif /* VULKAN_HPP_NO_SMART_HANDLE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + + template + VULKAN_HPP_NODISCARD Result + getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + #if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_NV_acquire_winrt_display === diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp index 1c2795f..f8e37ac 100644 --- a/include/vulkan/vulkan_hash.hpp +++ b/include/vulkan/vulkan_hash.hpp @@ -10682,6 +10682,39 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + template <> struct hash { @@ -13966,8 +13999,9 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.inputImageDataFillAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags ); return seed; } @@ -13984,14 +14018,18 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxSliceCount ); 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.maxTemporalLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.expectDyadicTemporalLayerPattern ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.minQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.maxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.prefersGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.requiresGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesEXT.stdSyntaxFlags ); return seed; } }; @@ -14027,6 +14065,25 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT const & videoEncodeH264GopRemainingFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.useGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.gopRemainingI ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.gopRemainingP ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoEXT.gopRemainingB ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14036,14 +14093,31 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.mbCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pStdReferenceFinalLists ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.constantQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoEXT.pStdSliceHeader ); return seed; } }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT const & videoEncodeH264PictureInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.naluSliceEntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.pNaluSliceEntries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.pStdPictureInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoEXT.generatePrefixNalu ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14074,6 +14148,30 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT const & videoEncodeH264QualityLevelPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredRateControlFlags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredGopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredIdrPeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredConsecutiveBFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredTemporalLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredConstantQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredMaxL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredMaxL1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesEXT.preferredStdEntropyCodingModeFlag ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14083,10 +14181,10 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.flags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.gopFrameCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.idrPeriod ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.rateControlStructure ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoEXT.temporalLayerCount ); return seed; } @@ -14103,9 +14201,6 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.temporalLayerId ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useInitialRcQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.initialRcQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.minQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp ); @@ -14117,6 +14212,22 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT const & videoEncodeH264SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.useMaxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoEXT.maxLevelIdc ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14156,17 +14267,35 @@ namespace std # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> - struct hash + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT const & videoEncodeH264SessionParametersFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.hasStdSPSOverrides ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoEXT.hasStdPPSOverrides ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const & videoEncodeH264VclFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT const & videoEncodeH264SessionParametersGetInfoEXT ) const + VULKAN_HPP_NOEXCEPT { 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.pStdReferenceFinalLists ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264VclFrameInfoEXT.pStdPictureInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.writeStdSPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.writeStdPPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.stdSPSId ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoEXT.stdPPSId ); return seed; } }; @@ -14182,23 +14311,21 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxSliceSegmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxTiles ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.ctbSizes ); 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.maxSubLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.expectDyadicTemporalSubLayerPattern ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.minQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.maxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.prefersGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.requiresGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesEXT.stdSyntaxFlags ); return seed; } }; @@ -14234,6 +14361,25 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT const & videoEncodeH265GopRemainingFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.useGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.gopRemainingI ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.gopRemainingP ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoEXT.gopRemainingB ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14244,14 +14390,30 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.ctbCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pStdReferenceFinalLists ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.constantQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoEXT.pStdSliceSegmentHeader ); return seed; } }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT const & videoEncodeH265PictureInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.naluSliceSegmentEntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.pNaluSliceSegmentEntries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoEXT.pStdPictureInfo ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14282,6 +14444,29 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT const & videoEncodeH265QualityLevelPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredRateControlFlags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredGopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredIdrPeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredConsecutiveBFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredSubLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredConstantQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredMaxL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesEXT.preferredMaxL1ReferenceCount ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14291,10 +14476,10 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.flags ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.gopFrameCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.idrPeriod ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.rateControlStructure ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoEXT.subLayerCount ); return seed; } @@ -14311,9 +14496,6 @@ namespace std std::size_t seed = 0; VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.temporalId ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useInitialRcQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.initialRcQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.minQp ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp ); @@ -14325,6 +14507,22 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT const & videoEncodeH265SessionCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.useMaxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoEXT.maxLevelIdc ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14367,17 +14565,38 @@ namespace std # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> - struct hash + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT const & videoEncodeH265SessionParametersFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.hasStdVPSOverrides ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.hasStdSPSOverrides ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoEXT.hasStdPPSOverrides ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const & videoEncodeH265VclFrameInfoEXT ) const VULKAN_HPP_NOEXCEPT + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT const & videoEncodeH265SessionParametersGetInfoEXT ) const + VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pStdReferenceFinalLists ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.naluSliceSegmentEntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pNaluSliceSegmentEntries ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pStdPictureInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.writeStdVPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.writeStdSPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.writeStdPPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.stdVPSId ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.stdSPSId ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoEXT.stdPPSId ); return seed; } }; @@ -14393,7 +14612,6 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.qualityLevel ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange ); @@ -14407,6 +14625,37 @@ namespace std }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_ENABLE_BETA_EXTENSIONS ) template <> struct hash @@ -14420,8 +14669,6 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.virtualBufferSizeInMs ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.initialVirtualBufferSizeInMs ); return seed; } }; @@ -14440,6 +14687,40 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount ); VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters ); return seed; } }; @@ -14493,22 +14774,6 @@ namespace std } }; - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); - return seed; - } - }; - template <> struct hash { diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp index cb86db7..52ec380 100644 --- a/include/vulkan/vulkan_raii.hpp +++ b/include/vulkan/vulkan_raii.hpp @@ -341,6 +341,12 @@ namespace VULKAN_HPP_NAMESPACE vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) ); +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_NV_acquire_winrt_display === vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); @@ -424,8 +430,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; # else - PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_XLIB_KHR*/ # if defined( VK_USE_PLATFORM_XCB_KHR ) @@ -433,8 +439,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; # else - PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_XCB_KHR*/ # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) @@ -442,15 +448,15 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; # else - PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ # if defined( VK_USE_PLATFORM_ANDROID_KHR ) //=== VK_KHR_android_surface === PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; # else - PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; + PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ # if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -458,8 +464,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; # else - PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; + PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_EXT_debug_report === @@ -475,7 +481,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_GGP_stream_descriptor_surface === PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; # else - PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; + PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; # endif /*VK_USE_PLATFORM_GGP*/ //=== VK_NV_external_memory_capabilities === @@ -494,7 +500,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NN_vi_surface === PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; # else - PFN_dummy vkCreateViSurfaceNN_placeholder = 0; + PFN_dummy vkCreateViSurfaceNN_placeholder = 0; # endif /*VK_USE_PLATFORM_VI_NN*/ //=== VK_KHR_device_group_creation === @@ -514,8 +520,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; # else - PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; - PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; + PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; + PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ //=== VK_EXT_display_surface_counter === @@ -542,14 +548,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_MVK_ios_surface === PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; # else - PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; + PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; # endif /*VK_USE_PLATFORM_IOS_MVK*/ # if defined( VK_USE_PLATFORM_MACOS_MVK ) //=== VK_MVK_macos_surface === PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; # else - PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; + PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; # endif /*VK_USE_PLATFORM_MACOS_MVK*/ //=== VK_EXT_debug_utils === @@ -567,14 +573,14 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_FUCHSIA_imagepipe_surface === PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; # else - PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; + PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; # endif /*VK_USE_PLATFORM_FUCHSIA*/ # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_surface === PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; # else - PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; + PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; # endif /*VK_USE_PLATFORM_METAL_EXT*/ //=== VK_KHR_fragment_shading_rate === @@ -593,7 +599,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_full_screen_exclusive === PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; # else - PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_EXT_headless_surface === @@ -603,13 +609,20 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0; +# else + PFN_dummy vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR_placeholder = 0; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_NV_acquire_winrt_display === PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; # else - PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; - PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; + PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; + PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) @@ -617,8 +630,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; # else - PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; + PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ # if defined( VK_USE_PLATFORM_SCREEN_QNX ) @@ -626,8 +639,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; # else - PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; + PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ //=== VK_NV_optical_flow === @@ -1343,6 +1356,8 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === + vkGetEncodedVideoSessionParametersKHR = + PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) ); vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); # endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -1873,7 +1888,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_external_memory_win32 === PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; # else - PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_device_group === @@ -1889,8 +1904,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; # else - PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_external_memory_fd === @@ -1902,8 +1917,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; # else - PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; + PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_external_semaphore_fd === @@ -1958,8 +1973,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; # else - PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; + PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_external_fence_fd === @@ -1985,8 +2000,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; # else - PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; - PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; + PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; + PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ //=== VK_EXT_sample_locations === @@ -2123,9 +2138,9 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; # else - PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; + PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ //=== VK_KHR_buffer_device_address === @@ -2188,16 +2203,18 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === - PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; + PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0; + PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; # else - PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; + PFN_dummy vkGetEncodedVideoSessionParametersKHR_placeholder = 0; + PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; # else - PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; + PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; # endif /*VK_USE_PLATFORM_METAL_EXT*/ //=== VK_KHR_synchronization2 === @@ -2253,8 +2270,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; # else - PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; + PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; # endif /*VK_USE_PLATFORM_FUCHSIA*/ # if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -2262,8 +2279,8 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; # else - PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; # endif /*VK_USE_PLATFORM_FUCHSIA*/ # if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -2274,11 +2291,11 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; # else - PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; + PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; # endif /*VK_USE_PLATFORM_FUCHSIA*/ //=== VK_HUAWEI_subpass_shading === @@ -3210,6 +3227,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR + getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain + getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_USE_PLATFORM_WIN32_KHR ) //=== VK_NV_acquire_winrt_display === @@ -4009,6 +4037,17 @@ namespace VULKAN_HPP_NAMESPACE uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_video_encode_queue === + + VULKAN_HPP_NODISCARD std::pair> + getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; + + template + VULKAN_HPP_NODISCARD std::pair, std::vector> + getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -18285,6 +18324,120 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_KHR_video_encode_queue === + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( + const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; + VkResult result = getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + static_cast( m_physicalDevice ), + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return qualityLevelProperties; + } + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( + const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && + "Function requires " ); + + StructureChain structureChain; + VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = + structureChain.template get(); + VkResult result = getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + static_cast( m_physicalDevice ), + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return structureChain; + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair> + Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && + "Function requires " ); + + std::pair> data_; + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; + std::vector & data = data_.second; + size_t dataSize; + VkResult result; + do + { + result = getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + data.resize( dataSize ); + result = getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return data_; + } + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair, std::vector> + Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && + "Function requires " ); + + std::pair, std::vector> data_; + VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = + data_.first.template get(); + std::vector & data = data_.second; + size_t dataSize; + VkResult result; + do + { + result = getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + structureChains.resize( dataSize ); + data.resize( dataSize ); + for ( size_t i = 0; i < dataSize; i++ ) + { + data[i].pNext = structureChains[i].template get().pNext; + } + result = getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return data_; + } + VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEncodeVideoKHR && "Function requires " ); diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp index e366864..f17770b 100644 --- a/include/vulkan/vulkan_static_assertions.hpp +++ b/include/vulkan/vulkan_static_assertions.hpp @@ -2229,6 +2229,20 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "VideoEncodeH264CapabilitiesEXT is not nothrow_move_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesEXT ) == sizeof( VkVideoEncodeH264QualityLevelPropertiesEXT ), + "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, + "VideoEncodeH264QualityLevelPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoEXT ) == sizeof( VkVideoEncodeH264SessionCreateInfoEXT ), + "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, + "VideoEncodeH264SessionCreateInfoEXT is not nothrow_move_constructible!" ); + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT ) == sizeof( VkVideoEncodeH264SessionParametersCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -2244,11 +2258,26 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "VideoEncodeH264SessionParametersAddInfoEXT is not nothrow_move_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT ) == sizeof( VkVideoEncodeH264VclFrameInfoEXT ), +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoEXT ) == sizeof( VkVideoEncodeH264SessionParametersGetInfoEXT ), + "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, + "VideoEncodeH264SessionParametersGetInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoEXT ) == + sizeof( VkVideoEncodeH264SessionParametersFeedbackInfoEXT ), + "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, + "VideoEncodeH264SessionParametersFeedbackInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoEXT ) == sizeof( VkVideoEncodeH264PictureInfoEXT ), "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, - "VideoEncodeH264VclFrameInfoEXT is not nothrow_move_constructible!" ); +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, + "VideoEncodeH264PictureInfoEXT is not nothrow_move_constructible!" ); VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT ) == sizeof( VkVideoEncodeH264DpbSlotInfoEXT ), "struct and wrapper have different size!" ); @@ -2291,6 +2320,13 @@ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSize 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, "VideoEncodeH264FrameSizeEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoEXT ) == sizeof( VkVideoEncodeH264GopRemainingFrameInfoEXT ), + "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, + "VideoEncodeH264GopRemainingFrameInfoEXT is not nothrow_move_constructible!" ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -2302,6 +2338,20 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "VideoEncodeH265CapabilitiesEXT is not nothrow_move_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoEXT ) == sizeof( VkVideoEncodeH265SessionCreateInfoEXT ), + "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, + "VideoEncodeH265SessionCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesEXT ) == sizeof( VkVideoEncodeH265QualityLevelPropertiesEXT ), + "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, + "VideoEncodeH265QualityLevelPropertiesEXT is not nothrow_move_constructible!" ); + VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT ) == sizeof( VkVideoEncodeH265SessionParametersCreateInfoEXT ), "struct and wrapper have different size!" ); @@ -2317,11 +2367,26 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "VideoEncodeH265SessionParametersAddInfoEXT is not nothrow_move_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT ) == sizeof( VkVideoEncodeH265VclFrameInfoEXT ), +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoEXT ) == sizeof( VkVideoEncodeH265SessionParametersGetInfoEXT ), + "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, + "VideoEncodeH265SessionParametersGetInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoEXT ) == + sizeof( VkVideoEncodeH265SessionParametersFeedbackInfoEXT ), + "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, + "VideoEncodeH265SessionParametersFeedbackInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoEXT ) == sizeof( VkVideoEncodeH265PictureInfoEXT ), "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, - "VideoEncodeH265VclFrameInfoEXT is not nothrow_move_constructible!" ); +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, + "VideoEncodeH265PictureInfoEXT is not nothrow_move_constructible!" ); VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT ) == sizeof( VkVideoEncodeH265DpbSlotInfoEXT ), "struct and wrapper have different size!" ); @@ -2365,6 +2430,13 @@ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSize 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, "VideoEncodeH265FrameSizeEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoEXT ) == sizeof( VkVideoEncodeH265GopRemainingFrameInfoEXT ), + "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, + "VideoEncodeH265GopRemainingFrameInfoEXT is not nothrow_move_constructible!" ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_KHR_video_decode_h264 === @@ -4856,6 +4928,42 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "VideoEncodeRateControlLayerInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR ) == + sizeof( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR ), + "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, + "PhysicalDeviceVideoEncodeQualityLevelInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeQualityLevelPropertiesKHR ), + "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, + "VideoEncodeQualityLevelPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR ) == sizeof( VkVideoEncodeQualityLevelInfoKHR ), + "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, + "VideoEncodeQualityLevelInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR ) == sizeof( VkVideoEncodeSessionParametersGetInfoKHR ), + "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, + "VideoEncodeSessionParametersGetInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR ) == + sizeof( VkVideoEncodeSessionParametersFeedbackInfoKHR ), + "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, + "VideoEncodeSessionParametersFeedbackInfoKHR is not nothrow_move_constructible!" ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_NV_device_diagnostics_config === diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index 8e39452..14e6731 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -77551,6 +77551,247 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; }; + struct VideoProfileInfoKHR + { + using NativeType = VkVideoProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( + VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone, + VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ = {}, + VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ = {}, + VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , videoCodecOperation( videoCodecOperation_ ) + , chromaSubsampling( chromaSubsampling_ ) + , lumaBitDepth( lumaBitDepth_ ) + , chromaBitDepth( chromaBitDepth_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoProfileInfoKHR( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoProfileInfoKHR & operator=( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoProfileInfoKHR & operator=( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & + setVideoCodecOperation( VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) VULKAN_HPP_NOEXCEPT + { + videoCodecOperation = videoCodecOperation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & + setChromaSubsampling( VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) VULKAN_HPP_NOEXCEPT + { + chromaSubsampling = chromaSubsampling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setLumaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) VULKAN_HPP_NOEXCEPT + { + lumaBitDepth = lumaBitDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) VULKAN_HPP_NOEXCEPT + { + chromaBitDepth = chromaBitDepth_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoProfileInfoKHR &() 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, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoProfileInfoKHR const & ) const = default; +#else + bool operator==( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) && + ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && ( chromaBitDepth == rhs.chromaBitDepth ); +# endif + } + + bool operator!=( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoProfileInfoKHR; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone; + VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling = {}; + VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth = {}; + VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth = {}; + }; + + template <> + struct CppType + { + using Type = VideoProfileInfoKHR; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR + { + using NativeType = VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile_ = {}, + uint32_t qualityLevel_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , pVideoProfile( pVideoProfile_ ) + , qualityLevel( qualityLevel_ ) + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoEncodeQualityLevelInfoKHR( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoEncodeQualityLevelInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & + setPVideoProfile( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile_ ) VULKAN_HPP_NOEXCEPT + { + pVideoProfile = pVideoProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) VULKAN_HPP_NOEXCEPT + { + qualityLevel = qualityLevel_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR &() 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, pVideoProfile, qualityLevel ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & ) const = default; +# else + bool operator==( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVideoProfile == rhs.pVideoProfile ) && ( qualityLevel == rhs.qualityLevel ); +# endif + } + + bool operator!=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR; + const void * pNext = {}; + const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile = {}; + uint32_t qualityLevel = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeQualityLevelInfoKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + struct PhysicalDeviceVideoFormatInfoKHR { using NativeType = VkPhysicalDeviceVideoFormatInfoKHR; @@ -104110,19 +104351,21 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeCapabilitiesKHR; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes_ = {}, - uint32_t maxRateControlLayers_ = {}, - uint32_t maxQualityLevels_ = {}, - VULKAN_HPP_NAMESPACE::Extent2D inputImageDataFillAlignment_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags_ = {}, + VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes_ = {}, + uint32_t maxRateControlLayers_ = {}, + uint64_t maxBitrate_ = {}, + uint32_t maxQualityLevels_ = {}, + VULKAN_HPP_NAMESPACE::Extent2D encodeInputPictureGranularity_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) , flags( flags_ ) , rateControlModes( rateControlModes_ ) , maxRateControlLayers( maxRateControlLayers_ ) + , maxBitrate( maxBitrate_ ) , maxQualityLevels( maxQualityLevels_ ) - , inputImageDataFillAlignment( inputImageDataFillAlignment_ ) + , encodeInputPictureGranularity( encodeInputPictureGranularity_ ) , supportedEncodeFeedbackFlags( supportedEncodeFeedbackFlags_ ) { } @@ -104162,14 +104405,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR const &, VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR const &, uint32_t const &, + uint64_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::Extent2D const &, VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( - sType, pNext, flags, rateControlModes, maxRateControlLayers, maxQualityLevels, inputImageDataFillAlignment, supportedEncodeFeedbackFlags ); + return std::tie( sType, + pNext, + flags, + rateControlModes, + maxRateControlLayers, + maxBitrate, + maxQualityLevels, + encodeInputPictureGranularity, + supportedEncodeFeedbackFlags ); } # endif @@ -104182,8 +104433,8 @@ namespace VULKAN_HPP_NAMESPACE return this->reflect() == rhs.reflect(); # else return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlModes == rhs.rateControlModes ) && - ( maxRateControlLayers == rhs.maxRateControlLayers ) && ( maxQualityLevels == rhs.maxQualityLevels ) && - ( inputImageDataFillAlignment == rhs.inputImageDataFillAlignment ) && ( supportedEncodeFeedbackFlags == rhs.supportedEncodeFeedbackFlags ); + ( maxRateControlLayers == rhs.maxRateControlLayers ) && ( maxBitrate == rhs.maxBitrate ) && ( maxQualityLevels == rhs.maxQualityLevels ) && + ( encodeInputPictureGranularity == rhs.encodeInputPictureGranularity ) && ( supportedEncodeFeedbackFlags == rhs.supportedEncodeFeedbackFlags ); # endif } @@ -104194,14 +104445,15 @@ namespace VULKAN_HPP_NAMESPACE # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeCapabilitiesKHR; - void * pNext = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes = {}; - uint32_t maxRateControlLayers = {}; - uint32_t maxQualityLevels = {}; - VULKAN_HPP_NAMESPACE::Extent2D inputImageDataFillAlignment = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeCapabilitiesKHR; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes = {}; + uint32_t maxRateControlLayers = {}; + uint64_t maxBitrate = {}; + uint32_t maxQualityLevels = {}; + VULKAN_HPP_NAMESPACE::Extent2D encodeInputPictureGranularity = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags = {}; }; template <> @@ -104220,26 +104472,34 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264CapabilitiesEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {}, - uint32_t maxPPictureL0ReferenceCount_ = {}, - uint32_t maxBPictureL0ReferenceCount_ = {}, - uint32_t maxL1ReferenceCount_ = {}, - VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag_ = {}, - uint32_t maxBytesPerPicDenom_ = {}, - uint32_t maxBitsPerMbDenom_ = {}, - uint32_t log2MaxMvLengthHorizontal_ = {}, - uint32_t log2MaxMvLengthVertical_ = {}, + VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {}, + StdVideoH264LevelIdc maxLevelIdc_ = {}, + uint32_t maxSliceCount_ = {}, + uint32_t maxPPictureL0ReferenceCount_ = {}, + uint32_t maxBPictureL0ReferenceCount_ = {}, + uint32_t maxL1ReferenceCount_ = {}, + uint32_t maxTemporalLayerCount_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalLayerPattern_ = {}, + int32_t minQp_ = {}, + int32_t maxQp_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT stdSyntaxFlags_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) , flags( flags_ ) + , maxLevelIdc( maxLevelIdc_ ) + , maxSliceCount( maxSliceCount_ ) , maxPPictureL0ReferenceCount( maxPPictureL0ReferenceCount_ ) , maxBPictureL0ReferenceCount( maxBPictureL0ReferenceCount_ ) , maxL1ReferenceCount( maxL1ReferenceCount_ ) - , motionVectorsOverPicBoundariesFlag( motionVectorsOverPicBoundariesFlag_ ) - , maxBytesPerPicDenom( maxBytesPerPicDenom_ ) - , maxBitsPerMbDenom( maxBitsPerMbDenom_ ) - , log2MaxMvLengthHorizontal( log2MaxMvLengthHorizontal_ ) - , log2MaxMvLengthVertical( log2MaxMvLengthVertical_ ) + , maxTemporalLayerCount( maxTemporalLayerCount_ ) + , expectDyadicTemporalLayerPattern( expectDyadicTemporalLayerPattern_ ) + , minQp( minQp_ ) + , maxQp( maxQp_ ) + , prefersGopRemainingFrames( prefersGopRemainingFrames_ ) + , requiresGopRemainingFrames( requiresGopRemainingFrames_ ) + , stdSyntaxFlags( stdSyntaxFlags_ ) { } @@ -104276,65 +104536,109 @@ namespace VULKAN_HPP_NAMESPACE std::tuple + VULKAN_HPP_NAMESPACE::Bool32 const &, + int32_t const &, + int32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, + maxLevelIdc, + maxSliceCount, maxPPictureL0ReferenceCount, maxBPictureL0ReferenceCount, maxL1ReferenceCount, - motionVectorsOverPicBoundariesFlag, - maxBytesPerPicDenom, - maxBitsPerMbDenom, - log2MaxMvLengthHorizontal, - log2MaxMvLengthVertical ); + maxTemporalLayerCount, + expectDyadicTemporalLayerPattern, + minQp, + maxQp, + prefersGopRemainingFrames, + requiresGopRemainingFrames, + stdSyntaxFlags ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default; -# else - bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + std::strong_ordering operator<=>( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && - ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && - ( motionVectorsOverPicBoundariesFlag == rhs.motionVectorsOverPicBoundariesFlag ) && ( maxBytesPerPicDenom == rhs.maxBytesPerPicDenom ) && - ( maxBitsPerMbDenom == rhs.maxBitsPerMbDenom ) && ( log2MaxMvLengthHorizontal == rhs.log2MaxMvLengthHorizontal ) && - ( log2MaxMvLengthVertical == rhs.log2MaxMvLengthVertical ); -# endif + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = maxSliceCount <=> rhs.maxSliceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxTemporalLayerCount <=> rhs.maxTemporalLayerCount; cmp != 0 ) + return cmp; + if ( auto cmp = expectDyadicTemporalLayerPattern <=> rhs.expectDyadicTemporalLayerPattern; cmp != 0 ) + return cmp; + if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 ) + return cmp; + if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 ) + return cmp; + if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; } +# endif - bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ) && ( maxSliceCount == rhs.maxSliceCount ) && + ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && + ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxTemporalLayerCount == rhs.maxTemporalLayerCount ) && + ( expectDyadicTemporalLayerPattern == rhs.expectDyadicTemporalLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) && + ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && + ( stdSyntaxFlags == rhs.stdSyntaxFlags ); + } + + bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -# endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT; - void * pNext = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {}; - uint32_t maxPPictureL0ReferenceCount = {}; - uint32_t maxBPictureL0ReferenceCount = {}; - uint32_t maxL1ReferenceCount = {}; - VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag = {}; - uint32_t maxBytesPerPicDenom = {}; - uint32_t maxBitsPerMbDenom = {}; - uint32_t log2MaxMvLengthHorizontal = {}; - uint32_t log2MaxMvLengthVertical = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {}; + StdVideoH264LevelIdc maxLevelIdc = {}; + uint32_t maxSliceCount = {}; + uint32_t maxPPictureL0ReferenceCount = {}; + uint32_t maxBPictureL0ReferenceCount = {}; + uint32_t maxL1ReferenceCount = {}; + uint32_t maxTemporalLayerCount = {}; + VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalLayerPattern = {}; + int32_t minQp = {}; + int32_t maxQp = {}; + VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames = {}; + VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsEXT stdSyntaxFlags = {}; }; template <> @@ -104540,6 +104844,139 @@ namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH264GopRemainingFrameInfoEXT + { + using NativeType = VkVideoEncodeH264GopRemainingFrameInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ = {}, + uint32_t gopRemainingI_ = {}, + uint32_t gopRemainingP_ = {}, + uint32_t gopRemainingB_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , useGopRemainingFrames( useGopRemainingFrames_ ) + , gopRemainingI( gopRemainingI_ ) + , gopRemainingP( gopRemainingP_ ) + , gopRemainingB( gopRemainingB_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoEXT( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264GopRemainingFrameInfoEXT( VkVideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264GopRemainingFrameInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264GopRemainingFrameInfoEXT & operator=( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH264GopRemainingFrameInfoEXT & operator=( VkVideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & + setUseGopRemainingFrames( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ ) VULKAN_HPP_NOEXCEPT + { + useGopRemainingFrames = useGopRemainingFrames_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setGopRemainingI( uint32_t gopRemainingI_ ) VULKAN_HPP_NOEXCEPT + { + gopRemainingI = gopRemainingI_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setGopRemainingP( uint32_t gopRemainingP_ ) VULKAN_HPP_NOEXCEPT + { + gopRemainingP = gopRemainingP_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoEXT & setGopRemainingB( uint32_t gopRemainingB_ ) VULKAN_HPP_NOEXCEPT + { + gopRemainingB = gopRemainingB_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeH264GopRemainingFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264GopRemainingFrameInfoEXT &() 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, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264GopRemainingFrameInfoEXT const & ) const = default; +# else + bool operator==( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && + ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB ); +# endif + } + + bool operator!=( VideoEncodeH264GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames = {}; + uint32_t gopRemainingI = {}; + uint32_t gopRemainingP = {}; + uint32_t gopRemainingB = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH264GopRemainingFrameInfoEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + #if defined( VK_ENABLE_BETA_EXTENSIONS ) struct VideoEncodeH264NaluSliceInfoEXT { @@ -104549,13 +104986,11 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264NaluSliceInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoEXT( uint32_t mbCount_ = {}, - const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ = {}, - const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoEXT( int32_t constantQp_ = {}, + const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , mbCount( mbCount_ ) - , pStdReferenceFinalLists( pStdReferenceFinalLists_ ) + , constantQp( constantQp_ ) , pStdSliceHeader( pStdSliceHeader_ ) { } @@ -104583,16 +105018,9 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoEXT & setMbCount( uint32_t mbCount_ ) VULKAN_HPP_NOEXCEPT - { - mbCount = mbCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoEXT & - setPStdReferenceFinalLists( const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoEXT & setConstantQp( int32_t constantQp_ ) VULKAN_HPP_NOEXCEPT { - pStdReferenceFinalLists = pStdReferenceFinalLists_; + constantQp = constantQp_; return *this; } @@ -104617,15 +105045,11 @@ namespace VULKAN_HPP_NAMESPACE # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, mbCount, pStdReferenceFinalLists, pStdSliceHeader ); + return std::tie( sType, pNext, constantQp, pStdSliceHeader ); } # endif @@ -104637,8 +105061,7 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mbCount == rhs.mbCount ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) && - ( pStdSliceHeader == rhs.pStdSliceHeader ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceHeader == rhs.pStdSliceHeader ); # endif } @@ -104649,11 +105072,10 @@ namespace VULKAN_HPP_NAMESPACE # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264NaluSliceInfoEXT; - const void * pNext = {}; - uint32_t mbCount = {}; - const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists = {}; - const StdVideoEncodeH264SliceHeader * pStdSliceHeader = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264NaluSliceInfoEXT; + const void * pNext = {}; + int32_t constantQp = {}; + const StdVideoEncodeH264SliceHeader * pStdSliceHeader = {}; }; template <> @@ -104663,6 +105085,164 @@ namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH264PictureInfoEXT + { + using NativeType = VkVideoEncodeH264PictureInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264PictureInfoEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoEXT( uint32_t naluSliceEntryCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ = {}, + const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , naluSliceEntryCount( naluSliceEntryCount_ ) + , pNaluSliceEntries( pNaluSliceEntries_ ) + , pStdPictureInfo( pStdPictureInfo_ ) + , generatePrefixNalu( generatePrefixNalu_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoEXT( VideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264PictureInfoEXT( VkVideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264PictureInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264PictureInfoEXT( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceEntries_, + const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , naluSliceEntryCount( static_cast( naluSliceEntries_.size() ) ) + , pNaluSliceEntries( naluSliceEntries_.data() ) + , pStdPictureInfo( pStdPictureInfo_ ) + , generatePrefixNalu( generatePrefixNalu_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeH264PictureInfoEXT & operator=( VideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH264PictureInfoEXT & operator=( VkVideoEncodeH264PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) VULKAN_HPP_NOEXCEPT + { + naluSliceEntryCount = naluSliceEntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & + setPNaluSliceEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ ) VULKAN_HPP_NOEXCEPT + { + pNaluSliceEntries = pNaluSliceEntries_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264PictureInfoEXT & setNaluSliceEntries( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT + { + naluSliceEntryCount = static_cast( naluSliceEntries_.size() ); + pNaluSliceEntries = naluSliceEntries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoEXT & setGeneratePrefixNalu( VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu_ ) VULKAN_HPP_NOEXCEPT + { + generatePrefixNalu = generatePrefixNalu_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeH264PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264PictureInfoEXT &() 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, naluSliceEntryCount, pNaluSliceEntries, pStdPictureInfo, generatePrefixNalu ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264PictureInfoEXT const & ) const = default; +# else + bool operator==( VideoEncodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && + ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( generatePrefixNalu == rhs.generatePrefixNalu ); +# endif + } + + bool operator!=( VideoEncodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264PictureInfoEXT; + const void * pNext = {}; + uint32_t naluSliceEntryCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries = {}; + const StdVideoEncodeH264PictureInfo * pStdPictureInfo = {}; + VULKAN_HPP_NAMESPACE::Bool32 generatePrefixNalu = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH264PictureInfoEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + #if defined( VK_ENABLE_BETA_EXTENSIONS ) struct VideoEncodeH264ProfileInfoEXT { @@ -104864,75 +105444,207 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH264RateControlInfoEXT + struct VideoEncodeH264QualityLevelPropertiesEXT { - using NativeType = VkVideoEncodeH264RateControlInfoEXT; + using NativeType = VkVideoEncodeH264QualityLevelPropertiesEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264QualityLevelPropertiesEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( uint32_t gopFrameCount_ = {}, - uint32_t idrPeriod_ = {}, - uint32_t consecutiveBFrameCount_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT rateControlStructure_ = - VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT::eUnknown, - uint32_t temporalLayerCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT preferredRateControlFlags_ = {}, + uint32_t preferredGopFrameCount_ = {}, + uint32_t preferredIdrPeriod_ = {}, + uint32_t preferredConsecutiveBFrameCount_ = {}, + uint32_t preferredTemporalLayerCount_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT preferredConstantQp_ = {}, + uint32_t preferredMaxL0ReferenceCount_ = {}, + uint32_t preferredMaxL1ReferenceCount_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 preferredStdEntropyCodingModeFlag_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , gopFrameCount( gopFrameCount_ ) - , idrPeriod( idrPeriod_ ) - , consecutiveBFrameCount( consecutiveBFrameCount_ ) - , rateControlStructure( rateControlStructure_ ) - , temporalLayerCount( temporalLayerCount_ ) + , preferredRateControlFlags( preferredRateControlFlags_ ) + , preferredGopFrameCount( preferredGopFrameCount_ ) + , preferredIdrPeriod( preferredIdrPeriod_ ) + , preferredConsecutiveBFrameCount( preferredConsecutiveBFrameCount_ ) + , preferredTemporalLayerCount( preferredTemporalLayerCount_ ) + , preferredConstantQp( preferredConstantQp_ ) + , preferredMaxL0ReferenceCount( preferredMaxL0ReferenceCount_ ) + , preferredMaxL1ReferenceCount( preferredMaxL1ReferenceCount_ ) + , preferredStdEntropyCodingModeFlag( preferredStdEntropyCodingModeFlag_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesEXT( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH264RateControlInfoEXT( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264RateControlInfoEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH264QualityLevelPropertiesEXT( VkVideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264QualityLevelPropertiesEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH264RateControlInfoEXT & operator=( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH264QualityLevelPropertiesEXT & operator=( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH264RateControlInfoEXT & operator=( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH264QualityLevelPropertiesEXT & operator=( VkVideoEncodeH264QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } -# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH264QualityLevelPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { - pNext = pNext_; - return *this; + return *reinterpret_cast( this ); } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH264QualityLevelPropertiesEXT &() VULKAN_HPP_NOEXCEPT { - gopFrameCount = gopFrameCount_; - return *this; + return *reinterpret_cast( this ); } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT +# if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT { - idrPeriod = idrPeriod_; - return *this; + return std::tie( sType, + pNext, + preferredRateControlFlags, + preferredGopFrameCount, + preferredIdrPeriod, + preferredConsecutiveBFrameCount, + preferredTemporalLayerCount, + preferredConstantQp, + preferredMaxL0ReferenceCount, + preferredMaxL1ReferenceCount, + preferredStdEntropyCodingModeFlag ); } +# endif - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264QualityLevelPropertiesEXT const & ) const = default; +# else + bool operator==( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - consecutiveBFrameCount = consecutiveBFrameCount_; +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && + ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) && + ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredTemporalLayerCount == rhs.preferredTemporalLayerCount ) && + ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) && + ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount ) && + ( preferredStdEntropyCodingModeFlag == rhs.preferredStdEntropyCodingModeFlag ); +# endif + } + + bool operator!=( VideoEncodeH264QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264QualityLevelPropertiesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT preferredRateControlFlags = {}; + uint32_t preferredGopFrameCount = {}; + uint32_t preferredIdrPeriod = {}; + uint32_t preferredConsecutiveBFrameCount = {}; + uint32_t preferredTemporalLayerCount = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT preferredConstantQp = {}; + uint32_t preferredMaxL0ReferenceCount = {}; + uint32_t preferredMaxL1ReferenceCount = {}; + VULKAN_HPP_NAMESPACE::Bool32 preferredStdEntropyCodingModeFlag = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH264QualityLevelPropertiesEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH264RateControlInfoEXT + { + using NativeType = VkVideoEncodeH264RateControlInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlInfoEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT flags_ = {}, + uint32_t gopFrameCount_ = {}, + uint32_t idrPeriod_ = {}, + uint32_t consecutiveBFrameCount_ = {}, + uint32_t temporalLayerCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , flags( flags_ ) + , gopFrameCount( gopFrameCount_ ) + , idrPeriod( idrPeriod_ ) + , consecutiveBFrameCount( consecutiveBFrameCount_ ) + , temporalLayerCount( temporalLayerCount_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoEXT( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264RateControlInfoEXT( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264RateControlInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264RateControlInfoEXT & operator=( VideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH264RateControlInfoEXT & operator=( VkVideoEncodeH264RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT + { + gopFrameCount = gopFrameCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT + { + idrPeriod = idrPeriod_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & - setRateControlStructure( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT rateControlStructure_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT { - rateControlStructure = rateControlStructure_; + consecutiveBFrameCount = consecutiveBFrameCount_; return *this; } @@ -104959,15 +105671,15 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, temporalLayerCount ); + return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, temporalLayerCount ); } # endif @@ -104979,9 +105691,8 @@ namespace VULKAN_HPP_NAMESPACE # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && ( idrPeriod == rhs.idrPeriod ) && - ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( rateControlStructure == rhs.rateControlStructure ) && - ( temporalLayerCount == rhs.temporalLayerCount ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && + ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( temporalLayerCount == rhs.temporalLayerCount ); # endif } @@ -104992,13 +105703,13 @@ namespace VULKAN_HPP_NAMESPACE # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264RateControlInfoEXT; - const void * pNext = {}; - uint32_t gopFrameCount = {}; - uint32_t idrPeriod = {}; - uint32_t consecutiveBFrameCount = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT rateControlStructure = VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureEXT::eUnknown; - uint32_t temporalLayerCount = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264RateControlInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsEXT flags = {}; + uint32_t gopFrameCount = {}; + uint32_t idrPeriod = {}; + uint32_t consecutiveBFrameCount = {}; + uint32_t temporalLayerCount = {}; }; template <> @@ -105017,10 +105728,7 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlLayerInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoEXT( uint32_t temporalLayerId_ = {}, - VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT initialRcQp_ = {}, - VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {}, + VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {}, VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT minQp_ = {}, VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ = {}, VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT maxQp_ = {}, @@ -105028,9 +105736,6 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT maxFrameSize_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , temporalLayerId( temporalLayerId_ ) - , useInitialRcQp( useInitialRcQp_ ) - , initialRcQp( initialRcQp_ ) , useMinQp( useMinQp_ ) , minQp( minQp_ ) , useMaxQp( useMaxQp_ ) @@ -105063,25 +105768,6 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT & setTemporalLayerId( uint32_t temporalLayerId_ ) VULKAN_HPP_NOEXCEPT - { - temporalLayerId = temporalLayerId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT & setUseInitialRcQp( VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ ) VULKAN_HPP_NOEXCEPT - { - useInitialRcQp = useInitialRcQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT & - setInitialRcQp( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const & initialRcQp_ ) VULKAN_HPP_NOEXCEPT - { - initialRcQp = initialRcQp_; - return *this; - } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoEXT & setUseMinQp( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ ) VULKAN_HPP_NOEXCEPT { useMinQp = useMinQp_; @@ -105136,9 +105822,6 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuplereflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalLayerId == rhs.temporalLayerId ) && ( useInitialRcQp == rhs.useInitialRcQp ) && - ( initialRcQp == rhs.initialRcQp ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize ); # endif } @@ -105175,9 +105857,6 @@ namespace VULKAN_HPP_NAMESPACE public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264RateControlLayerInfoEXT; const void * pNext = {}; - uint32_t temporalLayerId = {}; - VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT initialRcQp = {}; VULKAN_HPP_NAMESPACE::Bool32 useMinQp = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT minQp = {}; VULKAN_HPP_NAMESPACE::Bool32 useMaxQp = {}; @@ -105193,6 +105872,123 @@ namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH264SessionCreateInfoEXT + { + using NativeType = VkVideoEncodeH264SessionCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionCreateInfoEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ = {}, + StdVideoH264LevelIdc maxLevelIdc_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , useMaxLevelIdc( useMaxLevelIdc_ ) + , maxLevelIdc( maxLevelIdc_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoEXT( VideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264SessionCreateInfoEXT( VkVideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264SessionCreateInfoEXT & operator=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH264SessionCreateInfoEXT & operator=( VkVideoEncodeH264SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoEXT & setUseMaxLevelIdc( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ ) VULKAN_HPP_NOEXCEPT + { + useMaxLevelIdc = useMaxLevelIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoEXT & setMaxLevelIdc( StdVideoH264LevelIdc maxLevelIdc_ ) VULKAN_HPP_NOEXCEPT + { + maxLevelIdc = maxLevelIdc_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeH264SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionCreateInfoEXT &() 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, useMaxLevelIdc, maxLevelIdc ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ); + } + + bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264SessionCreateInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc = {}; + StdVideoH264LevelIdc maxLevelIdc = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH264SessionCreateInfoEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + #if defined( VK_ENABLE_BETA_EXTENSIONS ) struct VideoEncodeH264SessionParametersAddInfoEXT { @@ -105484,222 +106280,281 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH264VclFrameInfoEXT + struct VideoEncodeH264SessionParametersFeedbackInfoEXT { - using NativeType = VkVideoEncodeH264VclFrameInfoEXT; + using NativeType = VkVideoEncodeH264SessionParametersFeedbackInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264VclFrameInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264VclFrameInfoEXT( const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ = {}, - uint32_t naluSliceEntryCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ = {}, - const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersFeedbackInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , pStdReferenceFinalLists( pStdReferenceFinalLists_ ) - , naluSliceEntryCount( naluSliceEntryCount_ ) - , pNaluSliceEntries( pNaluSliceEntries_ ) - , pStdPictureInfo( pStdPictureInfo_ ) + , hasStdSPSOverrides( hasStdSPSOverrides_ ) + , hasStdPPSOverrides( hasStdPPSOverrides_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH264VclFrameInfoEXT( VideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264VclFrameInfoEXT( VkVideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264VclFrameInfoEXT( *reinterpret_cast( &rhs ) ) - { - } + VULKAN_HPP_CONSTEXPR + VideoEncodeH264SessionParametersFeedbackInfoEXT( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264VclFrameInfoEXT( - const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceEntries_, - const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , pStdReferenceFinalLists( pStdReferenceFinalLists_ ) - , naluSliceEntryCount( static_cast( naluSliceEntries_.size() ) ) - , pNaluSliceEntries( naluSliceEntries_.data() ) - , pStdPictureInfo( pStdPictureInfo_ ) + VideoEncodeH264SessionParametersFeedbackInfoEXT( VkVideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionParametersFeedbackInfoEXT( *reinterpret_cast( &rhs ) ) { } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VideoEncodeH264VclFrameInfoEXT & operator=( VideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH264SessionParametersFeedbackInfoEXT & operator=( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH264VclFrameInfoEXT & operator=( VkVideoEncodeH264VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & - setPStdReferenceFinalLists( const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT - { - pStdReferenceFinalLists = pStdReferenceFinalLists_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) VULKAN_HPP_NOEXCEPT - { - naluSliceEntryCount = naluSliceEntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & - setPNaluSliceEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries_ ) VULKAN_HPP_NOEXCEPT - { - pNaluSliceEntries = pNaluSliceEntries_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264VclFrameInfoEXT & setNaluSliceEntries( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT - { - naluSliceEntryCount = static_cast( naluSliceEntries_.size() ); - pNaluSliceEntries = naluSliceEntries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264VclFrameInfoEXT & setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT + VideoEncodeH264SessionParametersFeedbackInfoEXT & operator=( VkVideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - pStdPictureInfo = pStdPictureInfo_; + *this = *reinterpret_cast( &rhs ); return *this; } -# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH264VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH264SessionParametersFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH264VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH264SessionParametersFeedbackInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, pStdReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pStdPictureInfo ); + return std::tie( sType, pNext, hasStdSPSOverrides, hasStdPPSOverrides ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default; + auto operator<=>( VideoEncodeH264SessionParametersFeedbackInfoEXT const & ) const = default; # else - bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) && - ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) && + ( hasStdPPSOverrides == rhs.hasStdPPSOverrides ); # endif } - bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH264SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264VclFrameInfoEXT; - const void * pNext = {}; - const StdVideoEncodeH264ReferenceListsInfo * pStdReferenceFinalLists = {}; - uint32_t naluSliceEntryCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoEXT * pNaluSliceEntries = {}; - const StdVideoEncodeH264PictureInfo * pStdPictureInfo = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides = {}; + VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH264VclFrameInfoEXT; + using Type = VideoEncodeH264SessionParametersFeedbackInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265CapabilitiesEXT + struct VideoEncodeH264SessionParametersGetInfoEXT { - using NativeType = VkVideoEncodeH265CapabilitiesEXT; + using NativeType = VkVideoEncodeH264SessionParametersGetInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265CapabilitiesEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersGetInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes_ = {}, - uint32_t maxPPictureL0ReferenceCount_ = {}, - uint32_t maxBPictureL0ReferenceCount_ = {}, - uint32_t maxL1ReferenceCount_ = {}, - uint32_t maxSubLayersCount_ = {}, - uint32_t minLog2MinLumaCodingBlockSizeMinus3_ = {}, - uint32_t maxLog2MinLumaCodingBlockSizeMinus3_ = {}, - uint32_t minLog2MinLumaTransformBlockSizeMinus2_ = {}, - uint32_t maxLog2MinLumaTransformBlockSizeMinus2_ = {}, - uint32_t minMaxTransformHierarchyDepthInter_ = {}, - uint32_t maxMaxTransformHierarchyDepthInter_ = {}, - uint32_t minMaxTransformHierarchyDepthIntra_ = {}, - uint32_t maxMaxTransformHierarchyDepthIntra_ = {}, - uint32_t maxDiffCuQpDeltaDepth_ = {}, - uint32_t minMaxNumMergeCand_ = {}, - uint32_t maxMaxNumMergeCand_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ = {}, + uint32_t stdSPSId_ = {}, + uint32_t stdPPSId_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , flags( flags_ ) - , ctbSizes( ctbSizes_ ) - , transformBlockSizes( transformBlockSizes_ ) - , maxPPictureL0ReferenceCount( maxPPictureL0ReferenceCount_ ) - , maxBPictureL0ReferenceCount( maxBPictureL0ReferenceCount_ ) - , maxL1ReferenceCount( maxL1ReferenceCount_ ) - , maxSubLayersCount( maxSubLayersCount_ ) - , minLog2MinLumaCodingBlockSizeMinus3( minLog2MinLumaCodingBlockSizeMinus3_ ) - , maxLog2MinLumaCodingBlockSizeMinus3( maxLog2MinLumaCodingBlockSizeMinus3_ ) - , minLog2MinLumaTransformBlockSizeMinus2( minLog2MinLumaTransformBlockSizeMinus2_ ) - , maxLog2MinLumaTransformBlockSizeMinus2( maxLog2MinLumaTransformBlockSizeMinus2_ ) - , minMaxTransformHierarchyDepthInter( minMaxTransformHierarchyDepthInter_ ) - , maxMaxTransformHierarchyDepthInter( maxMaxTransformHierarchyDepthInter_ ) - , minMaxTransformHierarchyDepthIntra( minMaxTransformHierarchyDepthIntra_ ) - , maxMaxTransformHierarchyDepthIntra( maxMaxTransformHierarchyDepthIntra_ ) - , maxDiffCuQpDeltaDepth( maxDiffCuQpDeltaDepth_ ) - , minMaxNumMergeCand( minMaxNumMergeCand_ ) - , maxMaxNumMergeCand( maxMaxNumMergeCand_ ) + , writeStdSPS( writeStdSPS_ ) + , writeStdPPS( writeStdPPS_ ) + , stdSPSId( stdSPSId_ ) + , stdPPSId( stdPPSId_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoEXT( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH265CapabilitiesEXT( VkVideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265CapabilitiesEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH264SessionParametersGetInfoEXT( VkVideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionParametersGetInfoEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH265CapabilitiesEXT & operator=( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH264SessionParametersGetInfoEXT & operator=( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH264SessionParametersGetInfoEXT & operator=( VkVideoEncodeH264SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setWriteStdSPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ ) VULKAN_HPP_NOEXCEPT + { + writeStdSPS = writeStdSPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setWriteStdPPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ ) VULKAN_HPP_NOEXCEPT + { + writeStdPPS = writeStdPPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setStdSPSId( uint32_t stdSPSId_ ) VULKAN_HPP_NOEXCEPT + { + stdSPSId = stdSPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoEXT & setStdPPSId( uint32_t stdPPSId_ ) VULKAN_HPP_NOEXCEPT + { + stdPPSId = stdPPSId_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeH264SessionParametersGetInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersGetInfoEXT &() 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, writeStdSPS, writeStdPPS, stdSPSId, stdPPSId ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264SessionParametersGetInfoEXT const & ) const = default; +# else + bool operator==( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdSPS == rhs.writeStdSPS ) && ( writeStdPPS == rhs.writeStdPPS ) && + ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId ); +# endif + } + + bool operator!=( VideoEncodeH264SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264SessionParametersGetInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS = {}; + VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS = {}; + uint32_t stdSPSId = {}; + uint32_t stdPPSId = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersGetInfoEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH265CapabilitiesEXT + { + using NativeType = VkVideoEncodeH265CapabilitiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265CapabilitiesEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags_ = {}, + StdVideoH265LevelIdc maxLevelIdc_ = {}, + uint32_t maxSliceSegmentCount_ = {}, + VULKAN_HPP_NAMESPACE::Extent2D maxTiles_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes_ = {}, + uint32_t maxPPictureL0ReferenceCount_ = {}, + uint32_t maxBPictureL0ReferenceCount_ = {}, + uint32_t maxL1ReferenceCount_ = {}, + uint32_t maxSubLayerCount_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalSubLayerPattern_ = {}, + int32_t minQp_ = {}, + int32_t maxQp_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT stdSyntaxFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , flags( flags_ ) + , maxLevelIdc( maxLevelIdc_ ) + , maxSliceSegmentCount( maxSliceSegmentCount_ ) + , maxTiles( maxTiles_ ) + , ctbSizes( ctbSizes_ ) + , transformBlockSizes( transformBlockSizes_ ) + , maxPPictureL0ReferenceCount( maxPPictureL0ReferenceCount_ ) + , maxBPictureL0ReferenceCount( maxBPictureL0ReferenceCount_ ) + , maxL1ReferenceCount( maxL1ReferenceCount_ ) + , maxSubLayerCount( maxSubLayerCount_ ) + , expectDyadicTemporalSubLayerPattern( expectDyadicTemporalSubLayerPattern_ ) + , minQp( minQp_ ) + , maxQp( maxQp_ ) + , prefersGopRemainingFrames( prefersGopRemainingFrames_ ) + , requiresGopRemainingFrames( requiresGopRemainingFrames_ ) + , stdSyntaxFlags( stdSyntaxFlags_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesEXT( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265CapabilitiesEXT( VkVideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265CapabilitiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265CapabilitiesEXT & operator=( VideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ VideoEncodeH265CapabilitiesEXT & operator=( VkVideoEncodeH265CapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT @@ -105725,99 +106580,125 @@ namespace VULKAN_HPP_NAMESPACE std::tuple + VULKAN_HPP_NAMESPACE::Bool32 const &, + int32_t const &, + int32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( sType, pNext, flags, + maxLevelIdc, + maxSliceSegmentCount, + maxTiles, ctbSizes, transformBlockSizes, maxPPictureL0ReferenceCount, maxBPictureL0ReferenceCount, maxL1ReferenceCount, - maxSubLayersCount, - minLog2MinLumaCodingBlockSizeMinus3, - maxLog2MinLumaCodingBlockSizeMinus3, - minLog2MinLumaTransformBlockSizeMinus2, - maxLog2MinLumaTransformBlockSizeMinus2, - minMaxTransformHierarchyDepthInter, - maxMaxTransformHierarchyDepthInter, - minMaxTransformHierarchyDepthIntra, - maxMaxTransformHierarchyDepthIntra, - maxDiffCuQpDeltaDepth, - minMaxNumMergeCand, - maxMaxNumMergeCand ); + maxSubLayerCount, + expectDyadicTemporalSubLayerPattern, + minQp, + maxQp, + prefersGopRemainingFrames, + requiresGopRemainingFrames, + stdSyntaxFlags ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default; -# else + std::strong_ordering operator<=>( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = maxSliceSegmentCount <=> rhs.maxSliceSegmentCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxTiles <=> rhs.maxTiles; cmp != 0 ) + return cmp; + if ( auto cmp = ctbSizes <=> rhs.ctbSizes; cmp != 0 ) + return cmp; + if ( auto cmp = transformBlockSizes <=> rhs.transformBlockSizes; cmp != 0 ) + return cmp; + if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxSubLayerCount <=> rhs.maxSubLayerCount; cmp != 0 ) + return cmp; + if ( auto cmp = expectDyadicTemporalSubLayerPattern <=> rhs.expectDyadicTemporalSubLayerPattern; cmp != 0 ) + return cmp; + if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 ) + return cmp; + if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 ) + return cmp; + if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +# endif + bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( ctbSizes == rhs.ctbSizes ) && - ( transformBlockSizes == rhs.transformBlockSizes ) && ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && - ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && - ( maxSubLayersCount == rhs.maxSubLayersCount ) && ( minLog2MinLumaCodingBlockSizeMinus3 == rhs.minLog2MinLumaCodingBlockSizeMinus3 ) && - ( maxLog2MinLumaCodingBlockSizeMinus3 == rhs.maxLog2MinLumaCodingBlockSizeMinus3 ) && - ( minLog2MinLumaTransformBlockSizeMinus2 == rhs.minLog2MinLumaTransformBlockSizeMinus2 ) && - ( maxLog2MinLumaTransformBlockSizeMinus2 == rhs.maxLog2MinLumaTransformBlockSizeMinus2 ) && - ( minMaxTransformHierarchyDepthInter == rhs.minMaxTransformHierarchyDepthInter ) && - ( maxMaxTransformHierarchyDepthInter == rhs.maxMaxTransformHierarchyDepthInter ) && - ( minMaxTransformHierarchyDepthIntra == rhs.minMaxTransformHierarchyDepthIntra ) && - ( maxMaxTransformHierarchyDepthIntra == rhs.maxMaxTransformHierarchyDepthIntra ) && ( maxDiffCuQpDeltaDepth == rhs.maxDiffCuQpDeltaDepth ) && - ( minMaxNumMergeCand == rhs.minMaxNumMergeCand ) && ( maxMaxNumMergeCand == rhs.maxMaxNumMergeCand ); -# endif + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ) && ( maxSliceSegmentCount == rhs.maxSliceSegmentCount ) && + ( maxTiles == rhs.maxTiles ) && ( ctbSizes == rhs.ctbSizes ) && ( transformBlockSizes == rhs.transformBlockSizes ) && + ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && + ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxSubLayerCount == rhs.maxSubLayerCount ) && + ( expectDyadicTemporalSubLayerPattern == rhs.expectDyadicTemporalSubLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) && + ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && + ( stdSyntaxFlags == rhs.stdSyntaxFlags ); } bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -# endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265CapabilitiesEXT; - void * pNext = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes = {}; - uint32_t maxPPictureL0ReferenceCount = {}; - uint32_t maxBPictureL0ReferenceCount = {}; - uint32_t maxL1ReferenceCount = {}; - uint32_t maxSubLayersCount = {}; - uint32_t minLog2MinLumaCodingBlockSizeMinus3 = {}; - uint32_t maxLog2MinLumaCodingBlockSizeMinus3 = {}; - uint32_t minLog2MinLumaTransformBlockSizeMinus2 = {}; - uint32_t maxLog2MinLumaTransformBlockSizeMinus2 = {}; - uint32_t minMaxTransformHierarchyDepthInter = {}; - uint32_t maxMaxTransformHierarchyDepthInter = {}; - uint32_t minMaxTransformHierarchyDepthIntra = {}; - uint32_t maxMaxTransformHierarchyDepthIntra = {}; - uint32_t maxDiffCuQpDeltaDepth = {}; - uint32_t minMaxNumMergeCand = {}; - uint32_t maxMaxNumMergeCand = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265CapabilitiesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags = {}; + StdVideoH265LevelIdc maxLevelIdc = {}; + uint32_t maxSliceSegmentCount = {}; + VULKAN_HPP_NAMESPACE::Extent2D maxTiles = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes = {}; + uint32_t maxPPictureL0ReferenceCount = {}; + uint32_t maxBPictureL0ReferenceCount = {}; + uint32_t maxL1ReferenceCount = {}; + uint32_t maxSubLayerCount = {}; + VULKAN_HPP_NAMESPACE::Bool32 expectDyadicTemporalSubLayerPattern = {}; + int32_t minQp = {}; + int32_t maxQp = {}; + VULKAN_HPP_NAMESPACE::Bool32 prefersGopRemainingFrames = {}; + VULKAN_HPP_NAMESPACE::Bool32 requiresGopRemainingFrames = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsEXT stdSyntaxFlags = {}; }; template <> @@ -106024,77 +106905,84 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265NaluSliceSegmentInfoEXT + struct VideoEncodeH265GopRemainingFrameInfoEXT { - using NativeType = VkVideoEncodeH265NaluSliceSegmentInfoEXT; + using NativeType = VkVideoEncodeH265GopRemainingFrameInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( uint32_t ctbCount_ = {}, - const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ = {}, - const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ = {}, + uint32_t gopRemainingI_ = {}, + uint32_t gopRemainingP_ = {}, + uint32_t gopRemainingB_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , ctbCount( ctbCount_ ) - , pStdReferenceFinalLists( pStdReferenceFinalLists_ ) - , pStdSliceSegmentHeader( pStdSliceSegmentHeader_ ) + , useGopRemainingFrames( useGopRemainingFrames_ ) + , gopRemainingI( gopRemainingI_ ) + , gopRemainingP( gopRemainingP_ ) + , gopRemainingB( gopRemainingB_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoEXT( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH265NaluSliceSegmentInfoEXT( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265NaluSliceSegmentInfoEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH265GopRemainingFrameInfoEXT( VkVideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265GopRemainingFrameInfoEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265GopRemainingFrameInfoEXT & operator=( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265GopRemainingFrameInfoEXT & operator=( VkVideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setCtbCount( uint32_t ctbCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & + setUseGopRemainingFrames( VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames_ ) VULKAN_HPP_NOEXCEPT { - ctbCount = ctbCount_; + useGopRemainingFrames = useGopRemainingFrames_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & - setPStdReferenceFinalLists( const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setGopRemainingI( uint32_t gopRemainingI_ ) VULKAN_HPP_NOEXCEPT { - pStdReferenceFinalLists = pStdReferenceFinalLists_; + gopRemainingI = gopRemainingI_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & - setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setGopRemainingP( uint32_t gopRemainingP_ ) VULKAN_HPP_NOEXCEPT { - pStdSliceSegmentHeader = pStdSliceSegmentHeader_; + gopRemainingP = gopRemainingP_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoEXT & setGopRemainingB( uint32_t gopRemainingB_ ) VULKAN_HPP_NOEXCEPT + { + gopRemainingB = gopRemainingB_; return *this; } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265NaluSliceSegmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265GopRemainingFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265NaluSliceSegmentInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265GopRemainingFrameInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) @@ -106103,515 +106991,562 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuple + uint32_t const &, + uint32_t const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, ctbCount, pStdReferenceFinalLists, pStdSliceSegmentHeader ); + return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265NaluSliceSegmentInfoEXT const & ) const = default; + auto operator<=>( VideoEncodeH265GopRemainingFrameInfoEXT const & ) const = default; # else - bool operator==( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) && - ( pStdSliceSegmentHeader == rhs.pStdSliceSegmentHeader ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && + ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB ); # endif } - bool operator!=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265GopRemainingFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT; - const void * pNext = {}; - uint32_t ctbCount = {}; - const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists = {}; - const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 useGopRemainingFrames = {}; + uint32_t gopRemainingI = {}; + uint32_t gopRemainingP = {}; + uint32_t gopRemainingB = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH265NaluSliceSegmentInfoEXT; + using Type = VideoEncodeH265GopRemainingFrameInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265ProfileInfoEXT + struct VideoEncodeH265NaluSliceSegmentInfoEXT { - using NativeType = VkVideoEncodeH265ProfileInfoEXT; + using NativeType = VkVideoEncodeH265NaluSliceSegmentInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265ProfileInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( int32_t constantQp_ = {}, + const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , stdProfileIdc( stdProfileIdc_ ) + , constantQp( constantQp_ ) + , pStdSliceSegmentHeader( pStdSliceSegmentHeader_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoEXT( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH265ProfileInfoEXT( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265ProfileInfoEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH265NaluSliceSegmentInfoEXT( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265NaluSliceSegmentInfoEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH265ProfileInfoEXT & operator=( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265ProfileInfoEXT & operator=( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265NaluSliceSegmentInfoEXT & operator=( VkVideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & setConstantQp( int32_t constantQp_ ) VULKAN_HPP_NOEXCEPT { - stdProfileIdc = stdProfileIdc_; + constantQp = constantQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoEXT & + setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) VULKAN_HPP_NOEXCEPT + { + pStdSliceSegmentHeader = pStdSliceSegmentHeader_; return *this; } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265ProfileInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265NaluSliceSegmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265ProfileInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265NaluSliceSegmentInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, stdProfileIdc ); + return std::tie( sType, pNext, constantQp, pStdSliceSegmentHeader ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + auto operator<=>( VideoEncodeH265NaluSliceSegmentInfoEXT const & ) const = default; +# else + bool operator==( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceSegmentHeader == rhs.pStdSliceSegmentHeader ); +# endif } -# endif - bool operator==( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); - } - - bool operator!=( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265NaluSliceSegmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } +# endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265ProfileInfoEXT; - const void * pNext = {}; - StdVideoH265ProfileIdc stdProfileIdc = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT; + const void * pNext = {}; + int32_t constantQp = {}; + const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH265ProfileInfoEXT; + using Type = VideoEncodeH265NaluSliceSegmentInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265QpEXT + struct VideoEncodeH265PictureInfoEXT { - using NativeType = VkVideoEncodeH265QpEXT; + using NativeType = VkVideoEncodeH265PictureInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265PictureInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT - : qpI( qpI_ ) - , qpP( qpP_ ) - , qpB( qpB_ ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoEXT( uint32_t naluSliceSegmentEntryCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ = {}, + const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , naluSliceSegmentEntryCount( naluSliceSegmentEntryCount_ ) + , pNaluSliceSegmentEntries( pNaluSliceSegmentEntries_ ) + , pStdPictureInfo( pStdPictureInfo_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoEXT( VideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH265QpEXT( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265QpEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH265PictureInfoEXT( VkVideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265PictureInfoEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH265QpEXT & operator=( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265PictureInfoEXT( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceSegmentEntries_, + const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , naluSliceSegmentEntryCount( static_cast( naluSliceSegmentEntries_.size() ) ) + , pNaluSliceSegmentEntries( naluSliceSegmentEntries_.data() ) + , pStdPictureInfo( pStdPictureInfo_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeH265PictureInfoEXT & operator=( VideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265QpEXT & operator=( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265PictureInfoEXT & operator=( VkVideoEncodeH265PictureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpI( int32_t qpI_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { - qpI = qpI_; + pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpP( int32_t qpP_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT & setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) VULKAN_HPP_NOEXCEPT { - qpP = qpP_; + naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpB( int32_t qpB_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT & + setPNaluSliceSegmentEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ ) VULKAN_HPP_NOEXCEPT { - qpB = qpB_; + pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265PictureInfoEXT & setNaluSliceSegmentEntries( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceSegmentEntries_ ) + VULKAN_HPP_NOEXCEPT + { + naluSliceSegmentEntryCount = static_cast( naluSliceSegmentEntries_.size() ); + pNaluSliceSegmentEntries = naluSliceSegmentEntries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoEXT & setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; return *this; } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265PictureInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265PictureInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( qpI, qpP, qpB ); + return std::tie( sType, pNext, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pStdPictureInfo ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265QpEXT const & ) const = default; + auto operator<=>( VideoEncodeH265PictureInfoEXT const & ) const = default; # else - bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) && + ( pNaluSliceSegmentEntries == rhs.pNaluSliceSegmentEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ); # endif } - bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - int32_t qpI = {}; - int32_t qpP = {}; - int32_t qpB = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265PictureInfoEXT; + const void * pNext = {}; + uint32_t naluSliceSegmentEntryCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries = {}; + const StdVideoEncodeH265PictureInfo * pStdPictureInfo = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH265PictureInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265RateControlInfoEXT + struct VideoEncodeH265ProfileInfoEXT { - using NativeType = VkVideoEncodeH265RateControlInfoEXT; + using NativeType = VkVideoEncodeH265ProfileInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265ProfileInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( uint32_t gopFrameCount_ = {}, - uint32_t idrPeriod_ = {}, - uint32_t consecutiveBFrameCount_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT rateControlStructure_ = - VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT::eUnknown, - uint32_t subLayerCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , gopFrameCount( gopFrameCount_ ) - , idrPeriod( idrPeriod_ ) - , consecutiveBFrameCount( consecutiveBFrameCount_ ) - , rateControlStructure( rateControlStructure_ ) - , subLayerCount( subLayerCount_ ) + , stdProfileIdc( stdProfileIdc_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoEXT( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH265RateControlInfoEXT( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265RateControlInfoEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH265ProfileInfoEXT( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265ProfileInfoEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH265RateControlInfoEXT & operator=( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265ProfileInfoEXT & operator=( VideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265RateControlInfoEXT & operator=( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265ProfileInfoEXT & operator=( VkVideoEncodeH265ProfileInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT - { - gopFrameCount = gopFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT - { - idrPeriod = idrPeriod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT - { - consecutiveBFrameCount = consecutiveBFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & - setRateControlStructure( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT rateControlStructure_ ) VULKAN_HPP_NOEXCEPT - { - rateControlStructure = rateControlStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setSubLayerCount( uint32_t subLayerCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoEXT & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) VULKAN_HPP_NOEXCEPT { - subLayerCount = subLayerCount_; + stdProfileIdc = stdProfileIdc_; return *this; } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265ProfileInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265ProfileInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, subLayerCount ); + return std::tie( sType, pNext, stdProfileIdc ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default; -# else - bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + std::strong_ordering operator<=>( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && ( idrPeriod == rhs.idrPeriod ) && - ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( rateControlStructure == rhs.rateControlStructure ) && - ( subLayerCount == rhs.subLayerCount ); -# endif + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; } +# endif - bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); + } + + bool operator!=( VideoEncodeH265ProfileInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -# endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlInfoEXT; - const void * pNext = {}; - uint32_t gopFrameCount = {}; - uint32_t idrPeriod = {}; - uint32_t consecutiveBFrameCount = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT rateControlStructure = VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureEXT::eUnknown; - uint32_t subLayerCount = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265ProfileInfoEXT; + const void * pNext = {}; + StdVideoH265ProfileIdc stdProfileIdc = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH265RateControlInfoEXT; + using Type = VideoEncodeH265ProfileInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265RateControlLayerInfoEXT + struct VideoEncodeH265QpEXT { - using NativeType = VkVideoEncodeH265RateControlLayerInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT; + using NativeType = VkVideoEncodeH265QpEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( uint32_t temporalId_ = {}, - VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT initialRcQp_ = {}, - VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp_ = {}, - VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp_ = {}, - VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext( pNext_ ) - , temporalId( temporalId_ ) - , useInitialRcQp( useInitialRcQp_ ) - , initialRcQp( initialRcQp_ ) - , useMinQp( useMinQp_ ) - , minQp( minQp_ ) - , useMaxQp( useMaxQp_ ) - , maxQp( maxQp_ ) - , useMaxFrameSize( useMaxFrameSize_ ) - , maxFrameSize( maxFrameSize_ ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT + : qpI( qpI_ ) + , qpP( qpP_ ) + , qpB( qpB_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH265QpEXT( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH265RateControlLayerInfoEXT( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265RateControlLayerInfoEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH265QpEXT( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265QpEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH265RateControlLayerInfoEXT & operator=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265QpEXT & operator=( VideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265RateControlLayerInfoEXT & operator=( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265QpEXT & operator=( VkVideoEncodeH265QpEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpI( int32_t qpI_ ) VULKAN_HPP_NOEXCEPT { - pNext = pNext_; + qpI = qpI_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setTemporalId( uint32_t temporalId_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpP( int32_t qpP_ ) VULKAN_HPP_NOEXCEPT { - temporalId = temporalId_; + qpP = qpP_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseInitialRcQp( VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpEXT & setQpB( int32_t qpB_ ) VULKAN_HPP_NOEXCEPT { - useInitialRcQp = useInitialRcQp_; + qpB = qpB_; return *this; } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & - setInitialRcQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & initialRcQp_ ) VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265QpEXT const &() const VULKAN_HPP_NOEXCEPT { - initialRcQp = initialRcQp_; - return *this; + return *reinterpret_cast( this ); } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMinQp( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ ) VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265QpEXT &() VULKAN_HPP_NOEXCEPT { - useMinQp = useMinQp_; - return *this; + return *reinterpret_cast( this ); } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMinQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & minQp_ ) VULKAN_HPP_NOEXCEPT - { - minQp = minQp_; - return *this; - } +# if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( qpI, qpP, qpB ); + } +# endif - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxQp( VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ ) VULKAN_HPP_NOEXCEPT +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265QpEXT const & ) const = default; +# else + bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - useMaxQp = useMaxQp_; - return *this; +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); +# endif } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMaxQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & maxQp_ ) VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - maxQp = maxQp_; - return *this; + return !operator==( rhs ); } +# endif - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxFrameSize( VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ ) VULKAN_HPP_NOEXCEPT + public: + int32_t qpI = {}; + int32_t qpP = {}; + int32_t qpB = {}; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH265QualityLevelPropertiesEXT + { + using NativeType = VkVideoEncodeH265QualityLevelPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265QualityLevelPropertiesEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT preferredRateControlFlags_ = {}, + uint32_t preferredGopFrameCount_ = {}, + uint32_t preferredIdrPeriod_ = {}, + uint32_t preferredConsecutiveBFrameCount_ = {}, + uint32_t preferredSubLayerCount_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT preferredConstantQp_ = {}, + uint32_t preferredMaxL0ReferenceCount_ = {}, + uint32_t preferredMaxL1ReferenceCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , preferredRateControlFlags( preferredRateControlFlags_ ) + , preferredGopFrameCount( preferredGopFrameCount_ ) + , preferredIdrPeriod( preferredIdrPeriod_ ) + , preferredConsecutiveBFrameCount( preferredConsecutiveBFrameCount_ ) + , preferredSubLayerCount( preferredSubLayerCount_ ) + , preferredConstantQp( preferredConstantQp_ ) + , preferredMaxL0ReferenceCount( preferredMaxL0ReferenceCount_ ) + , preferredMaxL1ReferenceCount( preferredMaxL1ReferenceCount_ ) { - useMaxFrameSize = useMaxFrameSize_; - return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & - setMaxFrameSize( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & maxFrameSize_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesEXT( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265QualityLevelPropertiesEXT( VkVideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265QualityLevelPropertiesEXT( *reinterpret_cast( &rhs ) ) { - maxFrameSize = maxFrameSize_; + } + + VideoEncodeH265QualityLevelPropertiesEXT & operator=( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH265QualityLevelPropertiesEXT & operator=( VkVideoEncodeH265QualityLevelPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); return *this; } -# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265QualityLevelPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265QualityLevelPropertiesEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) @@ -106619,204 +107554,159 @@ namespace VULKAN_HPP_NAMESPACE auto # else std::tuple + uint32_t const &, + uint32_t const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, temporalId, useInitialRcQp, initialRcQp, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize ); + return std::tie( sType, + pNext, + preferredRateControlFlags, + preferredGopFrameCount, + preferredIdrPeriod, + preferredConsecutiveBFrameCount, + preferredSubLayerCount, + preferredConstantQp, + preferredMaxL0ReferenceCount, + preferredMaxL1ReferenceCount ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default; + auto operator<=>( VideoEncodeH265QualityLevelPropertiesEXT const & ) const = default; # else - bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalId == rhs.temporalId ) && ( useInitialRcQp == rhs.useInitialRcQp ) && - ( initialRcQp == rhs.initialRcQp ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && - ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && + ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) && + ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredSubLayerCount == rhs.preferredSubLayerCount ) && + ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) && + ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount ); # endif } - bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265QualityLevelPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT; - const void * pNext = {}; - uint32_t temporalId = {}; - VULKAN_HPP_NAMESPACE::Bool32 useInitialRcQp = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT initialRcQp = {}; - VULKAN_HPP_NAMESPACE::Bool32 useMinQp = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp = {}; - VULKAN_HPP_NAMESPACE::Bool32 useMaxQp = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp = {}; - VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265QualityLevelPropertiesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT preferredRateControlFlags = {}; + uint32_t preferredGopFrameCount = {}; + uint32_t preferredIdrPeriod = {}; + uint32_t preferredConsecutiveBFrameCount = {}; + uint32_t preferredSubLayerCount = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT preferredConstantQp = {}; + uint32_t preferredMaxL0ReferenceCount = {}; + uint32_t preferredMaxL1ReferenceCount = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH265RateControlLayerInfoEXT; + using Type = VideoEncodeH265QualityLevelPropertiesEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265SessionParametersAddInfoEXT + struct VideoEncodeH265RateControlInfoEXT { - using NativeType = VkVideoEncodeH265SessionParametersAddInfoEXT; + using NativeType = VkVideoEncodeH265RateControlInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( uint32_t stdVPSCount_ = {}, - const StdVideoH265VideoParameterSet * pStdVPSs_ = {}, - uint32_t stdSPSCount_ = {}, - const StdVideoH265SequenceParameterSet * pStdSPSs_ = {}, - uint32_t stdPPSCount_ = {}, - const StdVideoH265PictureParameterSet * pStdPPSs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT flags_ = {}, + uint32_t gopFrameCount_ = {}, + uint32_t idrPeriod_ = {}, + uint32_t consecutiveBFrameCount_ = {}, + uint32_t subLayerCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , stdVPSCount( stdVPSCount_ ) - , pStdVPSs( pStdVPSs_ ) - , stdSPSCount( stdSPSCount_ ) - , pStdSPSs( pStdSPSs_ ) - , stdPPSCount( stdPPSCount_ ) - , pStdPPSs( pStdPPSs_ ) + , flags( flags_ ) + , gopFrameCount( gopFrameCount_ ) + , idrPeriod( idrPeriod_ ) + , consecutiveBFrameCount( consecutiveBFrameCount_ ) + , subLayerCount( subLayerCount_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265SessionParametersAddInfoEXT( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265SessionParametersAddInfoEXT( *reinterpret_cast( &rhs ) ) - { - } + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoEXT( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoEXT( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdVPSs_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdSPSs_ = {}, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdPPSs_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stdVPSCount( static_cast( stdVPSs_.size() ) ) - , pStdVPSs( stdVPSs_.data() ) - , stdSPSCount( static_cast( stdSPSs_.size() ) ) - , pStdSPSs( stdSPSs_.data() ) - , stdPPSCount( static_cast( stdPPSs_.size() ) ) - , pStdPPSs( stdPPSs_.data() ) + VideoEncodeH265RateControlInfoEXT( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265RateControlInfoEXT( *reinterpret_cast( &rhs ) ) { } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VideoEncodeH265SessionParametersAddInfoEXT & operator=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265RateControlInfoEXT & operator=( VideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265SessionParametersAddInfoEXT & operator=( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265RateControlInfoEXT & operator=( VkVideoEncodeH265RateControlInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdVPSCount( uint32_t stdVPSCount_ ) VULKAN_HPP_NOEXCEPT - { - stdVPSCount = stdVPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) VULKAN_HPP_NOEXCEPT - { - pStdVPSs = pStdVPSs_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoEXT & - setStdVPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdVPSCount = static_cast( stdVPSs_.size() ); - pStdVPSs = stdVPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdSPSCount( uint32_t stdSPSCount_ ) VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT { - pStdSPSs = pStdSPSs_; + flags = flags_; return *this; } -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoEXT & - setStdSPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setGopFrameCount( uint32_t gopFrameCount_ ) VULKAN_HPP_NOEXCEPT { - stdSPSCount = static_cast( stdSPSs_.size() ); - pStdSPSs = stdSPSs_.data(); + gopFrameCount = gopFrameCount_; return *this; } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdPPSCount( uint32_t stdPPSCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setIdrPeriod( uint32_t idrPeriod_ ) VULKAN_HPP_NOEXCEPT { - stdPPSCount = stdPPSCount_; + idrPeriod = idrPeriod_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) VULKAN_HPP_NOEXCEPT { - pStdPPSs = pStdPPSs_; + consecutiveBFrameCount = consecutiveBFrameCount_; return *this; } -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoEXT & - setStdPPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoEXT & setSubLayerCount( uint32_t subLayerCount_ ) VULKAN_HPP_NOEXCEPT { - stdPPSCount = static_cast( stdPPSs_.size() ); - pStdPPSs = stdPPSs_.data(); + subLayerCount = subLayerCount_; return *this; } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265RateControlInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265RateControlInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) @@ -106825,137 +107715,149 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuple + uint32_t const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); + return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, subLayerCount ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default; + auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default; # else - bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) && - ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && + ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( subLayerCount == rhs.subLayerCount ); # endif } - bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT; - const void * pNext = {}; - uint32_t stdVPSCount = {}; - const StdVideoH265VideoParameterSet * pStdVPSs = {}; - uint32_t stdSPSCount = {}; - const StdVideoH265SequenceParameterSet * pStdSPSs = {}; - uint32_t stdPPSCount = {}; - const StdVideoH265PictureParameterSet * pStdPPSs = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsEXT flags = {}; + uint32_t gopFrameCount = {}; + uint32_t idrPeriod = {}; + uint32_t consecutiveBFrameCount = {}; + uint32_t subLayerCount = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH265SessionParametersAddInfoEXT; + using Type = VideoEncodeH265RateControlInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265SessionParametersCreateInfoEXT + struct VideoEncodeH265RateControlLayerInfoEXT { - using NativeType = VkVideoEncodeH265SessionParametersCreateInfoEXT; + using NativeType = VkVideoEncodeH265RateControlLayerInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeH265SessionParametersCreateInfoEXT( uint32_t maxStdVPSCount_ = {}, - uint32_t maxStdSPSCount_ = {}, - uint32_t maxStdPPSCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , maxStdVPSCount( maxStdVPSCount_ ) - , maxStdSPSCount( maxStdSPSCount_ ) - , maxStdPPSCount( maxStdPPSCount_ ) - , pParametersAddInfo( pParametersAddInfo_ ) + , useMinQp( useMinQp_ ) + , minQp( minQp_ ) + , useMaxQp( useMaxQp_ ) + , maxQp( maxQp_ ) + , useMaxFrameSize( useMaxFrameSize_ ) + , maxFrameSize( maxFrameSize_ ) { } - VULKAN_HPP_CONSTEXPR - VideoEncodeH265SessionParametersCreateInfoEXT( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoEXT( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeH265SessionParametersCreateInfoEXT( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265SessionParametersCreateInfoEXT( *reinterpret_cast( &rhs ) ) + VideoEncodeH265RateControlLayerInfoEXT( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265RateControlLayerInfoEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265RateControlLayerInfoEXT & operator=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265RateControlLayerInfoEXT & operator=( VkVideoEncodeH265RateControlLayerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMinQp( VULKAN_HPP_NAMESPACE::Bool32 useMinQp_ ) VULKAN_HPP_NOEXCEPT { - maxStdVPSCount = maxStdVPSCount_; + useMinQp = useMinQp_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMinQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & minQp_ ) VULKAN_HPP_NOEXCEPT { - maxStdSPSCount = maxStdSPSCount_; + minQp = minQp_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxQp( VULKAN_HPP_NAMESPACE::Bool32 useMaxQp_ ) VULKAN_HPP_NOEXCEPT { - maxStdPPSCount = maxStdPPSCount_; + useMaxQp = useMaxQp_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & - setPParametersAddInfo( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setMaxQp( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const & maxQp_ ) VULKAN_HPP_NOEXCEPT { - pParametersAddInfo = pParametersAddInfo_; + maxQp = maxQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & setUseMaxFrameSize( VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize_ ) VULKAN_HPP_NOEXCEPT + { + useMaxFrameSize = useMaxFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoEXT & + setMaxFrameSize( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const & maxFrameSize_ ) VULKAN_HPP_NOEXCEPT + { + maxFrameSize = maxFrameSize_; return *this; } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265RateControlLayerInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265RateControlLayerInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) @@ -106964,375 +107866,313 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuple + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); + return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default; + auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default; # else - bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && - ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && + ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize ); # endif } - bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT; - const void * pNext = {}; - uint32_t maxStdVPSCount = {}; - uint32_t maxStdSPSCount = {}; - uint32_t maxStdPPSCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265RateControlLayerInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 useMinQp = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT minQp = {}; + VULKAN_HPP_NAMESPACE::Bool32 useMaxQp = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT maxQp = {}; + VULKAN_HPP_NAMESPACE::Bool32 useMaxFrameSize = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT maxFrameSize = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH265SessionParametersCreateInfoEXT; + using Type = VideoEncodeH265RateControlLayerInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeH265VclFrameInfoEXT + struct VideoEncodeH265SessionCreateInfoEXT { - using NativeType = VkVideoEncodeH265VclFrameInfoEXT; + using NativeType = VkVideoEncodeH265SessionCreateInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265VclFrameInfoEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionCreateInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265VclFrameInfoEXT( const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ = {}, - uint32_t naluSliceSegmentEntryCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ = {}, - const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ = {}, + StdVideoH265LevelIdc maxLevelIdc_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , pStdReferenceFinalLists( pStdReferenceFinalLists_ ) - , naluSliceSegmentEntryCount( naluSliceSegmentEntryCount_ ) - , pNaluSliceSegmentEntries( pNaluSliceSegmentEntries_ ) - , pStdPictureInfo( pStdPictureInfo_ ) + , useMaxLevelIdc( useMaxLevelIdc_ ) + , maxLevelIdc( maxLevelIdc_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeH265VclFrameInfoEXT( VideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265VclFrameInfoEXT( VkVideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265VclFrameInfoEXT( *reinterpret_cast( &rhs ) ) - { - } + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoEXT( VideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265VclFrameInfoEXT( - const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceSegmentEntries_, - const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , pStdReferenceFinalLists( pStdReferenceFinalLists_ ) - , naluSliceSegmentEntryCount( static_cast( naluSliceSegmentEntries_.size() ) ) - , pNaluSliceSegmentEntries( naluSliceSegmentEntries_.data() ) - , pStdPictureInfo( pStdPictureInfo_ ) + VideoEncodeH265SessionCreateInfoEXT( VkVideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionCreateInfoEXT( *reinterpret_cast( &rhs ) ) { } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VideoEncodeH265VclFrameInfoEXT & operator=( VideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265SessionCreateInfoEXT & operator=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeH265VclFrameInfoEXT & operator=( VkVideoEncodeH265VclFrameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265SessionCreateInfoEXT & operator=( VkVideoEncodeH265SessionCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & - setPStdReferenceFinalLists( const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT - { - pStdReferenceFinalLists = pStdReferenceFinalLists_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) VULKAN_HPP_NOEXCEPT - { - naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & - setPNaluSliceSegmentEntries( const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries_ ) VULKAN_HPP_NOEXCEPT - { - pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265VclFrameInfoEXT & setNaluSliceSegmentEntries( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & naluSliceSegmentEntries_ ) - VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoEXT & setUseMaxLevelIdc( VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc_ ) VULKAN_HPP_NOEXCEPT { - naluSliceSegmentEntryCount = static_cast( naluSliceSegmentEntries_.size() ); - pNaluSliceSegmentEntries = naluSliceSegmentEntries_.data(); + useMaxLevelIdc = useMaxLevelIdc_; return *this; } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoEXT & setMaxLevelIdc( StdVideoH265LevelIdc maxLevelIdc_ ) VULKAN_HPP_NOEXCEPT { - pStdPictureInfo = pStdPictureInfo_; + maxLevelIdc = maxLevelIdc_; return *this; } # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeH265VclFrameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265SessionCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeH265VclFrameInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265SessionCreateInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, pStdReferenceFinalLists, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pStdPictureInfo ); + return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default; -# else - bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + std::strong_ordering operator<=>( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceFinalLists == rhs.pStdReferenceFinalLists ) && - ( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) && ( pNaluSliceSegmentEntries == rhs.pNaluSliceSegmentEntries ) && - ( pStdPictureInfo == rhs.pStdPictureInfo ); -# endif + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ); } - bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } -# endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265VclFrameInfoEXT; - const void * pNext = {}; - const StdVideoEncodeH265ReferenceListsInfo * pStdReferenceFinalLists = {}; - uint32_t naluSliceSegmentEntryCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoEXT * pNaluSliceSegmentEntries = {}; - const StdVideoEncodeH265PictureInfo * pStdPictureInfo = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionCreateInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 useMaxLevelIdc = {}; + StdVideoH265LevelIdc maxLevelIdc = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeH265VclFrameInfoEXT; + using Type = VideoEncodeH265SessionCreateInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeInfoKHR + struct VideoEncodeH265SessionParametersAddInfoEXT { - using NativeType = VkVideoEncodeInfoKHR; + using NativeType = VkVideoEncodeH265SessionParametersAddInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeInfoKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ = {}, - uint32_t qualityLevel_ = {}, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ = {}, - VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ = {}, - VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ = {}, - VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_ = {}, - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {}, - uint32_t referenceSlotCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, - uint32_t precedingExternallyEncodedBytes_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( uint32_t stdVPSCount_ = {}, + const StdVideoH265VideoParameterSet * pStdVPSs_ = {}, + uint32_t stdSPSCount_ = {}, + const StdVideoH265SequenceParameterSet * pStdSPSs_ = {}, + uint32_t stdPPSCount_ = {}, + const StdVideoH265PictureParameterSet * pStdPPSs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , flags( flags_ ) - , qualityLevel( qualityLevel_ ) - , dstBuffer( dstBuffer_ ) - , dstBufferOffset( dstBufferOffset_ ) - , dstBufferRange( dstBufferRange_ ) - , srcPictureResource( srcPictureResource_ ) - , pSetupReferenceSlot( pSetupReferenceSlot_ ) - , referenceSlotCount( referenceSlotCount_ ) - , pReferenceSlots( pReferenceSlots_ ) - , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ ) + , stdVPSCount( stdVPSCount_ ) + , pStdVPSs( pStdVPSs_ ) + , stdSPSCount( stdSPSCount_ ) + , pStdSPSs( pStdSPSs_ ) + , stdPPSCount( stdPPSCount_ ) + , pStdPPSs( pStdPPSs_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoEXT( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeInfoKHR( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoEncodeInfoKHR( *reinterpret_cast( &rhs ) ) {} + VideoEncodeH265SessionParametersAddInfoEXT( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersAddInfoEXT( *reinterpret_cast( &rhs ) ) + { + } # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_, - uint32_t qualityLevel_, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer_, - VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_, - VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_, - VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_, - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & referenceSlots_, - uint32_t precedingExternallyEncodedBytes_ = {}, - const void * pNext_ = nullptr ) + VideoEncodeH265SessionParametersAddInfoEXT( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdVPSs_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdSPSs_ = {}, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdPPSs_ = {}, + const void * pNext_ = nullptr ) : pNext( pNext_ ) - , flags( flags_ ) - , qualityLevel( qualityLevel_ ) - , dstBuffer( dstBuffer_ ) - , dstBufferOffset( dstBufferOffset_ ) - , dstBufferRange( dstBufferRange_ ) - , srcPictureResource( srcPictureResource_ ) - , pSetupReferenceSlot( pSetupReferenceSlot_ ) - , referenceSlotCount( static_cast( referenceSlots_.size() ) ) - , pReferenceSlots( referenceSlots_.data() ) - , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ ) + , stdVPSCount( static_cast( stdVPSs_.size() ) ) + , pStdVPSs( stdVPSs_.data() ) + , stdSPSCount( static_cast( stdSPSs_.size() ) ) + , pStdSPSs( stdSPSs_.data() ) + , stdPPSCount( static_cast( stdPPSs_.size() ) ) + , pStdPPSs( stdPPSs_.data() ) { } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VideoEncodeInfoKHR & operator=( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265SessionParametersAddInfoEXT & operator=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeInfoKHR & operator=( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265SessionParametersAddInfoEXT & operator=( VkVideoEncodeH265SessionParametersAddInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdVPSCount( uint32_t stdVPSCount_ ) VULKAN_HPP_NOEXCEPT { - flags = flags_; + stdVPSCount = stdVPSCount_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) VULKAN_HPP_NOEXCEPT { - qualityLevel = qualityLevel_; + pStdVPSs = pStdVPSs_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ ) VULKAN_HPP_NOEXCEPT - { - dstBuffer = dstBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferOffset( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ ) VULKAN_HPP_NOEXCEPT +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265SessionParametersAddInfoEXT & + setStdVPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT { - dstBufferOffset = dstBufferOffset_; + stdVPSCount = static_cast( stdVPSs_.size() ); + pStdVPSs = stdVPSs_.data(); return *this; } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferRange( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdSPSCount( uint32_t stdSPSCount_ ) VULKAN_HPP_NOEXCEPT { - dstBufferRange = dstBufferRange_; + stdSPSCount = stdSPSCount_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & - setSrcPictureResource( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & srcPictureResource_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) VULKAN_HPP_NOEXCEPT { - srcPictureResource = srcPictureResource_; + pStdSPSs = pStdSPSs_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & - setPSetupReferenceSlot( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) VULKAN_HPP_NOEXCEPT +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265SessionParametersAddInfoEXT & + setStdSPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT { - pSetupReferenceSlot = pSetupReferenceSlot_; + stdSPSCount = static_cast( stdSPSs_.size() ); + pStdSPSs = stdSPSs_.data(); return *this; } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setStdPPSCount( uint32_t stdPPSCount_ ) VULKAN_HPP_NOEXCEPT { - referenceSlotCount = referenceSlotCount_; + stdPPSCount = stdPPSCount_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & - setPReferenceSlots( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoEXT & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) VULKAN_HPP_NOEXCEPT { - pReferenceSlots = pReferenceSlots_; + pStdPPSs = pStdPPSs_; return *this; } # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeInfoKHR & setReferenceSlots( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265SessionParametersAddInfoEXT & + setStdPPSs( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT { - referenceSlotCount = static_cast( referenceSlots_.size() ); - pReferenceSlots = referenceSlots_.data(); + stdPPSCount = static_cast( stdPPSs_.size() ); + pStdPPSs = stdPPSs_.data(); return *this; } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) VULKAN_HPP_NOEXCEPT - { - precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_; - return *this; - } -# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - - operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265SessionParametersAddInfoEXT const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeH265SessionParametersAddInfoEXT &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) @@ -107341,385 +108181,1352 @@ namespace VULKAN_HPP_NAMESPACE # else std::tuple + const StdVideoH265SequenceParameterSet * const &, + uint32_t const &, + const StdVideoH265PictureParameterSet * const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, - pNext, - flags, - qualityLevel, - dstBuffer, - dstBufferOffset, - dstBufferRange, - srcPictureResource, - pSetupReferenceSlot, - referenceSlotCount, - pReferenceSlots, - precedingExternallyEncodedBytes ); + return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeInfoKHR const & ) const = default; + auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default; # else - bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( qualityLevel == rhs.qualityLevel ) && - ( dstBuffer == rhs.dstBuffer ) && ( dstBufferOffset == rhs.dstBufferOffset ) && ( dstBufferRange == rhs.dstBufferRange ) && - ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && - ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) && - ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) && + ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); # endif } - bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeInfoKHR; - const void * pNext = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags = {}; - uint32_t qualityLevel = {}; - VULKAN_HPP_NAMESPACE::Buffer dstBuffer = {}; - VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset = {}; - VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange = {}; - VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource = {}; - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {}; - uint32_t referenceSlotCount = {}; - const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots = {}; - uint32_t precedingExternallyEncodedBytes = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersAddInfoEXT; + const void * pNext = {}; + uint32_t stdVPSCount = {}; + const StdVideoH265VideoParameterSet * pStdVPSs = {}; + uint32_t stdSPSCount = {}; + const StdVideoH265SequenceParameterSet * pStdSPSs = {}; + uint32_t stdPPSCount = {}; + const StdVideoH265PictureParameterSet * pStdPPSs = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeInfoKHR; + using Type = VideoEncodeH265SessionParametersAddInfoEXT; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeRateControlLayerInfoKHR + struct VideoEncodeH265SessionParametersCreateInfoEXT { - using NativeType = VkVideoEncodeRateControlLayerInfoKHR; + using NativeType = VkVideoEncodeH265SessionParametersCreateInfoEXT; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlLayerInfoKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( uint64_t averageBitrate_ = {}, - uint64_t maxBitrate_ = {}, - uint32_t frameRateNumerator_ = {}, - uint32_t frameRateDenominator_ = {}, - uint32_t virtualBufferSizeInMs_ = {}, - uint32_t initialVirtualBufferSizeInMs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR + VideoEncodeH265SessionParametersCreateInfoEXT( uint32_t maxStdVPSCount_ = {}, + uint32_t maxStdSPSCount_ = {}, + uint32_t maxStdPPSCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , averageBitrate( averageBitrate_ ) - , maxBitrate( maxBitrate_ ) - , frameRateNumerator( frameRateNumerator_ ) - , frameRateDenominator( frameRateDenominator_ ) - , virtualBufferSizeInMs( virtualBufferSizeInMs_ ) - , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ ) + , maxStdVPSCount( maxStdVPSCount_ ) + , maxStdSPSCount( maxStdSPSCount_ ) + , maxStdPPSCount( maxStdPPSCount_ ) + , pParametersAddInfo( pParametersAddInfo_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR + VideoEncodeH265SessionParametersCreateInfoEXT( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VideoEncodeRateControlLayerInfoKHR( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeRateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) + VideoEncodeH265SessionParametersCreateInfoEXT( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersCreateInfoEXT( *reinterpret_cast( &rhs ) ) { } - VideoEncodeRateControlLayerInfoKHR & operator=( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeRateControlLayerInfoKHR & operator=( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeH265SessionParametersCreateInfoEXT & operator=( VkVideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setAverageBitrate( uint64_t averageBitrate_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) VULKAN_HPP_NOEXCEPT { - averageBitrate = averageBitrate_; + maxStdVPSCount = maxStdVPSCount_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setMaxBitrate( uint64_t maxBitrate_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) VULKAN_HPP_NOEXCEPT { - maxBitrate = maxBitrate_; + maxStdSPSCount = maxStdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoEXT & + setPParametersAddInfo( const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo_ ) VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; return *this; } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeH265SessionParametersCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersCreateInfoEXT &() 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, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default; +# else + bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && + ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif + } + + bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT; + const void * pNext = {}; + uint32_t maxStdVPSCount = {}; + uint32_t maxStdSPSCount = {}; + uint32_t maxStdPPSCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * pParametersAddInfo = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersCreateInfoEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH265SessionParametersFeedbackInfoEXT + { + using NativeType = VkVideoEncodeH265SessionParametersFeedbackInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersFeedbackInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 hasStdVPSOverrides_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , hasStdVPSOverrides( hasStdVPSOverrides_ ) + , hasStdSPSOverrides( hasStdSPSOverrides_ ) + , hasStdPPSOverrides( hasStdPPSOverrides_ ) + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeH265SessionParametersFeedbackInfoEXT( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265SessionParametersFeedbackInfoEXT( VkVideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersFeedbackInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265SessionParametersFeedbackInfoEXT & operator=( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH265SessionParametersFeedbackInfoEXT & operator=( VkVideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH265SessionParametersFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersFeedbackInfoEXT &() 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, hasStdVPSOverrides, hasStdSPSOverrides, hasStdPPSOverrides ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265SessionParametersFeedbackInfoEXT const & ) const = default; +# else + bool operator==( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdVPSOverrides == rhs.hasStdVPSOverrides ) && + ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) && ( hasStdPPSOverrides == rhs.hasStdPPSOverrides ); +# endif + } + + bool operator!=( VideoEncodeH265SessionParametersFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 hasStdVPSOverrides = {}; + VULKAN_HPP_NAMESPACE::Bool32 hasStdSPSOverrides = {}; + VULKAN_HPP_NAMESPACE::Bool32 hasStdPPSOverrides = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersFeedbackInfoEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeH265SessionParametersGetInfoEXT + { + using NativeType = VkVideoEncodeH265SessionParametersGetInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersGetInfoEXT; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 writeStdVPS_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ = {}, + uint32_t stdVPSId_ = {}, + uint32_t stdSPSId_ = {}, + uint32_t stdPPSId_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , writeStdVPS( writeStdVPS_ ) + , writeStdSPS( writeStdSPS_ ) + , writeStdPPS( writeStdPPS_ ) + , stdVPSId( stdVPSId_ ) + , stdSPSId( stdSPSId_ ) + , stdPPSId( stdPPSId_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoEXT( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265SessionParametersGetInfoEXT( VkVideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersGetInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265SessionParametersGetInfoEXT & operator=( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeH265SessionParametersGetInfoEXT & operator=( VkVideoEncodeH265SessionParametersGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setWriteStdVPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdVPS_ ) VULKAN_HPP_NOEXCEPT + { + writeStdVPS = writeStdVPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setWriteStdSPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS_ ) VULKAN_HPP_NOEXCEPT + { + writeStdSPS = writeStdSPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setWriteStdPPS( VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS_ ) VULKAN_HPP_NOEXCEPT + { + writeStdPPS = writeStdPPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setStdVPSId( uint32_t stdVPSId_ ) VULKAN_HPP_NOEXCEPT + { + stdVPSId = stdVPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setStdSPSId( uint32_t stdSPSId_ ) VULKAN_HPP_NOEXCEPT + { + stdSPSId = stdSPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoEXT & setStdPPSId( uint32_t stdPPSId_ ) VULKAN_HPP_NOEXCEPT + { + stdPPSId = stdPPSId_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeH265SessionParametersGetInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersGetInfoEXT &() 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, writeStdVPS, writeStdSPS, writeStdPPS, stdVPSId, stdSPSId, stdPPSId ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265SessionParametersGetInfoEXT const & ) const = default; +# else + bool operator==( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdVPS == rhs.writeStdVPS ) && ( writeStdSPS == rhs.writeStdSPS ) && + ( writeStdPPS == rhs.writeStdPPS ) && ( stdVPSId == rhs.stdVPSId ) && ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId ); +# endif + } + + bool operator!=( VideoEncodeH265SessionParametersGetInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265SessionParametersGetInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 writeStdVPS = {}; + VULKAN_HPP_NAMESPACE::Bool32 writeStdSPS = {}; + VULKAN_HPP_NAMESPACE::Bool32 writeStdPPS = {}; + uint32_t stdVPSId = {}; + uint32_t stdSPSId = {}; + uint32_t stdPPSId = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersGetInfoEXT; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeInfoKHR + { + using NativeType = VkVideoEncodeInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeInfoKHR; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ = {}, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ = {}, + VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ = {}, + VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ = {}, + VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_ = {}, + const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {}, + uint32_t referenceSlotCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, + uint32_t precedingExternallyEncodedBytes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , flags( flags_ ) + , dstBuffer( dstBuffer_ ) + , dstBufferOffset( dstBufferOffset_ ) + , dstBufferRange( dstBufferRange_ ) + , srcPictureResource( srcPictureResource_ ) + , pSetupReferenceSlot( pSetupReferenceSlot_ ) + , referenceSlotCount( referenceSlotCount_ ) + , pReferenceSlots( pReferenceSlots_ ) + , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeInfoKHR( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoEncodeInfoKHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer_, + VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_, + VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_, + VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource_, + const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & referenceSlots_, + uint32_t precedingExternallyEncodedBytes_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , dstBuffer( dstBuffer_ ) + , dstBufferOffset( dstBufferOffset_ ) + , dstBufferRange( dstBufferRange_ ) + , srcPictureResource( srcPictureResource_ ) + , pSetupReferenceSlot( pSetupReferenceSlot_ ) + , referenceSlotCount( static_cast( referenceSlots_.size() ) ) + , pReferenceSlots( referenceSlots_.data() ) + , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeInfoKHR & operator=( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeInfoKHR & operator=( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer_ ) VULKAN_HPP_NOEXCEPT + { + dstBuffer = dstBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferOffset( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset_ ) VULKAN_HPP_NOEXCEPT + { + dstBufferOffset = dstBufferOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferRange( VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange_ ) VULKAN_HPP_NOEXCEPT + { + dstBufferRange = dstBufferRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & + setSrcPictureResource( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & srcPictureResource_ ) VULKAN_HPP_NOEXCEPT + { + srcPictureResource = srcPictureResource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & + setPSetupReferenceSlot( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) VULKAN_HPP_NOEXCEPT + { + pSetupReferenceSlot = pSetupReferenceSlot_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = referenceSlotCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & + setPReferenceSlots( const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots_ ) VULKAN_HPP_NOEXCEPT + { + pReferenceSlots = pReferenceSlots_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeInfoKHR & setReferenceSlots( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = static_cast( referenceSlots_.size() ); + pReferenceSlots = referenceSlots_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) VULKAN_HPP_NOEXCEPT + { + precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeInfoKHR &() 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, + dstBuffer, + dstBufferOffset, + dstBufferRange, + srcPictureResource, + pSetupReferenceSlot, + referenceSlotCount, + pReferenceSlots, + precedingExternallyEncodedBytes ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeInfoKHR const & ) const = default; +# else + bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstBuffer == rhs.dstBuffer ) && + ( dstBufferOffset == rhs.dstBufferOffset ) && ( dstBufferRange == rhs.dstBufferRange ) && ( srcPictureResource == rhs.srcPictureResource ) && + ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) && + ( pReferenceSlots == rhs.pReferenceSlots ) && ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes ); +# endif + } + + bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeInfoKHR; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR flags = {}; + VULKAN_HPP_NAMESPACE::Buffer dstBuffer = {}; + VULKAN_HPP_NAMESPACE::DeviceSize dstBufferOffset = {}; + VULKAN_HPP_NAMESPACE::DeviceSize dstBufferRange = {}; + VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR srcPictureResource = {}; + const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {}; + uint32_t referenceSlotCount = {}; + const VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR * pReferenceSlots = {}; + uint32_t precedingExternallyEncodedBytes = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeInfoKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeQualityLevelInfoKHR + { + using NativeType = VkVideoEncodeQualityLevelInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelInfoKHR; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( uint32_t qualityLevel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , qualityLevel( qualityLevel_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeQualityLevelInfoKHR( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeQualityLevelInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeQualityLevelInfoKHR & operator=( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeQualityLevelInfoKHR & operator=( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) VULKAN_HPP_NOEXCEPT + { + qualityLevel = qualityLevel_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelInfoKHR &() 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, qualityLevel ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeQualityLevelInfoKHR const & ) const = default; +# else + bool operator==( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( qualityLevel == rhs.qualityLevel ); +# endif + } + + bool operator!=( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeQualityLevelInfoKHR; + const void * pNext = {}; + uint32_t qualityLevel = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeQualityLevelInfoKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeQualityLevelPropertiesKHR + { + using NativeType = VkVideoEncodeQualityLevelPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelPropertiesKHR; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelPropertiesKHR( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode_ = + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault, + uint32_t preferredRateControlLayerCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , preferredRateControlMode( preferredRateControlMode_ ) + , preferredRateControlLayerCount( preferredRateControlLayerCount_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelPropertiesKHR( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeQualityLevelPropertiesKHR( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeQualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeQualityLevelPropertiesKHR & operator=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeQualityLevelPropertiesKHR & operator=( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeQualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelPropertiesKHR &() 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, preferredRateControlMode, preferredRateControlLayerCount ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeQualityLevelPropertiesKHR const & ) const = default; +# else + bool operator==( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlMode == rhs.preferredRateControlMode ) && + ( preferredRateControlLayerCount == rhs.preferredRateControlLayerCount ); +# endif + } + + bool operator!=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeQualityLevelPropertiesKHR; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode = + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault; + uint32_t preferredRateControlLayerCount = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeQualityLevelPropertiesKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeRateControlLayerInfoKHR + { + using NativeType = VkVideoEncodeRateControlLayerInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlLayerInfoKHR; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( uint64_t averageBitrate_ = {}, + uint64_t maxBitrate_ = {}, + uint32_t frameRateNumerator_ = {}, + uint32_t frameRateDenominator_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , averageBitrate( averageBitrate_ ) + , maxBitrate( maxBitrate_ ) + , frameRateNumerator( frameRateNumerator_ ) + , frameRateDenominator( frameRateDenominator_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeRateControlLayerInfoKHR( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeRateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeRateControlLayerInfoKHR & operator=( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeRateControlLayerInfoKHR & operator=( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setAverageBitrate( uint64_t averageBitrate_ ) VULKAN_HPP_NOEXCEPT + { + averageBitrate = averageBitrate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setMaxBitrate( uint64_t maxBitrate_ ) VULKAN_HPP_NOEXCEPT + { + maxBitrate = maxBitrate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateNumerator( uint32_t frameRateNumerator_ ) VULKAN_HPP_NOEXCEPT + { + frameRateNumerator = frameRateNumerator_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateDenominator( uint32_t frameRateDenominator_ ) VULKAN_HPP_NOEXCEPT + { + frameRateDenominator = frameRateDenominator_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlLayerInfoKHR &() 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, averageBitrate, maxBitrate, frameRateNumerator, frameRateDenominator ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default; +# else + bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && ( maxBitrate == rhs.maxBitrate ) && + ( frameRateNumerator == rhs.frameRateNumerator ) && ( frameRateDenominator == rhs.frameRateDenominator ); +# endif + } + + bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlLayerInfoKHR; + const void * pNext = {}; + uint64_t averageBitrate = {}; + uint64_t maxBitrate = {}; + uint32_t frameRateNumerator = {}; + uint32_t frameRateDenominator = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeRateControlLayerInfoKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeRateControlInfoKHR + { + using NativeType = VkVideoEncodeRateControlInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlInfoKHR; + +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ = {}, + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault, + uint32_t layerCount_ = {}, + const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ = {}, + uint32_t virtualBufferSizeInMs_ = {}, + uint32_t initialVirtualBufferSizeInMs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , flags( flags_ ) + , rateControlMode( rateControlMode_ ) + , layerCount( layerCount_ ) + , pLayers( pLayers_ ) + , virtualBufferSizeInMs( virtualBufferSizeInMs_ ) + , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ ) + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeRateControlInfoKHR( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeRateControlInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeRateControlInfoKHR( + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_, + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & layers_, + uint32_t virtualBufferSizeInMs_ = {}, + uint32_t initialVirtualBufferSizeInMs_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , rateControlMode( rateControlMode_ ) + , layerCount( static_cast( layers_.size() ) ) + , pLayers( layers_.data() ) + , virtualBufferSizeInMs( virtualBufferSizeInMs_ ) + , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeRateControlInfoKHR & operator=( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeRateControlInfoKHR & operator=( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & + setRateControlMode( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) VULKAN_HPP_NOEXCEPT + { + rateControlMode = rateControlMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setLayerCount( uint32_t layerCount_ ) VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & + setPLayers( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ ) VULKAN_HPP_NOEXCEPT + { + pLayers = pLayers_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeRateControlInfoKHR & setLayers( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & layers_ ) VULKAN_HPP_NOEXCEPT + { + layerCount = static_cast( layers_.size() ); + pLayers = layers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT + { + virtualBufferSizeInMs = virtualBufferSizeInMs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT + { + initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_; + return *this; + } +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlInfoKHR &() 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, rateControlMode, layerCount, pLayers, virtualBufferSizeInMs, initialVirtualBufferSizeInMs ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default; +# else + bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlMode == rhs.rateControlMode ) && + ( layerCount == rhs.layerCount ) && ( pLayers == rhs.pLayers ) && ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) && + ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs ); +# endif + } + + bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlInfoKHR; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags = {}; + VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault; + uint32_t layerCount = {}; + const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers = {}; + uint32_t virtualBufferSizeInMs = {}; + uint32_t initialVirtualBufferSizeInMs = {}; + }; + + template <> + struct CppType + { + using Type = VideoEncodeRateControlInfoKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + struct VideoEncodeSessionParametersFeedbackInfoKHR + { + using NativeType = VkVideoEncodeSessionParametersFeedbackInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR; - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateNumerator( uint32_t frameRateNumerator_ ) VULKAN_HPP_NOEXCEPT +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( VULKAN_HPP_NAMESPACE::Bool32 hasOverrides_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , hasOverrides( hasOverrides_ ) { - frameRateNumerator = frameRateNumerator_; - return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateDenominator( uint32_t frameRateDenominator_ ) VULKAN_HPP_NOEXCEPT - { - frameRateDenominator = frameRateDenominator_; - return *this; - } + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT + VideoEncodeSessionParametersFeedbackInfoKHR( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeSessionParametersFeedbackInfoKHR( *reinterpret_cast( &rhs ) ) { - virtualBufferSizeInMs = virtualBufferSizeInMs_; - return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) VULKAN_HPP_NOEXCEPT + VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_; + *this = *reinterpret_cast( &rhs ); return *this; } -# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeSessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeSessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( - sType, pNext, averageBitrate, maxBitrate, frameRateNumerator, frameRateDenominator, virtualBufferSizeInMs, initialVirtualBufferSizeInMs ); + return std::tie( sType, pNext, hasOverrides ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default; + auto operator<=>( VideoEncodeSessionParametersFeedbackInfoKHR const & ) const = default; # else - bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && ( maxBitrate == rhs.maxBitrate ) && - ( frameRateNumerator == rhs.frameRateNumerator ) && ( frameRateDenominator == rhs.frameRateDenominator ) && - ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) && ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasOverrides == rhs.hasOverrides ); # endif } - bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlLayerInfoKHR; - const void * pNext = {}; - uint64_t averageBitrate = {}; - uint64_t maxBitrate = {}; - uint32_t frameRateNumerator = {}; - uint32_t frameRateDenominator = {}; - uint32_t virtualBufferSizeInMs = {}; - uint32_t initialVirtualBufferSizeInMs = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 hasOverrides = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeRateControlLayerInfoKHR; + using Type = VideoEncodeSessionParametersFeedbackInfoKHR; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #if defined( VK_ENABLE_BETA_EXTENSIONS ) - struct VideoEncodeRateControlInfoKHR + struct VideoEncodeSessionParametersGetInfoKHR { - using NativeType = VkVideoEncodeRateControlInfoKHR; + using NativeType = VkVideoEncodeSessionParametersGetInfoKHR; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlInfoKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersGetInfoKHR; # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ = {}, - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault, - uint32_t layerCount_ = {}, - const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext( pNext_ ) - , flags( flags_ ) - , rateControlMode( rateControlMode_ ) - , layerCount( layerCount_ ) - , pLayers( pLayers_ ) + , videoSessionParameters( videoSessionParameters_ ) { } - VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeRateControlInfoKHR( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeRateControlInfoKHR( *reinterpret_cast( &rhs ) ) - { - } + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeRateControlInfoKHR( - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_, - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_, - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & layers_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), rateControlMode( rateControlMode_ ), layerCount( static_cast( layers_.size() ) ), pLayers( layers_.data() ) + VideoEncodeSessionParametersGetInfoKHR( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeSessionParametersGetInfoKHR( *reinterpret_cast( &rhs ) ) { } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VideoEncodeRateControlInfoKHR & operator=( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VideoEncodeSessionParametersGetInfoKHR & operator=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; # endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - VideoEncodeRateControlInfoKHR & operator=( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + VideoEncodeSessionParametersGetInfoKHR & operator=( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & - setRateControlMode( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) VULKAN_HPP_NOEXCEPT - { - rateControlMode = rateControlMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setLayerCount( uint32_t layerCount_ ) VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & - setPLayers( const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers_ ) VULKAN_HPP_NOEXCEPT - { - pLayers = pLayers_; - return *this; - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeRateControlInfoKHR & setLayers( - VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & layers_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR & + setVideoSessionParameters( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters_ ) VULKAN_HPP_NOEXCEPT { - layerCount = static_cast( layers_.size() ); - pLayers = layers_.data(); + videoSessionParameters = videoSessionParameters_; return *this; } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ +# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeSessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT + operator VkVideoEncodeSessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } # if defined( VULKAN_HPP_USE_REFLECT ) # if 14 <= VULKAN_HPP_CPP_VERSION auto # else - std::tuple + std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT { - return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayers ); + return std::tie( sType, pNext, videoSessionParameters ); } # endif # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default; + auto operator<=>( VideoEncodeSessionParametersGetInfoKHR const & ) const = default; # else - bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); # else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlMode == rhs.rateControlMode ) && - ( layerCount == rhs.layerCount ) && ( pLayers == rhs.pLayers ); + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoSessionParameters == rhs.videoSessionParameters ); # endif } - bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } # endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeRateControlInfoKHR; - const void * pNext = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR flags = {}; - VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR rateControlMode = VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR::eDefault; - uint32_t layerCount = {}; - const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * pLayers = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeSessionParametersGetInfoKHR; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters = {}; }; template <> - struct CppType + struct CppType { - using Type = VideoEncodeRateControlInfoKHR; + using Type = VideoEncodeSessionParametersGetInfoKHR; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -108050,138 +109857,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = VideoFormatPropertiesKHR; }; - struct VideoProfileInfoKHR - { - using NativeType = VkVideoProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( - VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone, - VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ = {}, - VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ = {}, - VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext( pNext_ ) - , videoCodecOperation( videoCodecOperation_ ) - , chromaSubsampling( chromaSubsampling_ ) - , lumaBitDepth( lumaBitDepth_ ) - , chromaBitDepth( chromaBitDepth_ ) - { - } - - VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoProfileInfoKHR( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoProfileInfoKHR & operator=( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - - VideoProfileInfoKHR & operator=( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & - setVideoCodecOperation( VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) VULKAN_HPP_NOEXCEPT - { - videoCodecOperation = videoCodecOperation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & - setChromaSubsampling( VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) VULKAN_HPP_NOEXCEPT - { - chromaSubsampling = chromaSubsampling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setLumaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) VULKAN_HPP_NOEXCEPT - { - lumaBitDepth = lumaBitDepth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaBitDepth( VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) VULKAN_HPP_NOEXCEPT - { - chromaBitDepth = chromaBitDepth_; - return *this; - } -#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ - - operator VkVideoProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoProfileInfoKHR &() 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, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoProfileInfoKHR const & ) const = default; -#else - bool operator==( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) && - ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && ( chromaBitDepth == rhs.chromaBitDepth ); -# endif - } - - bool operator!=( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoProfileInfoKHR; - const void * pNext = {}; - VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR videoCodecOperation = VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR::eNone; - VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR chromaSubsampling = {}; - VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR lumaBitDepth = {}; - VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR chromaBitDepth = {}; - }; - - template <> - struct CppType - { - using Type = VideoProfileInfoKHR; - }; - struct VideoProfileListInfoKHR { using NativeType = VkVideoProfileListInfoKHR; diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp index c9fc846..731c856 100644 --- a/include/vulkan/vulkan_to_string.hpp +++ b/include/vulkan/vulkan_to_string.hpp @@ -2084,6 +2084,10 @@ namespace VULKAN_HPP_NAMESPACE std::string result; if ( value & VideoSessionCreateFlagBitsKHR::eProtectedContent ) result += "ProtectedContent | "; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations ) + result += "AllowEncodeParameterOptimizations | "; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -2114,8 +2118,8 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) if ( value & VideoCodingControlFlagBitsKHR::eEncodeRateControl ) result += "EncodeRateControl | "; - if ( value & VideoCodingControlFlagBitsKHR::eEncodeRateControlLayer ) - result += "EncodeRateControlLayer | "; + if ( value & VideoCodingControlFlagBitsKHR::eEncodeQualityLevel ) + result += "EncodeQualityLevel | "; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ return "{ " + result.substr( 0, result.size() - 3 ) + " }"; @@ -2174,58 +2178,90 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceEnabled ) - result += "Direct8X8InferenceEnabled | "; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceDisabled ) - result += "Direct8X8InferenceDisabled | "; - 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::eSliceMbCount ) - result += "SliceMbCount | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::ePredictionWeightTableGenerated ) + result += "PredictionWeightTableGenerated | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice ) result += "RowUnalignedSlice | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType ) result += "DifferentSliceType | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL0List ) + result += "BFrameInL0List | "; if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List ) result += "BFrameInL1List | "; - if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDifferentReferenceFinalLists ) - result += "DifferentReferenceFinalLists | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp ) + result += "PerPictureTypeMinMaxQp | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::ePerSliceConstantQp ) + result += "PerSliceConstantQp | "; + if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eGeneratePrefixNalu ) + result += "GeneratePrefixNalu | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264StdFlagsEXT value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & VideoEncodeH264StdFlagBitsEXT::eSeparateColorPlaneFlagSet ) + result += "SeparateColorPlaneFlagSet | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eQpprimeYZeroTransformBypassFlagSet ) + result += "QpprimeYZeroTransformBypassFlagSet | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eScalingMatrixPresentFlagSet ) + result += "ScalingMatrixPresentFlagSet | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eChromaQpIndexOffset ) + result += "ChromaQpIndexOffset | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eSecondChromaQpIndexOffset ) + result += "SecondChromaQpIndexOffset | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::ePicInitQpMinus26 ) + result += "PicInitQpMinus26 | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eWeightedPredFlagSet ) + result += "WeightedPredFlagSet | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcExplicit ) + result += "WeightedBipredIdcExplicit | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcImplicit ) + result += "WeightedBipredIdcImplicit | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eTransform8X8ModeFlagSet ) + result += "Transform8X8ModeFlagSet | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eDirectSpatialMvPredFlagUnset ) + result += "DirectSpatialMvPredFlagUnset | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagUnset ) + result += "EntropyCodingModeFlagUnset | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagSet ) + result += "EntropyCodingModeFlagSet | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eDirect8X8InferenceFlagUnset ) + result += "Direct8X8InferenceFlagUnset | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eConstrainedIntraPredFlagSet ) + result += "ConstrainedIntraPredFlagSet | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled ) + result += "DeblockingFilterDisabled | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled ) + result += "DeblockingFilterEnabled | "; + if ( value & VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial ) + result += "DeblockingFilterPartial | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlFlagsEXT value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & VideoEncodeH264RateControlFlagBitsEXT::eAttemptHrdCompliance ) + result += "AttemptHrdCompliance | "; + if ( value & VideoEncodeH264RateControlFlagBitsEXT::eRegularGop ) + result += "RegularGop | "; + if ( value & VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternFlat ) + result += "ReferencePatternFlat | "; + if ( value & VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternDyadic ) + result += "ReferencePatternDyadic | "; + if ( value & VideoEncodeH264RateControlFlagBitsEXT::eTemporalLayerPatternDyadic ) + result += "TemporalLayerPatternDyadic | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -2240,60 +2276,74 @@ namespace VULKAN_HPP_NAMESPACE 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::eTransformSkipDisabled ) - result += "TransformSkipDisabled | "; - 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::ePredictionWeightTableGenerated ) + result += "PredictionWeightTableGenerated | "; if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment ) result += "RowUnalignedSliceSegment | "; - if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment ) - result += "DependentSliceSegment | "; - if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType ) - result += "DifferentSliceType | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceSegmentType ) + result += "DifferentSliceSegmentType | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL0List ) + result += "BFrameInL0List | "; if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List ) result += "BFrameInL1List | "; - if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDifferentReferenceFinalLists ) - result += "DifferentReferenceFinalLists | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp ) + result += "PerPictureTypeMinMaxQp | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::ePerSliceSegmentConstantQp ) + result += "PerSliceSegmentConstantQp | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilesPerSliceSegment ) + result += "MultipleTilesPerSliceSegment | "; + if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSliceSegmentsPerTile ) + result += "MultipleSliceSegmentsPerTile | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265StdFlagsEXT value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & VideoEncodeH265StdFlagBitsEXT::eSeparateColorPlaneFlagSet ) + result += "SeparateColorPlaneFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eSampleAdaptiveOffsetEnabledFlagSet ) + result += "SampleAdaptiveOffsetEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eScalingListDataPresentFlagSet ) + result += "ScalingListDataPresentFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::ePcmEnabledFlagSet ) + result += "PcmEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eSpsTemporalMvpEnabledFlagSet ) + result += "SpsTemporalMvpEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eInitQpMinus26 ) + result += "InitQpMinus26 | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eWeightedPredFlagSet ) + result += "WeightedPredFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eWeightedBipredFlagSet ) + result += "WeightedBipredFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eLog2ParallelMergeLevelMinus2 ) + result += "Log2ParallelMergeLevelMinus2 | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eSignDataHidingEnabledFlagSet ) + result += "SignDataHidingEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagSet ) + result += "TransformSkipEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagUnset ) + result += "TransformSkipEnabledFlagUnset | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::ePpsSliceChromaQpOffsetsPresentFlagSet ) + result += "PpsSliceChromaQpOffsetsPresentFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eTransquantBypassEnabledFlagSet ) + result += "TransquantBypassEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eConstrainedIntraPredFlagSet ) + result += "ConstrainedIntraPredFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eEntropyCodingSyncEnabledFlagSet ) + result += "EntropyCodingSyncEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet ) + result += "DeblockingFilterOverrideEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet ) + result += "DependentSliceSegmentsEnabledFlagSet | "; + if ( value & VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet ) + result += "DependentSliceSegmentFlagSet | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -2331,6 +2381,26 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlFlagsEXT value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & VideoEncodeH265RateControlFlagBitsEXT::eAttemptHrdCompliance ) + result += "AttemptHrdCompliance | "; + if ( value & VideoEncodeH265RateControlFlagBitsEXT::eRegularGop ) + result += "RegularGop | "; + if ( value & VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternFlat ) + result += "ReferencePatternFlat | "; + if ( value & VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternDyadic ) + result += "ReferencePatternDyadic | "; + if ( value & VideoEncodeH265RateControlFlagBitsEXT::eTemporalSubLayerPatternDyadic ) + result += "TemporalSubLayerPatternDyadic | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ //=== VK_KHR_video_decode_h264 === @@ -2809,6 +2879,8 @@ namespace VULKAN_HPP_NAMESPACE result += "streamBufferOffsetBit | "; if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit ) result += "streamBytesWrittenBit | "; + if ( value & VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit ) + result += "streamHasOverridesBit | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -3595,21 +3667,31 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eVideoEncodeH264CapabilitiesEXT: return "VideoEncodeH264CapabilitiesEXT"; case StructureType::eVideoEncodeH264SessionParametersCreateInfoEXT: return "VideoEncodeH264SessionParametersCreateInfoEXT"; case StructureType::eVideoEncodeH264SessionParametersAddInfoEXT: return "VideoEncodeH264SessionParametersAddInfoEXT"; - case StructureType::eVideoEncodeH264VclFrameInfoEXT: return "VideoEncodeH264VclFrameInfoEXT"; + case StructureType::eVideoEncodeH264PictureInfoEXT: return "VideoEncodeH264PictureInfoEXT"; case StructureType::eVideoEncodeH264DpbSlotInfoEXT: return "VideoEncodeH264DpbSlotInfoEXT"; case StructureType::eVideoEncodeH264NaluSliceInfoEXT: return "VideoEncodeH264NaluSliceInfoEXT"; + case StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT: return "VideoEncodeH264GopRemainingFrameInfoEXT"; case StructureType::eVideoEncodeH264ProfileInfoEXT: return "VideoEncodeH264ProfileInfoEXT"; case StructureType::eVideoEncodeH264RateControlInfoEXT: return "VideoEncodeH264RateControlInfoEXT"; case StructureType::eVideoEncodeH264RateControlLayerInfoEXT: return "VideoEncodeH264RateControlLayerInfoEXT"; + case StructureType::eVideoEncodeH264SessionCreateInfoEXT: return "VideoEncodeH264SessionCreateInfoEXT"; + case StructureType::eVideoEncodeH264QualityLevelPropertiesEXT: return "VideoEncodeH264QualityLevelPropertiesEXT"; + case StructureType::eVideoEncodeH264SessionParametersGetInfoEXT: return "VideoEncodeH264SessionParametersGetInfoEXT"; + case StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT: return "VideoEncodeH264SessionParametersFeedbackInfoEXT"; case StructureType::eVideoEncodeH265CapabilitiesEXT: return "VideoEncodeH265CapabilitiesEXT"; case StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT: return "VideoEncodeH265SessionParametersCreateInfoEXT"; case StructureType::eVideoEncodeH265SessionParametersAddInfoEXT: return "VideoEncodeH265SessionParametersAddInfoEXT"; - case StructureType::eVideoEncodeH265VclFrameInfoEXT: return "VideoEncodeH265VclFrameInfoEXT"; + case StructureType::eVideoEncodeH265PictureInfoEXT: return "VideoEncodeH265PictureInfoEXT"; case StructureType::eVideoEncodeH265DpbSlotInfoEXT: return "VideoEncodeH265DpbSlotInfoEXT"; case StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT: return "VideoEncodeH265NaluSliceSegmentInfoEXT"; + case StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT: return "VideoEncodeH265GopRemainingFrameInfoEXT"; case StructureType::eVideoEncodeH265ProfileInfoEXT: return "VideoEncodeH265ProfileInfoEXT"; case StructureType::eVideoEncodeH265RateControlInfoEXT: return "VideoEncodeH265RateControlInfoEXT"; case StructureType::eVideoEncodeH265RateControlLayerInfoEXT: return "VideoEncodeH265RateControlLayerInfoEXT"; + case StructureType::eVideoEncodeH265SessionCreateInfoEXT: return "VideoEncodeH265SessionCreateInfoEXT"; + case StructureType::eVideoEncodeH265QualityLevelPropertiesEXT: return "VideoEncodeH265QualityLevelPropertiesEXT"; + case StructureType::eVideoEncodeH265SessionParametersGetInfoEXT: return "VideoEncodeH265SessionParametersGetInfoEXT"; + case StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT: return "VideoEncodeH265SessionParametersFeedbackInfoEXT"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ case StructureType::eVideoDecodeH264CapabilitiesKHR: return "VideoDecodeH264CapabilitiesKHR"; case StructureType::eVideoDecodeH264PictureInfoKHR: return "VideoDecodeH264PictureInfoKHR"; @@ -3930,6 +4012,11 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eVideoEncodeCapabilitiesKHR: return "VideoEncodeCapabilitiesKHR"; case StructureType::eVideoEncodeUsageInfoKHR: return "VideoEncodeUsageInfoKHR"; case StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR: return "QueryPoolVideoEncodeFeedbackCreateInfoKHR"; + case StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR: return "PhysicalDeviceVideoEncodeQualityLevelInfoKHR"; + case StructureType::eVideoEncodeQualityLevelPropertiesKHR: return "VideoEncodeQualityLevelPropertiesKHR"; + case StructureType::eVideoEncodeQualityLevelInfoKHR: return "VideoEncodeQualityLevelInfoKHR"; + case StructureType::eVideoEncodeSessionParametersGetInfoKHR: return "VideoEncodeSessionParametersGetInfoKHR"; + case StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR: return "VideoEncodeSessionParametersFeedbackInfoKHR"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV: return "PhysicalDeviceDiagnosticsConfigFeaturesNV"; case StructureType::eDeviceDiagnosticsConfigCreateInfoNV: return "DeviceDiagnosticsConfigCreateInfoNV"; @@ -6604,6 +6691,9 @@ namespace VULKAN_HPP_NAMESPACE switch ( value ) { case VideoSessionCreateFlagBitsKHR::eProtectedContent: return "ProtectedContent"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations: return "AllowEncodeParameterOptimizations"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6615,7 +6705,7 @@ namespace VULKAN_HPP_NAMESPACE case VideoCodingControlFlagBitsKHR::eReset: return "Reset"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case VideoCodingControlFlagBitsKHR::eEncodeRateControl: return "EncodeRateControl"; - case VideoCodingControlFlagBitsKHR::eEncodeRateControlLayer: return "EncodeRateControlLayer"; + case VideoCodingControlFlagBitsKHR::eEncodeQualityLevel: return "EncodeQualityLevel"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } @@ -6690,43 +6780,54 @@ namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceEnabled: return "Direct8X8InferenceEnabled"; - case VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceDisabled: return "Direct8X8InferenceDisabled"; - 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::eSliceMbCount: return "SliceMbCount"; + case VideoEncodeH264CapabilityFlagBitsEXT::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated"; case VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice: return "RowUnalignedSlice"; case VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType: return "DifferentSliceType"; + case VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL0List: return "BFrameInL0List"; case VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List: return "BFrameInL1List"; - case VideoEncodeH264CapabilityFlagBitsEXT::eDifferentReferenceFinalLists: return "DifferentReferenceFinalLists"; + case VideoEncodeH264CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp: return "PerPictureTypeMinMaxQp"; + case VideoEncodeH264CapabilityFlagBitsEXT::ePerSliceConstantQp: return "PerSliceConstantQp"; + case VideoEncodeH264CapabilityFlagBitsEXT::eGeneratePrefixNalu: return "GeneratePrefixNalu"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264StdFlagBitsEXT value ) + { + switch ( value ) + { + case VideoEncodeH264StdFlagBitsEXT::eSeparateColorPlaneFlagSet: return "SeparateColorPlaneFlagSet"; + case VideoEncodeH264StdFlagBitsEXT::eQpprimeYZeroTransformBypassFlagSet: return "QpprimeYZeroTransformBypassFlagSet"; + case VideoEncodeH264StdFlagBitsEXT::eScalingMatrixPresentFlagSet: return "ScalingMatrixPresentFlagSet"; + case VideoEncodeH264StdFlagBitsEXT::eChromaQpIndexOffset: return "ChromaQpIndexOffset"; + case VideoEncodeH264StdFlagBitsEXT::eSecondChromaQpIndexOffset: return "SecondChromaQpIndexOffset"; + case VideoEncodeH264StdFlagBitsEXT::ePicInitQpMinus26: return "PicInitQpMinus26"; + case VideoEncodeH264StdFlagBitsEXT::eWeightedPredFlagSet: return "WeightedPredFlagSet"; + case VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcExplicit: return "WeightedBipredIdcExplicit"; + case VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcImplicit: return "WeightedBipredIdcImplicit"; + case VideoEncodeH264StdFlagBitsEXT::eTransform8X8ModeFlagSet: return "Transform8X8ModeFlagSet"; + case VideoEncodeH264StdFlagBitsEXT::eDirectSpatialMvPredFlagUnset: return "DirectSpatialMvPredFlagUnset"; + case VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagUnset: return "EntropyCodingModeFlagUnset"; + case VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagSet: return "EntropyCodingModeFlagSet"; + case VideoEncodeH264StdFlagBitsEXT::eDirect8X8InferenceFlagUnset: return "Direct8X8InferenceFlagUnset"; + case VideoEncodeH264StdFlagBitsEXT::eConstrainedIntraPredFlagSet: return "ConstrainedIntraPredFlagSet"; + case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled: return "DeblockingFilterDisabled"; + case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled"; + case VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlStructureEXT value ) + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlFlagBitsEXT value ) { switch ( value ) { - case VideoEncodeH264RateControlStructureEXT::eUnknown: return "Unknown"; - case VideoEncodeH264RateControlStructureEXT::eFlat: return "Flat"; - case VideoEncodeH264RateControlStructureEXT::eDyadic: return "Dyadic"; + case VideoEncodeH264RateControlFlagBitsEXT::eAttemptHrdCompliance: return "AttemptHrdCompliance"; + case VideoEncodeH264RateControlFlagBitsEXT::eRegularGop: return "RegularGop"; + case VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternFlat: return "ReferencePatternFlat"; + case VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternDyadic: return "ReferencePatternDyadic"; + case VideoEncodeH264RateControlFlagBitsEXT::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6739,33 +6840,43 @@ namespace VULKAN_HPP_NAMESPACE { 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::eTransformSkipDisabled: return "TransformSkipDisabled"; - 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::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated"; case VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment: return "RowUnalignedSliceSegment"; - case VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment: return "DependentSliceSegment"; - case VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType: return "DifferentSliceType"; + case VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceSegmentType: return "DifferentSliceSegmentType"; + case VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL0List: return "BFrameInL0List"; case VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List: return "BFrameInL1List"; - case VideoEncodeH265CapabilityFlagBitsEXT::eDifferentReferenceFinalLists: return "DifferentReferenceFinalLists"; + case VideoEncodeH265CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp: return "PerPictureTypeMinMaxQp"; + case VideoEncodeH265CapabilityFlagBitsEXT::ePerSliceSegmentConstantQp: return "PerSliceSegmentConstantQp"; + case VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilesPerSliceSegment: return "MultipleTilesPerSliceSegment"; + case VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSliceSegmentsPerTile: return "MultipleSliceSegmentsPerTile"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265StdFlagBitsEXT value ) + { + switch ( value ) + { + case VideoEncodeH265StdFlagBitsEXT::eSeparateColorPlaneFlagSet: return "SeparateColorPlaneFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eSampleAdaptiveOffsetEnabledFlagSet: return "SampleAdaptiveOffsetEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eScalingListDataPresentFlagSet: return "ScalingListDataPresentFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::ePcmEnabledFlagSet: return "PcmEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eSpsTemporalMvpEnabledFlagSet: return "SpsTemporalMvpEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eInitQpMinus26: return "InitQpMinus26"; + case VideoEncodeH265StdFlagBitsEXT::eWeightedPredFlagSet: return "WeightedPredFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eWeightedBipredFlagSet: return "WeightedBipredFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eLog2ParallelMergeLevelMinus2: return "Log2ParallelMergeLevelMinus2"; + case VideoEncodeH265StdFlagBitsEXT::eSignDataHidingEnabledFlagSet: return "SignDataHidingEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagSet: return "TransformSkipEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagUnset: return "TransformSkipEnabledFlagUnset"; + case VideoEncodeH265StdFlagBitsEXT::ePpsSliceChromaQpOffsetsPresentFlagSet: return "PpsSliceChromaQpOffsetsPresentFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eTransquantBypassEnabledFlagSet: return "TransquantBypassEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eConstrainedIntraPredFlagSet: return "ConstrainedIntraPredFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eEntropyCodingSyncEnabledFlagSet: return "EntropyCodingSyncEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet: return "DeblockingFilterOverrideEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet: return "DependentSliceSegmentsEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet: return "DependentSliceSegmentFlagSet"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6793,13 +6904,15 @@ namespace VULKAN_HPP_NAMESPACE } } - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlStructureEXT value ) + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlFlagBitsEXT value ) { switch ( value ) { - case VideoEncodeH265RateControlStructureEXT::eUnknown: return "Unknown"; - case VideoEncodeH265RateControlStructureEXT::eFlat: return "Flat"; - case VideoEncodeH265RateControlStructureEXT::eDyadic: return "Dyadic"; + case VideoEncodeH265RateControlFlagBitsEXT::eAttemptHrdCompliance: return "AttemptHrdCompliance"; + case VideoEncodeH265RateControlFlagBitsEXT::eRegularGop: return "RegularGop"; + case VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternFlat: return "ReferencePatternFlat"; + case VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternDyadic: return "ReferencePatternDyadic"; + case VideoEncodeH265RateControlFlagBitsEXT::eTemporalSubLayerPatternDyadic: return "TemporalSubLayerPatternDyadic"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -7799,6 +7912,7 @@ namespace VULKAN_HPP_NAMESPACE { case VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit: return "streamBufferOffsetBit"; case VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit: return "streamBytesWrittenBit"; + case VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit: return "streamHasOverridesBit"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } diff --git a/registry/generator.py b/registry/generator.py index 37ae277..56a6310 100644 --- a/registry/generator.py +++ b/registry/generator.py @@ -1021,6 +1021,30 @@ class OutputGenerator: Extend to generate as desired in your derived class.""" return + def genSyncStage(self, stageinfo): + """Generate interface for a sync stage element. + + - stageinfo - SyncStageInfo + + Extend to generate as desired in your derived class.""" + return + + def genSyncAccess(self, accessinfo): + """Generate interface for a sync stage element. + + - accessinfo - AccessInfo + + Extend to generate as desired in your derived class.""" + return + + def genSyncPipeline(self, pipelineinfo): + """Generate interface for a sync stage element. + + - pipelineinfo - SyncPipelineInfo + + Extend to generate as desired in your derived class.""" + return + def makeProtoName(self, name, tail): """Turn a `` `` into C-language prototype and typedef declarations for that name. diff --git a/registry/genvk.py b/registry/genvk.py index 98618c1..53637c4 100755 --- a/registry/genvk.py +++ b/registry/genvk.py @@ -31,6 +31,7 @@ from generator import write from spirvcapgenerator import SpirvCapabilityOutputGenerator from hostsyncgenerator import HostSynchronizationOutputGenerator from formatsgenerator import FormatsOutputGenerator +from syncgenerator import SyncOutputGenerator from jsgenerator import JSOutputGenerator from pygenerator import PyOutputGenerator from rubygenerator import RubyOutputGenerator @@ -371,6 +372,25 @@ def makeGenOpts(args): reparentEnums = False) ] + # Used to generate various synchronization chapter tables + genOpts['syncinc'] = [ + SyncOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + reparentEnums = False) + ] + # Platform extensions, in their own header files # Each element of the platforms[] array defines information for # generating a single platform: diff --git a/registry/reg.py b/registry/reg.py index 3ff580d..65a3ac2 100644 --- a/registry/reg.py +++ b/registry/reg.py @@ -376,6 +376,28 @@ class FormatInfo(BaseInfo): # Need to save the condition here when it is known self.condition = condition +class SyncStageInfo(BaseInfo): + """Registry information about .""" + + def __init__(self, elem, condition): + BaseInfo.__init__(self, elem) + # Need to save the condition here when it is known + self.condition = condition + +class SyncAccessInfo(BaseInfo): + """Registry information about .""" + + def __init__(self, elem, condition): + BaseInfo.__init__(self, elem) + # Need to save the condition here when it is known + self.condition = condition + +class SyncPipelineInfo(BaseInfo): + """Registry information about .""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + class Registry: """Object representing an API registry, loaded from an XML file.""" @@ -432,6 +454,15 @@ class Registry: self.formatsdict = {} "dictionary of FeatureInfo objects for `` elements keyed by VkFormat name" + self.syncstagedict = {} + "dictionary of Sync*Info objects for `` elements keyed by VkPipelineStageFlagBits2 name" + + self.syncaccessdict = {} + "dictionary of Sync*Info objects for `` elements keyed by VkAccessFlagBits2 name" + + self.syncpipelinedict = {} + "dictionary of Sync*Info objects for `` elements keyed by pipeline type name" + self.emitFeatures = False """True to actually emit features for a version / extension, or False to just treat them as emitted""" @@ -477,10 +508,10 @@ class Registry: Intended for internal use only. - - elem - ``/``/``/``/``/``/``/``/`` Element - - info - corresponding {Type|Group|Enum|Cmd|Feature|Spirv|Format}Info object - - infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' / 'spirvextension' / 'spirvcapability' / 'format' - - dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap}dict + - elem - ``/``/``/``/``/``/``/``/``/``/``/`` Element + - info - corresponding {Type|Group|Enum|Cmd|Feature|Spirv|Format|SyncStage|SyncAccess|SyncPipeline}Info object + - infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' / 'spirvextension' / 'spirvcapability' / 'format' / 'syncstage' / 'syncaccess' / 'syncpipeline' + - dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap|sync}dict The dictionary key is the element 'name' attribute.""" @@ -683,6 +714,9 @@ class Registry: enumInfo = EnumInfo(enum) self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) + sync_pipeline_stage_condition = dict() + sync_access_condition = dict() + self.extensions = self.reg.findall('extensions/extension') self.extdict = {} for feature in self.extensions: @@ -730,6 +764,25 @@ class Registry: format_condition[format_name] += "," + featureInfo.name else: format_condition[format_name] = featureInfo.name + elif groupName == "VkPipelineStageFlagBits2": + stage_flag = enum.get('name') + if enum.get('alias'): + stage_flag = enum.get('alias') + featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name + if stage_flag in sync_pipeline_stage_condition: + sync_pipeline_stage_condition[stage_flag] += "," + featureName + else: + sync_pipeline_stage_condition[stage_flag] = featureName + elif groupName == "VkAccessFlagBits2": + access_flag = enum.get('name') + if enum.get('alias'): + access_flag = enum.get('alias') + featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name + if access_flag in sync_access_condition: + sync_access_condition[access_flag] += "," + featureName + else: + sync_access_condition[access_flag] = featureName + addEnumInfo = True elif enum.get('value') or enum.get('bitpos') or enum.get('alias'): # self.gen.logMsg('diag', 'Adding extension constant "enum"', @@ -756,6 +809,26 @@ class Registry: formatInfo = FormatInfo(format, condition) self.addElementInfo(format, formatInfo, 'format', self.formatsdict) + for stage in self.reg.findall('sync/syncstage'): + condition = None + stage_flag = stage.get('name') + if stage_flag in sync_pipeline_stage_condition: + condition = sync_pipeline_stage_condition[stage_flag] + syncInfo = SyncStageInfo(stage, condition) + self.addElementInfo(stage, syncInfo, 'syncstage', self.syncstagedict) + + for access in self.reg.findall('sync/syncaccess'): + condition = None + access_flag = access.get('name') + if access_flag in sync_access_condition: + condition = sync_access_condition[access_flag] + syncInfo = SyncAccessInfo(access, condition) + self.addElementInfo(access, syncInfo, 'syncaccess', self.syncaccessdict) + + for pipeline in self.reg.findall('sync/syncpipeline'): + syncInfo = SyncPipelineInfo(pipeline) + self.addElementInfo(pipeline, syncInfo, 'syncpipeline', self.syncpipelinedict) + def dumpReg(self, maxlen=120, filehandle=sys.stdout): """Dump all the dictionaries constructed from the Registry object. @@ -1440,6 +1513,18 @@ class Registry: genProc = self.gen.genFormat genProc(format, name, alias) + def generateSyncStage(self, sync): + genProc = self.gen.genSyncStage + genProc(sync) + + def generateSyncAccess(self, sync): + genProc = self.gen.genSyncAccess + genProc(sync) + + def generateSyncPipeline(self, sync): + genProc = self.gen.genSyncPipeline + genProc(sync) + def tagValidExtensionStructs(self): """Construct a "validextensionstructs" list for parent structures based on "structextends" tags in child structures. @@ -1664,6 +1749,12 @@ class Registry: self.generateSpirv(s, self.spirvcapdict) for s in formats: self.generateFormat(s, self.formatsdict) + for s in self.syncstagedict: + self.generateSyncStage(self.syncstagedict[s]) + for s in self.syncaccessdict: + self.generateSyncAccess(self.syncaccessdict[s]) + for s in self.syncpipelinedict: + self.generateSyncPipeline(self.syncpipelinedict[s]) self.gen.endFile() def apiReset(self): diff --git a/registry/validusage.json b/registry/validusage.json index a8c619a..ff8cc27 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.3.252", - "comment": "from git branch: github-main commit: 5718db0a370b5bd91e6cf2268a3dc2af9cfc15d1", - "date": "2023-06-02 12:04:26Z" + "api version": "1.3.253", + "comment": "from git branch: github-main commit: 45c0a582bbff022efc3b8c8019f94256b64f54af", + "date": "2023-06-10 02:50:38Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -13694,7 +13694,15 @@ }, { "vuid": "VUID-VkGraphicsPipelineCreateInfo-Input-08733", - "text": " If the pipeline requires vertex input state and pVertexInputState is not dynamic, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription" + "text": " If the pipeline requires vertex input state and pVertexInputState is not dynamic, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription::format" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-08929", + "text": " If the pipeline is being created with vertex input state and pVertexInputState is not dynamic, and VkVertexInputAttributeDescription::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-08930", + "text": " If the pipeline is being created with vertex input state and pVertexInputState is not dynamic, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription::format must have a 64-bit component" }, { "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02098", @@ -20346,18 +20354,10 @@ "vuid": "VUID-VkImageViewCreateInfo-usage-02275", "text": " If usage contains VK_IMAGE_USAGE_STORAGE_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT" }, - { - "vuid": "VUID-VkImageViewCreateInfo-usage-02276", - "text": " If usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" - }, { "vuid": "VUID-VkImageViewCreateInfo-usage-02277", "text": " If usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" }, - { - "vuid": "VUID-VkImageViewCreateInfo-usage-02652", - "text": " If usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then the image view’s format features must contain at least one of VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" - }, { "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01478", "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" @@ -20491,14 +20491,24 @@ "text": " If image was created with VK_IMAGE_TYPE_3D and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY then VkImageCreateInfo::flags must not contain any of VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" } ], + "!(VK_NV_linear_color_attachment)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-usage-02276", + "text": " If usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-02652", + "text": " If usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then the image view’s format features must contain at least one of VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], "(VK_NV_linear_color_attachment)": [ { - "vuid": "VUID-VkImageViewCreateInfo-usage-06516", - "text": " If usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, if the image is created with VK_IMAGE_TILING_LINEAR and the linearColorAttachment feature is enabled" + "vuid": "VUID-VkImageViewCreateInfo-usage-08931", + "text": " If usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" }, { - "vuid": "VUID-VkImageViewCreateInfo-usage-06517", - "text": " If usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, if the image is created with VK_IMAGE_TILING_LINEAR and the linearColorAttachment feature is enabled" + "vuid": "VUID-VkImageViewCreateInfo-usage-08932", + "text": " If usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then the image view’s format features must contain at least one of VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT or, VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV" } ], "(VK_EXT_fragment_density_map)": [ @@ -21204,7 +21214,7 @@ "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ { "vuid": "VUID-vkCreateAccelerationStructureKHR-accelerationStructure-03611", - "text": " The accelerationStructure feature must be enabled" + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" }, { "vuid": "VUID-vkCreateAccelerationStructureKHR-deviceAddress-03488", @@ -21285,12 +21295,12 @@ ], "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)+(VK_NV_ray_tracing_motion_blur)": [ { - "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-flags-04954", - "text": " If VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV is set in flags and type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, one member of the pNext chain must be a pointer to a valid instance of VkAccelerationStructureMotionInfoNV" + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-createFlags-04954", + "text": " If VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV is set in createFlags and type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, one member of the pNext chain must be a pointer to a valid instance of VkAccelerationStructureMotionInfoNV" }, { - "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-flags-04955", - "text": " If any geometry includes VkAccelerationStructureGeometryMotionTrianglesDataNV then flags must contain VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV" + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-createFlags-04955", + "text": " If any geometry includes VkAccelerationStructureGeometryMotionTrianglesDataNV then createFlags must contain VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV" } ], "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)+(VK_EXT_descriptor_buffer)": [ @@ -21319,8 +21329,8 @@ "vkGetAccelerationStructureBuildSizesKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ { - "vuid": "VUID-vkGetAccelerationStructureBuildSizesKHR-rayTracingPipeline-03617", - "text": " The rayTracingPipeline or rayQuery feature must be enabled" + "vuid": "VUID-vkGetAccelerationStructureBuildSizesKHR-accelerationStructure-08933", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" }, { "vuid": "VUID-vkGetAccelerationStructureBuildSizesKHR-device-03618", @@ -21522,6 +21532,10 @@ }, "vkDestroyAccelerationStructureKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-08934", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" + }, { "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02442", "text": " All submitted commands that refer to accelerationStructure must have completed execution" @@ -21722,6 +21736,10 @@ }, "vkGetAccelerationStructureDeviceAddressKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkGetAccelerationStructureDeviceAddressKHR-accelerationStructure-08935", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" + }, { "vuid": "VUID-vkGetAccelerationStructureDeviceAddressKHR-device-03504", "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled" @@ -36614,7 +36632,15 @@ }, { "vuid": "VUID-vkCmdDraw-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDraw-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDraw-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_EXT_extended_dynamic_state2)": [ @@ -38254,7 +38280,15 @@ }, { "vuid": "VUID-vkCmdDrawIndexed-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_EXT_extended_dynamic_state2)": [ @@ -39902,7 +39936,15 @@ }, { "vuid": "VUID-vkCmdDrawMultiEXT-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state2)": [ @@ -41562,7 +41604,15 @@ }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state2)": [ @@ -43224,7 +43274,15 @@ }, { "vuid": "VUID-vkCmdDrawIndirect-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_EXT_extended_dynamic_state2)": [ @@ -44918,7 +44976,15 @@ }, { "vuid": "VUID-vkCmdDrawIndirectCount-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state2)": [ @@ -46594,7 +46660,15 @@ }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_EXT_extended_dynamic_state2)": [ @@ -48296,7 +48370,15 @@ }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state2)": [ @@ -49956,7 +50038,15 @@ }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state2)": [ @@ -70812,7 +70902,15 @@ }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-Input-08734", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then all variables with the Input storage class decorated with Location in the Vertex {ExecutionModel} OpEntryPoint must be the same numeric type as the matching location in VkVertexInputAttributeDescription2EXT" + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then the numeric type associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-format-08936", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then the scalar width associated with all Input variables of the corresponding Location in the Vertex {ExecutionModel} OpEntryPoint must be 64-bit" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-format-08937", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, and the scalar width associated with a Location decorated Input variable in the Vertex {ExecutionModel} OpEntryPoint is 64-bit, then the corresponding VkVertexInputAttributeDescription2EXT::format must have a 64-bit component" } ], "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state2)": [ @@ -74890,6 +74988,10 @@ }, "vkCmdBuildAccelerationStructuresKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-accelerationStructure-08923", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" + }, { "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-mode-04628", "text": " The mode member of each element of pInfos must be a valid VkBuildAccelerationStructureModeKHR value" @@ -75178,6 +75280,10 @@ }, "vkCmdBuildAccelerationStructuresIndirectKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-accelerationStructureIndirectBuild-03650", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureIndirectBuild feature must be enabled" + }, { "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-mode-04628", "text": " The mode member of each element of pInfos must be a valid VkBuildAccelerationStructureModeKHR value" @@ -75446,10 +75552,6 @@ "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-commandBuffer-03649", "text": " commandBuffer must not be a protected command buffer" }, - { - "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-accelerationStructureIndirectBuild-03650", - "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureIndirectBuild feature must be enabled" - }, { "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03651", "text": " Each VkAccelerationStructureBuildRangeInfoKHR structure referenced by any element of pIndirectDeviceAddresses must be a valid VkAccelerationStructureBuildRangeInfoKHR structure" @@ -75870,6 +75972,10 @@ }, "vkCmdWriteAccelerationStructuresPropertiesKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-accelerationStructure-08924", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" + }, { "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-queryPool-02493", "text": " queryPool must have been created with a queryType matching queryType" @@ -76086,6 +76192,10 @@ }, "vkCmdCopyAccelerationStructureKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdCopyAccelerationStructureKHR-accelerationStructure-08925", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" + }, { "vuid": "VUID-vkCmdCopyAccelerationStructureKHR-buffer-03737", "text": " The buffer used to create pInfo->src must be bound to device memory" @@ -76178,6 +76288,10 @@ }, "vkCmdCopyAccelerationStructureToMemoryKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-accelerationStructure-08926", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" + }, { "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-pInfo-03739", "text": " pInfo->dst.deviceAddress must be a valid device address for a buffer bound to device memory" @@ -76254,6 +76368,10 @@ }, "vkCmdCopyMemoryToAccelerationStructureKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-accelerationStructure-08927", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" + }, { "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-pInfo-03742", "text": " pInfo->src.deviceAddress must be a valid device address for a buffer bound to device memory" @@ -76335,8 +76453,8 @@ "vkGetDeviceAccelerationStructureCompatibilityKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ { - "vuid": "VUID-vkGetDeviceAccelerationStructureCompatibilityKHR-rayTracingPipeline-03661", - "text": " The rayTracingPipeline or rayQuery feature must be enabled" + "vuid": "VUID-vkGetDeviceAccelerationStructureCompatibilityKHR-accelerationStructure-08928", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure feature must be enabled" }, { "vuid": "VUID-vkGetDeviceAccelerationStructureCompatibilityKHR-device-parameter", @@ -76370,6 +76488,10 @@ }, "vkBuildAccelerationStructuresKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-accelerationStructureHostCommands-03581", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + }, { "vuid": "VUID-vkBuildAccelerationStructuresKHR-mode-04628", "text": " The mode member of each element of pInfos must be a valid VkBuildAccelerationStructureModeKHR value" @@ -76530,10 +76652,6 @@ "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03724", "text": " For each element of pInfos, the buffer used to create each acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR must be bound to host-visible device memory" }, - { - "vuid": "VUID-vkBuildAccelerationStructuresKHR-accelerationStructureHostCommands-03581", - "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" - }, { "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03725", "text": " If pInfos[i].mode is VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, all addresses between pInfos[i].scratchData.hostAddress and pInfos[i].scratchData.hostAddress + N - 1 must be valid host memory, where N is given by the buildScratchSize member of the VkAccelerationStructureBuildSizesInfoKHR structure returned from a call to vkGetAccelerationStructureBuildSizesKHR with an identical VkAccelerationStructureBuildGeometryInfoKHR structure and primitive count" @@ -76614,6 +76732,10 @@ }, "vkCopyAccelerationStructureKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-accelerationStructureHostCommands-03582", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands" + }, { "vuid": "VUID-vkCopyAccelerationStructureKHR-deferredOperation-03677", "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" @@ -76628,11 +76750,7 @@ }, { "vuid": "VUID-vkCopyAccelerationStructureKHR-buffer-03728", - "text": " The buffer used to create pInfo->dst must be bound to host-visible device memory" - }, - { - "vuid": "VUID-vkCopyAccelerationStructureKHR-accelerationStructureHostCommands-03582", - "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + "text": " The buffer used to create pInfo->dst must be bound to host-visible device memory feature must be enabled" }, { "vuid": "VUID-vkCopyAccelerationStructureKHR-device-parameter", @@ -76664,6 +76782,10 @@ }, "vkCopyMemoryToAccelerationStructureKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-accelerationStructureHostCommands-03583", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + }, { "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-deferredOperation-03677", "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" @@ -76684,10 +76806,6 @@ "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-buffer-03730", "text": " The buffer used to create pInfo->dst must be bound to host-visible device memory" }, - { - "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-accelerationStructureHostCommands-03583", - "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" - }, { "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-device-parameter", "text": " device must be a valid VkDevice handle" @@ -76714,6 +76832,10 @@ }, "vkCopyAccelerationStructureToMemoryKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-accelerationStructureHostCommands-03584", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + }, { "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-deferredOperation-03677", "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" @@ -76734,10 +76856,6 @@ "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-pInfo-03751", "text": " pInfo->dst.hostAddress must be aligned to 16 bytes" }, - { - "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-accelerationStructureHostCommands-03584", - "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" - }, { "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-device-parameter", "text": " device must be a valid VkDevice handle" @@ -76764,6 +76882,10 @@ }, "vkWriteAccelerationStructuresPropertiesKHR": { "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-accelerationStructureHostCommands-03585", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + }, { "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-pAccelerationStructures-04964", "text": " All acceleration structures in pAccelerationStructures must have been built prior to the execution of this command" @@ -76796,10 +76918,6 @@ "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-buffer-03733", "text": " The buffer used to create each acceleration structure in pAccelerationStructures must be bound to host-visible device memory" }, - { - "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-accelerationStructureHostCommands-03585", - "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" - }, { "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-device-parameter", "text": " device must be a valid VkDevice handle" @@ -80204,7 +80322,11 @@ }, { "vuid": "VUID-VkVideoSessionCreateInfoKHR-pNext-pNext", - "text": " pNext must be NULL" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionCreateInfoEXT or VkVideoEncodeH265SessionCreateInfoEXT" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" }, { "vuid": "VUID-VkVideoSessionCreateInfoKHR-flags-parameter", @@ -80420,7 +80542,7 @@ }, { "vuid": "VUID-VkVideoSessionParametersCreateInfoKHR-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264SessionParametersCreateInfoKHR, VkVideoDecodeH265SessionParametersCreateInfoKHR, VkVideoEncodeH264SessionParametersCreateInfoEXT, or VkVideoEncodeH265SessionParametersCreateInfoEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoDecodeH264SessionParametersCreateInfoKHR, VkVideoDecodeH265SessionParametersCreateInfoKHR, VkVideoEncodeH264SessionParametersCreateInfoEXT, VkVideoEncodeH265SessionParametersCreateInfoEXT, or VkVideoEncodeQualityLevelInfoKHR" }, { "vuid": "VUID-VkVideoSessionParametersCreateInfoKHR-sType-unique", @@ -80732,7 +80854,11 @@ }, { "vuid": "VUID-VkVideoBeginCodingInfoKHR-pNext-pNext", - "text": " pNext must be NULL" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264GopRemainingFrameInfoEXT, VkVideoEncodeH264RateControlInfoEXT, VkVideoEncodeH265GopRemainingFrameInfoEXT, VkVideoEncodeH265RateControlInfoEXT, or VkVideoEncodeRateControlInfoKHR" + }, + { + "vuid": "VUID-VkVideoBeginCodingInfoKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" }, { "vuid": "VUID-VkVideoBeginCodingInfoKHR-flags-zerobitmask", @@ -80909,14 +81035,6 @@ { "vuid": "VUID-VkVideoCodingControlInfoKHR-flags-07018", "text": " If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, then the pNext chain must include a VkVideoEncodeRateControlInfoKHR structure" - }, - { - "vuid": "VUID-VkVideoCodingControlInfoKHR-flags-07019", - "text": " If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR, then the pNext chain must include a VkVideoEncodeRateControlLayerInfoKHR structure" - }, - { - "vuid": "VUID-VkVideoCodingControlInfoKHR-flags-07020", - "text": " If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, then it must not also include VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR" } ], "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ @@ -80927,10 +81045,6 @@ { "vuid": "VUID-VkVideoCodingControlInfoKHR-pNext-07022", "text": " If the pNext chain includes a VkVideoEncodeRateControlInfoKHR, and VkVideoEncodeRateControlInfoKHR::layerCount is greater than 1, then VkVideoEncodeH264RateControlInfoEXT::temporalLayerCount must be equal to layerCount" - }, - { - "vuid": "VUID-VkVideoCodingControlInfoKHR-flags-07023", - "text": " If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR and the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT, then the pNext chain must include a VkVideoEncodeH264RateControlLayerInfoEXT structure" } ], "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ @@ -80941,10 +81055,6 @@ { "vuid": "VUID-VkVideoCodingControlInfoKHR-pNext-07025", "text": " If the pNext chain includes a VkVideoEncodeRateControlInfoKHR, and VkVideoEncodeRateControlInfoKHR::layerCount is greater than 1, then VkVideoEncodeH265RateControlInfoEXT::subLayerCount must be equal to layerCount" - }, - { - "vuid": "VUID-VkVideoCodingControlInfoKHR-flags-07026", - "text": " If flags includes VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR and the bound video session was created with the video codec operation VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT, then the pNext chain must include a VkVideoEncodeH265RateControlLayerInfoEXT structure" } ], "(VK_KHR_video_queue)": [ @@ -80954,7 +81064,7 @@ }, { "vuid": "VUID-VkVideoCodingControlInfoKHR-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264RateControlInfoEXT, VkVideoEncodeH264RateControlLayerInfoEXT, VkVideoEncodeH265RateControlInfoEXT, VkVideoEncodeH265RateControlLayerInfoEXT, VkVideoEncodeRateControlInfoKHR, or VkVideoEncodeRateControlLayerInfoKHR" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264RateControlInfoEXT, VkVideoEncodeH265RateControlInfoEXT, VkVideoEncodeQualityLevelInfoKHR, or VkVideoEncodeRateControlInfoKHR" }, { "vuid": "VUID-VkVideoCodingControlInfoKHR-sType-unique", @@ -81478,6 +81588,122 @@ } ] }, + "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR": { + "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-pQualityLevelInfo-parameter", + "text": " pQualityLevelInfo must be a valid pointer to a valid VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR-pQualityLevelProperties-parameter", + "text": " pQualityLevelProperties must be a valid pointer to a VkVideoEncodeQualityLevelPropertiesKHR structure" + } + ] + }, + "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR": { + "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR" + }, + { + "vuid": "VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR-pVideoProfile-parameter", + "text": " pVideoProfile must be a valid pointer to a valid VkVideoProfileInfoKHR structure" + } + ] + }, + "VkVideoEncodeQualityLevelPropertiesKHR": { + "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkVideoEncodeQualityLevelPropertiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR" + }, + { + "vuid": "VUID-VkVideoEncodeQualityLevelPropertiesKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264QualityLevelPropertiesEXT or VkVideoEncodeH265QualityLevelPropertiesEXT" + }, + { + "vuid": "VUID-VkVideoEncodeQualityLevelPropertiesKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkVideoEncodeQualityLevelInfoKHR": { + "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkVideoEncodeQualityLevelInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR" + } + ] + }, + "vkGetEncodedVideoSessionParametersKHR": { + "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-vkGetEncodedVideoSessionParametersKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetEncodedVideoSessionParametersKHR-pVideoSessionParametersInfo-parameter", + "text": " pVideoSessionParametersInfo must be a valid pointer to a valid VkVideoEncodeSessionParametersGetInfoKHR structure" + }, + { + "vuid": "VUID-vkGetEncodedVideoSessionParametersKHR-pFeedbackInfo-parameter", + "text": " If pFeedbackInfo is not NULL, pFeedbackInfo must be a valid pointer to a VkVideoEncodeSessionParametersFeedbackInfoKHR structure" + }, + { + "vuid": "VUID-vkGetEncodedVideoSessionParametersKHR-pDataSize-parameter", + "text": " pDataSize must be a valid pointer to a size_t value" + }, + { + "vuid": "VUID-vkGetEncodedVideoSessionParametersKHR-pData-parameter", + "text": " If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes" + } + ] + }, + "VkVideoEncodeSessionParametersGetInfoKHR": { + "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkVideoEncodeSessionParametersGetInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR" + }, + { + "vuid": "VUID-VkVideoEncodeSessionParametersGetInfoKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionParametersGetInfoEXT or VkVideoEncodeH265SessionParametersGetInfoEXT" + }, + { + "vuid": "VUID-VkVideoEncodeSessionParametersGetInfoKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkVideoEncodeSessionParametersGetInfoKHR-videoSessionParameters-parameter", + "text": " videoSessionParameters must be a valid VkVideoSessionParametersKHR handle" + } + ] + }, + "VkVideoEncodeSessionParametersFeedbackInfoKHR": { + "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkVideoEncodeSessionParametersFeedbackInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR" + }, + { + "vuid": "VUID-VkVideoEncodeSessionParametersFeedbackInfoKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264SessionParametersFeedbackInfoEXT or VkVideoEncodeH265SessionParametersFeedbackInfoEXT" + }, + { + "vuid": "VUID-VkVideoEncodeSessionParametersFeedbackInfoKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, "vkCmdEncodeVideoKHR": { "(VK_KHR_video_queue)+(VK_KHR_video_encode_queue)": [ { @@ -81526,7 +81752,7 @@ }, { "vuid": "VUID-VkVideoEncodeInfoKHR-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264VclFrameInfoEXT or VkVideoEncodeH265VclFrameInfoEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264PictureInfoEXT or VkVideoEncodeH265PictureInfoEXT" }, { "vuid": "VUID-VkVideoEncodeInfoKHR-sType-unique", @@ -81579,6 +81805,14 @@ { "vuid": "VUID-VkVideoEncodeRateControlLayerInfoKHR-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR" + }, + { + "vuid": "VUID-VkVideoEncodeRateControlLayerInfoKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkVideoEncodeH264RateControlLayerInfoEXT or VkVideoEncodeH265RateControlLayerInfoEXT" + }, + { + "vuid": "VUID-VkVideoEncodeRateControlLayerInfoKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" } ] }, @@ -81598,6 +81832,22 @@ } ] }, + "VkVideoEncodeH264QualityLevelPropertiesEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ + { + "vuid": "VUID-VkVideoEncodeH264QualityLevelPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT" + } + ] + }, + "VkVideoEncodeH264SessionCreateInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ + { + "vuid": "VUID-VkVideoEncodeH264SessionCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT" + } + ] + }, "VkVideoEncodeH264SessionParametersCreateInfoEXT": { "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ { @@ -81662,26 +81912,38 @@ } ] }, - "VkVideoEncodeH264VclFrameInfoEXT": { + "VkVideoEncodeH264SessionParametersGetInfoEXT": { "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ { - "vuid": "VUID-VkVideoEncodeH264VclFrameInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT" - }, + "vuid": "VUID-VkVideoEncodeH264SessionParametersGetInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT" + } + ] + }, + "VkVideoEncodeH264SessionParametersFeedbackInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersFeedbackInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT" + } + ] + }, + "VkVideoEncodeH264PictureInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ { - "vuid": "VUID-VkVideoEncodeH264VclFrameInfoEXT-pStdReferenceFinalLists-parameter", - "text": " If pStdReferenceFinalLists is not NULL, pStdReferenceFinalLists must be a valid pointer to a valid StdVideoEncodeH264ReferenceListsInfo value" + "vuid": "VUID-VkVideoEncodeH264PictureInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT" }, { - "vuid": "VUID-VkVideoEncodeH264VclFrameInfoEXT-pNaluSliceEntries-parameter", + "vuid": "VUID-VkVideoEncodeH264PictureInfoEXT-pNaluSliceEntries-parameter", "text": " pNaluSliceEntries must be a valid pointer to an array of naluSliceEntryCount valid VkVideoEncodeH264NaluSliceInfoEXT structures" }, { - "vuid": "VUID-VkVideoEncodeH264VclFrameInfoEXT-pStdPictureInfo-parameter", + "vuid": "VUID-VkVideoEncodeH264PictureInfoEXT-pStdPictureInfo-parameter", "text": " pStdPictureInfo must be a valid pointer to a valid StdVideoEncodeH264PictureInfo value" }, { - "vuid": "VUID-VkVideoEncodeH264VclFrameInfoEXT-naluSliceEntryCount-arraylength", + "vuid": "VUID-VkVideoEncodeH264PictureInfoEXT-naluSliceEntryCount-arraylength", "text": " naluSliceEntryCount must be greater than 0" } ] @@ -81696,10 +81958,6 @@ "vuid": "VUID-VkVideoEncodeH264NaluSliceInfoEXT-pNext-pNext", "text": " pNext must be NULL" }, - { - "vuid": "VUID-VkVideoEncodeH264NaluSliceInfoEXT-pStdReferenceFinalLists-parameter", - "text": " If pStdReferenceFinalLists is not NULL, pStdReferenceFinalLists must be a valid pointer to a valid StdVideoEncodeH264ReferenceListsInfo value" - }, { "vuid": "VUID-VkVideoEncodeH264NaluSliceInfoEXT-pStdSliceHeader-parameter", "text": " pStdSliceHeader must be a valid pointer to a valid StdVideoEncodeH264SliceHeader value" @@ -81725,29 +81983,21 @@ "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT" }, { - "vuid": "VUID-VkVideoEncodeH264RateControlInfoEXT-rateControlStructure-parameter", - "text": " rateControlStructure must be a valid VkVideoEncodeH264RateControlStructureEXT value" + "vuid": "VUID-VkVideoEncodeH264RateControlInfoEXT-flags-parameter", + "text": " flags must be a valid combination of VkVideoEncodeH264RateControlFlagBitsEXT values" + }, + { + "vuid": "VUID-VkVideoEncodeH264RateControlInfoEXT-flags-requiredbitmask", + "text": " flags must not be 0" } ] }, "VkVideoEncodeH264RateControlLayerInfoEXT": { "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ - { - "vuid": "VUID-VkVideoEncodeH264RateControlLayerInfoEXT-rateControlMode-06474", - "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, both useMinQp and useMaxQp must be set to VK_TRUE" - }, - { - "vuid": "VUID-VkVideoEncodeH264RateControlLayerInfoEXT-rateControlMode-06475", - "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, the values provided in minQP must be identical to those provided in maxQp" - }, { "vuid": "VUID-VkVideoEncodeH264RateControlLayerInfoEXT-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT" }, - { - "vuid": "VUID-VkVideoEncodeH264RateControlLayerInfoEXT-initialRcQp-parameter", - "text": " initialRcQp must be a valid VkVideoEncodeH264QpEXT structure" - }, { "vuid": "VUID-VkVideoEncodeH264RateControlLayerInfoEXT-minQp-parameter", "text": " minQp must be a valid VkVideoEncodeH264QpEXT structure" @@ -81762,6 +82012,14 @@ } ] }, + "VkVideoEncodeH264GopRemainingFrameInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h264)": [ + { + "vuid": "VUID-VkVideoEncodeH264GopRemainingFrameInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT" + } + ] + }, "VkVideoEncodeH265ProfileInfoEXT": { "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ { @@ -81778,6 +82036,22 @@ } ] }, + "VkVideoEncodeH265QualityLevelPropertiesEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ + { + "vuid": "VUID-VkVideoEncodeH265QualityLevelPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT" + } + ] + }, + "VkVideoEncodeH265SessionCreateInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ + { + "vuid": "VUID-VkVideoEncodeH265SessionCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT" + } + ] + }, "VkVideoEncodeH265SessionParametersCreateInfoEXT": { "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ { @@ -81854,26 +82128,38 @@ } ] }, - "VkVideoEncodeH265VclFrameInfoEXT": { + "VkVideoEncodeH265SessionParametersGetInfoEXT": { "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ { - "vuid": "VUID-VkVideoEncodeH265VclFrameInfoEXT-sType-sType", - "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT" - }, + "vuid": "VUID-VkVideoEncodeH265SessionParametersGetInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT" + } + ] + }, + "VkVideoEncodeH265SessionParametersFeedbackInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersFeedbackInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT" + } + ] + }, + "VkVideoEncodeH265PictureInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ { - "vuid": "VUID-VkVideoEncodeH265VclFrameInfoEXT-pStdReferenceFinalLists-parameter", - "text": " If pStdReferenceFinalLists is not NULL, pStdReferenceFinalLists must be a valid pointer to a valid StdVideoEncodeH265ReferenceListsInfo value" + "vuid": "VUID-VkVideoEncodeH265PictureInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT" }, { - "vuid": "VUID-VkVideoEncodeH265VclFrameInfoEXT-pNaluSliceSegmentEntries-parameter", + "vuid": "VUID-VkVideoEncodeH265PictureInfoEXT-pNaluSliceSegmentEntries-parameter", "text": " pNaluSliceSegmentEntries must be a valid pointer to an array of naluSliceSegmentEntryCount valid VkVideoEncodeH265NaluSliceSegmentInfoEXT structures" }, { - "vuid": "VUID-VkVideoEncodeH265VclFrameInfoEXT-pStdPictureInfo-parameter", + "vuid": "VUID-VkVideoEncodeH265PictureInfoEXT-pStdPictureInfo-parameter", "text": " pStdPictureInfo must be a valid pointer to a valid StdVideoEncodeH265PictureInfo value" }, { - "vuid": "VUID-VkVideoEncodeH265VclFrameInfoEXT-naluSliceSegmentEntryCount-arraylength", + "vuid": "VUID-VkVideoEncodeH265PictureInfoEXT-naluSliceSegmentEntryCount-arraylength", "text": " naluSliceSegmentEntryCount must be greater than 0" } ] @@ -81888,10 +82174,6 @@ "vuid": "VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-pNext-pNext", "text": " pNext must be NULL" }, - { - "vuid": "VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-pStdReferenceFinalLists-parameter", - "text": " If pStdReferenceFinalLists is not NULL, pStdReferenceFinalLists must be a valid pointer to a valid StdVideoEncodeH265ReferenceListsInfo value" - }, { "vuid": "VUID-VkVideoEncodeH265NaluSliceSegmentInfoEXT-pStdSliceSegmentHeader-parameter", "text": " pStdSliceSegmentHeader must be a valid pointer to a valid StdVideoEncodeH265SliceSegmentHeader value" @@ -81917,29 +82199,21 @@ "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT" }, { - "vuid": "VUID-VkVideoEncodeH265RateControlInfoEXT-rateControlStructure-parameter", - "text": " rateControlStructure must be a valid VkVideoEncodeH265RateControlStructureEXT value" + "vuid": "VUID-VkVideoEncodeH265RateControlInfoEXT-flags-parameter", + "text": " flags must be a valid combination of VkVideoEncodeH265RateControlFlagBitsEXT values" + }, + { + "vuid": "VUID-VkVideoEncodeH265RateControlInfoEXT-flags-requiredbitmask", + "text": " flags must not be 0" } ] }, "VkVideoEncodeH265RateControlLayerInfoEXT": { "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ - { - "vuid": "VUID-VkVideoEncodeH265RateControlLayerInfoEXT-rateControlMode-06476", - "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, both useMinQp and useMaxQp must be set to VK_TRUE" - }, - { - "vuid": "VUID-VkVideoEncodeH265RateControlLayerInfoEXT-rateControlMode-06477", - "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, the values provided in minQP must be identical to those provided in maxQp" - }, { "vuid": "VUID-VkVideoEncodeH265RateControlLayerInfoEXT-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT" }, - { - "vuid": "VUID-VkVideoEncodeH265RateControlLayerInfoEXT-initialRcQp-parameter", - "text": " initialRcQp must be a valid VkVideoEncodeH265QpEXT structure" - }, { "vuid": "VUID-VkVideoEncodeH265RateControlLayerInfoEXT-minQp-parameter", "text": " minQp must be a valid VkVideoEncodeH265QpEXT structure" @@ -81954,6 +82228,14 @@ } ] }, + "VkVideoEncodeH265GopRemainingFrameInfoEXT": { + "(VK_KHR_video_queue)+(VK_EXT_video_encode_h265)": [ + { + "vuid": "VUID-VkVideoEncodeH265GopRemainingFrameInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT" + } + ] + }, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV": { "(VK_NV_optical_flow)": [ { diff --git a/registry/video.xml b/registry/video.xml index c6a56e1..52c3f9b 100644 --- a/registry/video.xml +++ b/registry/video.xml @@ -33,7 +33,7 @@ The current public version of video.xml is maintained in the default branch // Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_9 VK_MAKE_VIDEO_STD_VERSION(0, 9, 9) +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10) @@ -41,7 +41,7 @@ The current public version of video.xml is maintained in the default branch // Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10) +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_11 VK_MAKE_VIDEO_STD_VERSION(0, 9, 11) @@ -225,7 +225,7 @@ The current public version of video.xml is maintained in the default branch uint32_t top_field_flag : 1Reference is used for top field reference. uint32_t bottom_field_flag : 1Reference is used for bottom field reference. - uint32_t used_for_long_term_reference : 1: A picture that is marked as "used for long-term reference", derived binary value from clause 8.2.5.1 Sequence of operations for decoded reference picture marking process + uint32_t used_for_long_term_reference : 1A picture that is marked as "used for long-term reference", derived binary value from clause 8.2.5.1 Sequence of operations for decoded reference picture marking process uint32_t is_non_existing : 1Must be handled in accordance with 8.2.5.2: Decoding process for gaps in frame_num @@ -267,21 +267,24 @@ The current public version of video.xml is maintained in the default branch uint32_t direct_spatial_mv_pred_flag : 1 uint32_t num_ref_idx_active_override_flag : 1 - uint32_t no_output_of_prior_pics_flag : 1 - uint32_t adaptive_ref_pic_marking_mode_flag : 1 - uint32_t no_prior_references_available_flag : 1 + uint32_t reserved : 30 - uint32_t idr_flag : 1 - uint32_t is_reference_flag : 1 - uint32_t used_for_long_term_reference : 1: A picture that is marked as "used for long-term reference", derived binary value from clause 8.2.5.1 Sequence of operations for decoded reference picture marking process + uint32_t IdrPicFlag : 1 + uint32_t is_reference : 1A reference picture, i.e. a picture with nal_ref_idc not equal to 0, as defined in clause 3.136 + uint32_t no_output_of_prior_pics_flag : 1 + uint32_t long_term_reference_flag : 1 + uint32_t adaptive_ref_pic_marking_mode_flag : 1 + uint32_t reserved : 27 - uint32_t used_for_long_term_reference : 1: A picture that is marked as "used for long-term reference", derived binary value from clause 8.2.5.1 Sequence of operations for decoded reference picture marking process + uint32_t used_for_long_term_reference : 1A picture that is marked as "used for long-term reference", derived binary value from clause 8.2.5.1 Sequence of operations for decoded reference picture marking process + uint32_t reserved : 31 uint32_t ref_pic_list_modification_flag_l0 : 1 uint32_t ref_pic_list_modification_flag_l1 : 1 + uint32_t reserved : 30 StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc @@ -297,14 +300,14 @@ The current public version of video.xml is maintained in the default branch StdVideoEncodeH264ReferenceListsInfoFlags flags - uint8_t refPicList0EntryCountnum_ref_idx_l0_active_minus1 plus one - uint8_t refPicList1EntryCountnum_ref_idx_l1_active_minus1 plus one + uint8_t num_ref_idx_l0_active_minus1 + uint8_t num_ref_idx_l1_active_minus1 + uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF]slotIndex as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex + uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF]slotIndex as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex uint8_t refList0ModOpCount uint8_t refList1ModOpCount uint8_t refPicMarkingOpCount uint8_t reserved1[7]Reserved for future use and must be initialized with 0. - const uint8_t* pRefPicList0EntriesMust be a valid pointer to an array with size refPicList0EntryCount and contains the slotIndex values corresponding to the RefPicList0 as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex. - const uint8_t* pRefPicList1EntriesMust be a valid pointer to an array with size refPicList1EntryCount and contains the slotIndex values corresponding to the RefPicList1 as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex. const StdVideoEncodeH264RefListModEntry* pRefList0ModOperationsMust be a valid pointer to an array with size refList0ModOpCount if ref_pic_list_modification_flag_l0 is set and contains the RefList0 modification parameters as defined in section 7.4.3.1 const StdVideoEncodeH264RefListModEntry* pRefList1ModOperationsMust be a valid pointer to an array with size refList1ModOpCount if ref_pic_list_modification_flag_l1 is set and contains the RefList1 modification parameters as defined in section 7.4.3.1 const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperationsMust be a valid pointer to an array with size refPicMarkingOpCount and contains the reference picture markings as defined in section 7.4.3.3 @@ -313,32 +316,32 @@ The current public version of video.xml is maintained in the default branch StdVideoEncodeH264PictureInfoFlags flags uint8_t seq_parameter_set_idSelecting SPS id from the Sequence Parameters Set uint8_t pic_parameter_set_idSelecting PPS from the Picture Parameters for all StdVideoEncodeH264SliceHeader(s) - uint16_t reserved1Reserved for future use and must be initialized with 0. - StdVideoH264PictureType pictureType + uint16_t idr_pic_id + StdVideoH264PictureType primary_pic_type uint32_t frame_num - int32_t PicOrderCnt + int32_t PicOrderCntPicture order count, as defined in 8.2 + uint8_t temporal_idTemporal identifier of the picture, as defined in G.7.3.1.1 / G.7.4.1.1 + uint8_t reserved1[3]Reserved for future use and must be initialized with 0. + const StdVideoEncodeH264ReferenceListsInfo* pRefLists StdVideoEncodeH264ReferenceInfoFlags flags - StdVideoH264PictureType pictureType - uint32_t FrameNum - int32_t PicOrderCnt + StdVideoH264PictureType primary_pic_type + uint32_t FrameNumFrame number, as defined in 8.2 + int32_t PicOrderCntPicture order count, as defined in 8.2 uint16_t long_term_pic_num uint16_t long_term_frame_idx + uint8_t temporal_idTemporal identifier of the picture, as defined in G.7.3.1.1 / G.7.4.1.1 StdVideoEncodeH264SliceHeaderFlags flags uint32_t first_mb_in_slice StdVideoH264SliceType slice_type - uint16_t idr_pic_id - uint8_t num_ref_idx_l0_active_minus1 - uint8_t num_ref_idx_l1_active_minus1 - StdVideoH264CabacInitIdc cabac_init_idc - StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc int8_t slice_alpha_c0_offset_div2 int8_t slice_beta_offset_div2 uint16_t reserved1Reserved for future use and must be initialized with 0. - uint32_t reserved2Reserved for future use and must be initialized with 0. + StdVideoH264CabacInitIdc cabac_init_idc + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc const StdVideoEncodeH264WeightTable* pWeightTable @@ -740,11 +743,7 @@ The current public version of video.xml is maintained in the default branch uint32_t first_slice_segment_in_pic_flag : 1 - uint32_t no_output_of_prior_pics_flag : 1 uint32_t dependent_slice_segment_flag : 1 - uint32_t pic_output_flag : 1 - uint32_t short_term_ref_pic_set_sps_flag : 1 - uint32_t slice_temporal_mvp_enable_flag : 1 uint32_t slice_sao_luma_flag : 1 uint32_t slice_sao_chroma_flag : 1 uint32_t num_ref_idx_active_override_flag : 1 @@ -755,15 +754,13 @@ The current public version of video.xml is maintained in the default branch uint32_t slice_deblocking_filter_disabled_flag : 1 uint32_t collocated_from_l0_flag : 1 uint32_t slice_loop_filter_across_slices_enabled_flag : 1 + uint32_t reserved : 20 StdVideoEncodeH265SliceSegmentHeaderFlags flags StdVideoH265SliceType slice_type uint32_t slice_segment_address - uint8_t short_term_ref_pic_set_idx uint8_t collocated_ref_idx - uint8_t num_ref_idx_l0_active_minus1[0, 14] - uint8_t num_ref_idx_l1_active_minus1[0, 14] uint8_t MaxNumMergeCand int8_t slice_cb_qp_offset[-12, 12] int8_t slice_cr_qp_offset[-12, 12] @@ -772,50 +769,60 @@ The current public version of video.xml is maintained in the default branch int8_t slice_act_y_qp_offset int8_t slice_act_cb_qp_offset int8_t slice_act_cr_qp_offset - const StdVideoH265ShortTermRefPicSet*pShortTermRefPicSetMust be a valid pointer if short_term_ref_pic_set_sps_flag is not set - const StdVideoEncodeH265SliceSegmentLongTermRefPics*pLongTermRefPicsMust be a valid pointer if StdVideoH265SpsFlags:long_term_ref_pics_present_flag is set + uint8_t reserved1[3]Reserved for future use and must be initialized with 0. const StdVideoEncodeH265WeightTable* pWeightTable uint32_t ref_pic_list_modification_flag_l0 : 1 uint32_t ref_pic_list_modification_flag_l1 : 1 + uint32_t reserved : 30 StdVideoEncodeH265ReferenceListsInfoFlags flags uint8_t num_ref_idx_l0_active_minus1 uint8_t num_ref_idx_l1_active_minus1 - uint16_t reserved1Reserved for future use and must be initialized with 0. - const uint8_t* pRefPicList0EntriesMust be a valid pointer to an array with size num_ref_idx_l0_active_minus1 plus 1 and contains the slotIndex values corresponding to the RefPicList0 as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex. - const uint8_t* pRefPicList1EntriesMust be a valid pointer to an array with size num_ref_idx_l1_active_minus1 plus 1 and contains the slotIndex values corresponding to the RefPicList1 as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex. - const uint8_t* pRefList0ModificationsMust be a valid pointer to an array with size num_ref_idx_l0_active_minus1 plus 1 if ref_pic_list_modification_flag_l0 is set and contains the elements of list_entry_l0. - const uint8_t* pRefList1ModificationsMust be a valid pointer to an array with size num_ref_idx_l1_active_minus1 plus 1 if ref_pic_list_modification_flag_l1 is set and contains the elements of list_entry_l1. + uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF]slotIndex as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex + uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF]slotIndex as used in VkVideoReferenceSlotInfoKHR structures, 0xff for invalid slotIndex + uint8_t list_entry_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF] + uint8_t list_entry_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF] - uint32_t is_reference_flag : 1 - uint32_t IrapPicFlag : 1 - uint32_t long_term_flag : 1 + uint32_t is_reference : 1A reference picture, as defined in clause 3.132 + uint32_t IrapPicFlag : 1A reference picture, as defined in clause 3.73 + uint32_t used_for_long_term_reference : 1A picture that is marked as "used for long-term reference", derived binary value from clause 8.3.2 Decoding process for reference picture set uint32_t discardable_flag : 1 uint32_t cross_layer_bla_flag : 1 + uint32_t pic_output_flag : 1 + uint32_t no_output_of_prior_pics_flag : 1 + uint32_t short_term_ref_pic_set_sps_flag : 1 + uint32_t slice_temporal_mvp_enabled_flag : 1 + uint32_t reserved : 23 StdVideoEncodeH265PictureInfoFlags flags - StdVideoH265PictureType PictureType + StdVideoH265PictureType pic_type uint8_t sps_video_parameter_set_idSelecting VPS id from the Video Parameters Set uint8_t pps_seq_parameter_set_idSelecting SPS id from the Sequence Parameters Set uint8_t pps_pic_parameter_set_idSelecting PPS id from the Picture Parameters Set - uint8_t TemporalId - int32_t PicOrderCntVal + uint8_t short_term_ref_pic_set_idx + int32_t PicOrderCntValPicture order count derived as specified in 8.3.1 + uint8_t TemporalIdTemporal ID, as defined in 7.4.2.2 + uint8_t reserved1[7]Reserved for future use and must be initialized with 0. + const StdVideoEncodeH265ReferenceListsInfo* pRefLists + const StdVideoH265ShortTermRefPicSet*pShortTermRefPicSetMust be a valid pointer if short_term_ref_pic_set_sps_flag is not set + const StdVideoEncodeH265SliceSegmentLongTermRefPics*pLongTermRefPicsMust be a valid pointer if long_term_ref_pics_present_flag is set uint32_t used_for_long_term_reference : 1A picture that is marked as "used for long-term reference", derived binary value from clause 8.3.2 Decoding process for reference picture set uint32_t unused_for_reference : 1A picture that is marked as "unused for reference", derived binary value from clause 8.3.2 Decoding process for reference picture set + uint32_t reserved : 30 StdVideoEncodeH265ReferenceInfoFlags flags - StdVideoH265PictureType PictureType - int32_t PicOrderCntVal - uint8_t TemporalId + StdVideoH265PictureType pic_type + int32_t PicOrderCntValPicture order count derived as specified in 8.3.1 + uint8_t TemporalIdTemporal ID, as defined in 7.4.2.2 @@ -1087,8 +1094,8 @@ The current public version of video.xml is maintained in the default branch - - + + @@ -1174,8 +1181,8 @@ The current public version of video.xml is maintained in the default branch - - + + diff --git a/registry/vk.xml b/registry/vk.xml index f5300a3..8f7f55d 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -38,7 +38,7 @@ branch of the member gitlab server. - + @@ -174,7 +174,7 @@ branch of the member gitlab server. #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 252 +#define VK_HEADER_VERSION 253 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) // Version of this file @@ -338,6 +338,7 @@ typedef void* MTLSharedEvent_id; typedef VkFlags VkCommandBufferUsageFlags; typedef VkFlags VkQueryPipelineStatisticFlags; typedef VkFlags VkMemoryMapFlags; + typedef VkFlags VkMemoryUnmapFlagsKHR; typedef VkFlags VkImageAspectFlags; typedef VkFlags VkSparseMemoryBindFlags; typedef VkFlags VkSparseImageFormatFlags; @@ -506,13 +507,16 @@ typedef void* MTLSharedEvent_id; typedef VkFlags VkVideoComponentBitDepthFlagsKHR; Video Encode H.264 extension - typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; + typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; + typedef VkFlags VkVideoEncodeH264StdFlagsEXT; + typedef VkFlags VkVideoEncodeH264RateControlFlagsEXT; Video Encode H.265 extension - typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; - typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; - typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; - typedef VkFlags VkMemoryUnmapFlagsKHR; + typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; + typedef VkFlags VkVideoEncodeH265StdFlagsEXT; + typedef VkFlags VkVideoEncodeH265RateControlFlagsEXT; + typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; + typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; Types which can be void pointers or class pointers, selected at compile time VK_DEFINE_HANDLE(VkInstance) @@ -882,14 +886,16 @@ typedef void* MTLSharedEvent_id; Video H.264 Encode extensions - - + + + Video H.265 Encode extensions - - - - + + + + + The PFN_vk*Function types are used by VkAllocationCallbacks below typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( @@ -6663,6 +6669,16 @@ typedef void* MTLSharedEvent_id; const void* pNext uint32_t updateSequenceCount + + VkStructureType sType + const void* pNext + VkVideoSessionParametersKHR videoSessionParameters + + + VkStructureType sType + void* pNext + VkBool32 hasOverrides + VkStructureType sType const void* pNext @@ -6693,7 +6709,6 @@ typedef void* MTLSharedEvent_id; VkStructureType sType const void* pNext VkVideoEncodeFlagsKHR flags - uint32_t qualityLevel VkBuffer dstBuffer VkDeviceSize dstBufferOffset VkDeviceSize dstBufferRange @@ -6708,23 +6723,40 @@ typedef void* MTLSharedEvent_id; const void* pNext VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags - + + VkStructureType sType + const void* pNext + uint32_t qualityLevel + + + VkStructureType sType + const void* pNext + const VkVideoProfileInfoKHR* pVideoProfile + uint32_t qualityLevel + + + VkStructureType sType + void* pNext + VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode + uint32_t preferredRateControlLayerCount + + VkStructureType sType - const void* pNext + const void* pNext VkVideoEncodeRateControlFlagsKHR flags - VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode - uint32_t layerCount + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode + uint32_t layerCount const VkVideoEncodeRateControlLayerInfoKHR* pLayers + uint32_t virtualBufferSizeInMs + uint32_t initialVirtualBufferSizeInMs - + VkStructureType sType - const void* pNext - uint64_t averageBitrate - uint64_t maxBitrate - uint32_t frameRateNumerator - uint32_t frameRateDenominator - uint32_t virtualBufferSizeInMs - uint32_t initialVirtualBufferSizeInMs + const void* pNext + uint64_t averageBitrate + uint64_t maxBitrate + uint32_t frameRateNumerator + uint32_t frameRateDenominator VkStructureType sType @@ -6732,22 +6764,40 @@ typedef void* MTLSharedEvent_id; VkVideoEncodeCapabilityFlagsKHR flags VkVideoEncodeRateControlModeFlagsKHR rateControlModes uint32_t maxRateControlLayers + uint64_t maxBitrate uint32_t maxQualityLevels - VkExtent2D inputImageDataFillAlignment + VkExtent2D encodeInputPictureGranularity VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags VkStructureType sType void* pNext - VkVideoEncodeH264CapabilityFlagsEXT flags + VkVideoEncodeH264CapabilityFlagsEXT flags + StdVideoH264LevelIdc maxLevelIdc + uint32_t maxSliceCount uint32_t maxPPictureL0ReferenceCount uint32_t maxBPictureL0ReferenceCount uint32_t maxL1ReferenceCount - VkBool32 motionVectorsOverPicBoundariesFlag - uint32_t maxBytesPerPicDenom - uint32_t maxBitsPerMbDenom - uint32_t log2MaxMvLengthHorizontal - uint32_t log2MaxMvLengthVertical + uint32_t maxTemporalLayerCount + VkBool32 expectDyadicTemporalLayerPattern + int32_t minQp + int32_t maxQp + VkBool32 prefersGopRemainingFrames + VkBool32 requiresGopRemainingFrames + VkVideoEncodeH264StdFlagsEXT stdSyntaxFlags + + + VkStructureType sType + void* pNext + VkVideoEncodeH264RateControlFlagsEXT preferredRateControlFlags + uint32_t preferredGopFrameCount + uint32_t preferredIdrPeriod + uint32_t preferredConsecutiveBFrameCount + uint32_t preferredTemporalLayerCount + VkVideoEncodeH264QpEXT preferredConstantQp + uint32_t preferredMaxL0ReferenceCount + uint32_t preferredMaxL1ReferenceCount + VkBool32 preferredStdEntropyCodingModeFlag #include "vk_video/vulkan_video_codec_h264std_encode.h" @@ -6760,6 +6810,12 @@ typedef void* MTLSharedEvent_id; + + VkStructureType sType + const void* pNext + VkBool32 useMaxLevelIdc + StdVideoH264LevelIdc maxLevelIdc + VkStructureType sType const void* pNext @@ -6775,18 +6831,32 @@ typedef void* MTLSharedEvent_id; uint32_t maxStdPPSCount const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo + + VkStructureType sType + const void* pNext + VkBool32 writeStdSPS + VkBool32 writeStdPPS + uint32_t stdSPSId + uint32_t stdPPSId + + + VkStructureType sType + void* pNext + VkBool32 hasStdSPSOverrides + VkBool32 hasStdPPSOverrides + VkStructureType sType const void* pNext const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo - - VkStructureType sType + + VkStructureType sType const void* pNext - const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists uint32_t naluSliceEntryCount const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries const StdVideoEncodeH264PictureInfo* pStdPictureInfo + VkBool32 generatePrefixNalu VkStructureType sType @@ -6796,17 +6866,16 @@ typedef void* MTLSharedEvent_id; VkStructureType sType const void* pNext - uint32_t mbCount - const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists + int32_t constantQp const StdVideoEncodeH264SliceHeader* pStdSliceHeader - + VkStructureType sType const void* pNext + VkVideoEncodeH264RateControlFlagsEXT flags uint32_t gopFrameCount uint32_t idrPeriod uint32_t consecutiveBFrameCount - VkVideoEncodeH264RateControlStructureEXT rateControlStructure uint32_t temporalLayerCount @@ -6819,12 +6888,17 @@ typedef void* MTLSharedEvent_id; uint32_t framePSize uint32_t frameBSize - + + VkStructureType sType + const void* pNext + VkBool32 useGopRemainingFrames + uint32_t gopRemainingI + uint32_t gopRemainingP + uint32_t gopRemainingB + + VkStructureType sType const void* pNext - uint32_t temporalLayerId - VkBool32 useInitialRcQp - VkVideoEncodeH264QpEXT initialRcQp VkBool32 useMinQp VkVideoEncodeH264QpEXT minQp VkBool32 useMaxQp @@ -6835,24 +6909,34 @@ typedef void* MTLSharedEvent_id; VkStructureType sType void* pNext - VkVideoEncodeH265CapabilityFlagsEXT flags + VkVideoEncodeH265CapabilityFlagsEXT flags + StdVideoH265LevelIdc maxLevelIdc + uint32_t maxSliceSegmentCount + VkExtent2D maxTiles VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes uint32_t maxPPictureL0ReferenceCount uint32_t maxBPictureL0ReferenceCount uint32_t maxL1ReferenceCount - uint32_t maxSubLayersCount - uint32_t minLog2MinLumaCodingBlockSizeMinus3 - uint32_t maxLog2MinLumaCodingBlockSizeMinus3 - uint32_t minLog2MinLumaTransformBlockSizeMinus2 - uint32_t maxLog2MinLumaTransformBlockSizeMinus2 - uint32_t minMaxTransformHierarchyDepthInter - uint32_t maxMaxTransformHierarchyDepthInter - uint32_t minMaxTransformHierarchyDepthIntra - uint32_t maxMaxTransformHierarchyDepthIntra - uint32_t maxDiffCuQpDeltaDepth - uint32_t minMaxNumMergeCand - uint32_t maxMaxNumMergeCand + uint32_t maxSubLayerCount + VkBool32 expectDyadicTemporalSubLayerPattern + int32_t minQp + int32_t maxQp + VkBool32 prefersGopRemainingFrames + VkBool32 requiresGopRemainingFrames + VkVideoEncodeH265StdFlagsEXT stdSyntaxFlags + + + VkStructureType sType + void* pNext + VkVideoEncodeH265RateControlFlagsEXT preferredRateControlFlags + uint32_t preferredGopFrameCount + uint32_t preferredIdrPeriod + uint32_t preferredConsecutiveBFrameCount + uint32_t preferredSubLayerCount + VkVideoEncodeH265QpEXT preferredConstantQp + uint32_t preferredMaxL0ReferenceCount + uint32_t preferredMaxL1ReferenceCount #include "vk_video/vulkan_video_codec_h265std_encode.h" @@ -6863,6 +6947,12 @@ typedef void* MTLSharedEvent_id; + + VkStructureType sType + const void* pNext + VkBool32 useMaxLevelIdc + StdVideoH265LevelIdc maxLevelIdc + VkStructureType sType const void* pNext @@ -6881,10 +6971,26 @@ typedef void* MTLSharedEvent_id; uint32_t maxStdPPSCount const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo - - VkStructureType sType + + VkStructureType sType + const void* pNext + VkBool32 writeStdVPS + VkBool32 writeStdSPS + VkBool32 writeStdPPS + uint32_t stdVPSId + uint32_t stdSPSId + uint32_t stdPPSId + + + VkStructureType sType + void* pNext + VkBool32 hasStdVPSOverrides + VkBool32 hasStdSPSOverrides + VkBool32 hasStdPPSOverrides + + + VkStructureType sType const void* pNext - const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists uint32_t naluSliceSegmentEntryCount const VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries const StdVideoEncodeH265PictureInfo* pStdPictureInfo @@ -6892,17 +6998,16 @@ typedef void* MTLSharedEvent_id; VkStructureType sType const void* pNext - uint32_t ctbCount - const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists + int32_t constantQp const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader - + VkStructureType sType const void* pNext + VkVideoEncodeH265RateControlFlagsEXT flags uint32_t gopFrameCount uint32_t idrPeriod uint32_t consecutiveBFrameCount - VkVideoEncodeH265RateControlStructureEXT rateControlStructure uint32_t subLayerCount @@ -6915,12 +7020,17 @@ typedef void* MTLSharedEvent_id; uint32_t framePSize uint32_t frameBSize - + + VkStructureType sType + const void* pNext + VkBool32 useGopRemainingFrames + uint32_t gopRemainingI + uint32_t gopRemainingP + uint32_t gopRemainingB + + VkStructureType sType const void* pNext - uint32_t temporalId - VkBool32 useInitialRcQp - VkVideoEncodeH265QpEXT initialRcQp VkBool32 useMinQp VkVideoEncodeH265QpEXT minQp VkBool32 useMaxQp @@ -9923,6 +10033,7 @@ typedef void* MTLSharedEvent_id; + @@ -9931,37 +10042,42 @@ typedef void* MTLSharedEvent_id; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -10037,38 +10153,44 @@ typedef void* MTLSharedEvent_id; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -13623,6 +13745,12 @@ typedef void* MTLSharedEvent_id; uint32_t* pVideoFormatPropertyCount VkVideoFormatPropertiesKHR* pVideoFormatProperties + + VkResult vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties + VkResult vkCreateVideoSessionKHR VkDevice device @@ -13649,6 +13777,14 @@ typedef void* MTLSharedEvent_id; VkVideoSessionParametersKHR videoSessionParameters const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo + + VkResult vkGetEncodedVideoSessionParametersKHR + VkDevice device + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo + size_t* pDataSize + void* pData + void vkDestroyVideoSessionParametersKHR VkDevice device @@ -16123,69 +16259,94 @@ typedef void* MTLSharedEvent_id; - + - + + + + + + + + + + - + + + - + + + - + - + + + + + + - + + + + - + + + - + + + @@ -19639,7 +19800,7 @@ typedef void* MTLSharedEvent_id; - + @@ -19651,9 +19812,14 @@ typedef void* MTLSharedEvent_id; + + + + + - + @@ -19661,6 +19827,7 @@ typedef void* MTLSharedEvent_id; + @@ -19692,6 +19859,15 @@ typedef void* MTLSharedEvent_id; + + + + + + + + + @@ -22208,6 +22384,30 @@ typedef void* MTLSharedEvent_id; + + + + + + + + + + + + + + + + + + + + + + + + @@ -24293,4 +24493,339 @@ typedef void* MTLSharedEvent_id; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Fragment shader stage is added by the VK_EXT_shader_tile_image extension + + + + + + + Fragment shader stage is added by the VK_EXT_shader_tile_image extension + + + + + + + + + + + + + + + + + + + TODO/Suggestion. Introduce 'synclist' (could be a different name) element + that specifies the list of stages, accesses, etc. This list can be used by + 'syncaccess' or 'syncstage' elements. For example, 'syncsupport' in addition to the + 'stage' attribute can support 'list' attribute to reference 'synclist'. + We can have the lists defined for ALL stages and it can be shared between MEMORY_READ + and MEMORY_WRITE accesses. Similarly, ALL shader stages list is often used. This proposal + is a way to fix duplication problem. When new stage is added multiple places needs to be + updated. It is potential source of bugs. The expectation such setup will produce more + robust system and also more simple structure to review and validate. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT + VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT + VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT + VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT + VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT + VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT + VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT + VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT + VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR + VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT + VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT + VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT + VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT + VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT + VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT + + + VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT + VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT + VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT + VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR + VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT + VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT + VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT + VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT + VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT + VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT + + + VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT + VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT + VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT + + + VK_PIPELINE_STAGE_2_TRANSFER_BIT + + + VK_PIPELINE_STAGE_2_HOST_BIT + + + VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI + + + VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV + + + VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR + + + VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR + + + VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT + + + VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT + VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR + + + VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR + + + VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR + + + VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV + + -- cgit v1.2.3