Updated vulkan headers.

3rdparty/khronos/vulkan-local/vulkan.h

@@ -38,7 +38,6 @@
 
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-#include <wayland-client.h>
 #include "vulkan_wayland.h"
 #endif
 

3rdparty/khronos/vulkan-local/vulkan_beta.h

@@ -22,7 +22,7 @@ extern "C" {
 #define VK_KHR_video_queue 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR)
-#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION   4
+#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION   7
 #define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue"
 
 typedef enum VkQueryResultStatusKHR {
@@ -33,7 +33,7 @@ typedef enum VkQueryResultStatusKHR {
 } VkQueryResultStatusKHR;
 
 typedef enum VkVideoCodecOperationFlagBitsKHR {
-    VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0,
+    VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0,
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000,
 #endif
@@ -51,7 +51,7 @@ typedef enum VkVideoCodecOperationFlagBitsKHR {
 typedef VkFlags VkVideoCodecOperationFlagsKHR;
 
 typedef enum VkVideoChromaSubsamplingFlagBitsKHR {
-    VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = 0,
+    VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0,
     VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001,
     VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002,
     VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004,
@@ -77,73 +77,70 @@ typedef enum VkVideoCapabilityFlagBitsKHR {
 typedef VkFlags VkVideoCapabilityFlagsKHR;
 
 typedef enum VkVideoSessionCreateFlagBitsKHR {
-    VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0,
     VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
     VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoSessionCreateFlagBitsKHR;
 typedef VkFlags VkVideoSessionCreateFlagsKHR;
+typedef VkFlags VkVideoSessionParametersCreateFlagsKHR;
 typedef VkFlags VkVideoBeginCodingFlagsKHR;
 typedef VkFlags VkVideoEndCodingFlagsKHR;
 
 typedef enum VkVideoCodingControlFlagBitsKHR {
-    VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = 0,
     VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001,
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    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,
+#endif
     VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoCodingControlFlagBitsKHR;
 typedef VkFlags VkVideoCodingControlFlagsKHR;
-
-typedef enum VkVideoCodingQualityPresetFlagBitsKHR {
-    VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = 0x00000001,
-    VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = 0x00000002,
-    VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x00000004,
-    VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoCodingQualityPresetFlagBitsKHR;
-typedef VkFlags VkVideoCodingQualityPresetFlagsKHR;
-typedef struct VkQueueFamilyQueryResultStatusProperties2KHR {
+typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR {
     VkStructureType    sType;
     void*              pNext;
     VkBool32           queryResultStatusSupport;
-} VkQueueFamilyQueryResultStatusProperties2KHR;
+} VkQueueFamilyQueryResultStatusPropertiesKHR;
 
-typedef struct VkVideoQueueFamilyProperties2KHR {
+typedef struct VkQueueFamilyVideoPropertiesKHR {
     VkStructureType                  sType;
     void*                            pNext;
     VkVideoCodecOperationFlagsKHR    videoCodecOperations;
-} VkVideoQueueFamilyProperties2KHR;
+} VkQueueFamilyVideoPropertiesKHR;
 
-typedef struct VkVideoProfileKHR {
+typedef struct VkVideoProfileInfoKHR {
     VkStructureType                     sType;
     const void*                         pNext;
     VkVideoCodecOperationFlagBitsKHR    videoCodecOperation;
     VkVideoChromaSubsamplingFlagsKHR    chromaSubsampling;
     VkVideoComponentBitDepthFlagsKHR    lumaBitDepth;
     VkVideoComponentBitDepthFlagsKHR    chromaBitDepth;
-} VkVideoProfileKHR;
+} VkVideoProfileInfoKHR;
 
-typedef struct VkVideoProfilesKHR {
-    VkStructureType             sType;
-    const void*                 pNext;
-    uint32_t                    profileCount;
-    const VkVideoProfileKHR*    pProfiles;
-} VkVideoProfilesKHR;
+typedef struct VkVideoProfileListInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    uint32_t                        profileCount;
+    const VkVideoProfileInfoKHR*    pProfiles;
+} VkVideoProfileListInfoKHR;
 
 typedef struct VkVideoCapabilitiesKHR {
     VkStructureType              sType;
     void*                        pNext;
-    VkVideoCapabilityFlagsKHR    capabilityFlags;
+    VkVideoCapabilityFlagsKHR    flags;
     VkDeviceSize                 minBitstreamBufferOffsetAlignment;
     VkDeviceSize                 minBitstreamBufferSizeAlignment;
-    VkExtent2D                   videoPictureExtentGranularity;
-    VkExtent2D                   minExtent;
-    VkExtent2D                   maxExtent;
-    uint32_t                     maxReferencePicturesSlotsCount;
-    uint32_t                     maxReferencePicturesActiveCount;
+    VkExtent2D                   pictureAccessGranularity;
+    VkExtent2D                   minCodedExtent;
+    VkExtent2D                   maxCodedExtent;
+    uint32_t                     maxDpbSlots;
+    uint32_t                     maxActiveReferencePictures;
     VkExtensionProperties        stdHeaderVersion;
 } VkVideoCapabilitiesKHR;
 
 typedef struct VkPhysicalDeviceVideoFormatInfoKHR {
      VkStructureType     sType;
-    void*                pNext;
+    const void*          pNext;
     VkImageUsageFlags    imageUsage;
 } VkPhysicalDeviceVideoFormatInfoKHR;
 
@@ -158,57 +155,58 @@ typedef struct VkVideoFormatPropertiesKHR {
     VkImageUsageFlags     imageUsageFlags;
 } VkVideoFormatPropertiesKHR;
 
-typedef struct VkVideoPictureResourceKHR {
+typedef struct VkVideoPictureResourceInfoKHR {
     VkStructureType    sType;
     const void*        pNext;
     VkOffset2D         codedOffset;
     VkExtent2D         codedExtent;
     uint32_t           baseArrayLayer;
     VkImageView        imageViewBinding;
-} VkVideoPictureResourceKHR;
-
-typedef struct VkVideoReferenceSlotKHR {
-    VkStructureType                     sType;
-    const void*                         pNext;
-    int8_t                              slotIndex;
-    const VkVideoPictureResourceKHR*    pPictureResource;
-} VkVideoReferenceSlotKHR;
-
-typedef struct VkVideoGetMemoryPropertiesKHR {
-    VkStructureType           sType;
-    const void*               pNext;
-    uint32_t                  memoryBindIndex;
-    VkMemoryRequirements2*    pMemoryRequirements;
-} VkVideoGetMemoryPropertiesKHR;
+} VkVideoPictureResourceInfoKHR;
 
-typedef struct VkVideoBindMemoryKHR {
+typedef struct VkVideoReferenceSlotInfoKHR {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    int32_t                                 slotIndex;
+    const VkVideoPictureResourceInfoKHR*    pPictureResource;
+} VkVideoReferenceSlotInfoKHR;
+
+typedef struct VkVideoSessionMemoryRequirementsKHR {
+    VkStructureType         sType;
+    void*                   pNext;
+    uint32_t                memoryBindIndex;
+    VkMemoryRequirements    memoryRequirements;
+} VkVideoSessionMemoryRequirementsKHR;
+
+typedef struct VkBindVideoSessionMemoryInfoKHR {
     VkStructureType    sType;
     const void*        pNext;
     uint32_t           memoryBindIndex;
     VkDeviceMemory     memory;
     VkDeviceSize       memoryOffset;
     VkDeviceSize       memorySize;
-} VkVideoBindMemoryKHR;
+} VkBindVideoSessionMemoryInfoKHR;
 
 typedef struct VkVideoSessionCreateInfoKHR {
     VkStructureType                 sType;
     const void*                     pNext;
     uint32_t                        queueFamilyIndex;
     VkVideoSessionCreateFlagsKHR    flags;
-    const VkVideoProfileKHR*        pVideoProfile;
+    const VkVideoProfileInfoKHR*    pVideoProfile;
     VkFormat                        pictureFormat;
     VkExtent2D                      maxCodedExtent;
-    VkFormat                        referencePicturesFormat;
-    uint32_t                        maxReferencePicturesSlotsCount;
-    uint32_t                        maxReferencePicturesActiveCount;
+    VkFormat                        referencePictureFormat;
+    uint32_t                        maxDpbSlots;
+    uint32_t                        maxActiveReferencePictures;
     const VkExtensionProperties*    pStdHeaderVersion;
 } VkVideoSessionCreateInfoKHR;
 
 typedef struct VkVideoSessionParametersCreateInfoKHR {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkVideoSessionParametersKHR    videoSessionParametersTemplate;
-    VkVideoSessionKHR              videoSession;
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkVideoSessionParametersCreateFlagsKHR    flags;
+    VkVideoSessionParametersKHR               videoSessionParametersTemplate;
+    VkVideoSessionKHR                         videoSession;
 } VkVideoSessionParametersCreateInfoKHR;
 
 typedef struct VkVideoSessionParametersUpdateInfoKHR {
@@ -221,11 +219,10 @@ typedef struct VkVideoBeginCodingInfoKHR {
     VkStructureType                       sType;
     const void*                           pNext;
     VkVideoBeginCodingFlagsKHR            flags;
-    VkVideoCodingQualityPresetFlagsKHR    codecQualityPreset;
     VkVideoSessionKHR                     videoSession;
     VkVideoSessionParametersKHR           videoSessionParameters;
     uint32_t                              referenceSlotCount;
-    const VkVideoReferenceSlotKHR*        pReferenceSlots;
+    const VkVideoReferenceSlotInfoKHR*    pReferenceSlots;
 } VkVideoBeginCodingInfoKHR;
 
 typedef struct VkVideoEndCodingInfoKHR {
@@ -240,12 +237,12 @@ typedef struct VkVideoCodingControlInfoKHR {
     VkVideoCodingControlFlagsKHR    flags;
 } VkVideoCodingControlInfoKHR;
 
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities);
 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession);
 typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);
-typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories);
+typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements);
+typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters);
 typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
 typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator);
@@ -256,7 +253,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer command
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(
     VkPhysicalDevice                            physicalDevice,
-    const VkVideoProfileKHR*                    pVideoProfile,
+    const VkVideoProfileInfoKHR*                pVideoProfile,
     VkVideoCapabilitiesKHR*                     pCapabilities);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(
@@ -279,14 +276,14 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(
 VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(
     VkDevice                                    device,
     VkVideoSessionKHR                           videoSession,
-    uint32_t*                                   pVideoSessionMemoryRequirementsCount,
-    VkVideoGetMemoryPropertiesKHR*              pVideoSessionMemoryRequirements);
+    uint32_t*                                   pMemoryRequirementsCount,
+    VkVideoSessionMemoryRequirementsKHR*        pMemoryRequirements);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(
     VkDevice                                    device,
     VkVideoSessionKHR                           videoSession,
-    uint32_t                                    videoSessionBindMemoryCount,
-    const VkVideoBindMemoryKHR*                 pVideoSessionBindMemories);
+    uint32_t                                    bindSessionMemoryInfoCount,
+    const VkBindVideoSessionMemoryInfoKHR*      pBindSessionMemoryInfos);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(
     VkDevice                                    device,
@@ -319,22 +316,24 @@ VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(
 
 
 #define VK_KHR_video_decode_queue 1
-#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 4
+#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 6
 #define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue"
 
 typedef enum VkVideoDecodeCapabilityFlagBitsKHR {
-    VK_VIDEO_DECODE_CAPABILITY_DEFAULT_KHR = 0,
     VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001,
     VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002,
     VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoDecodeCapabilityFlagBitsKHR;
 typedef VkFlags VkVideoDecodeCapabilityFlagsKHR;
 
-typedef enum VkVideoDecodeFlagBitsKHR {
-    VK_VIDEO_DECODE_DEFAULT_KHR = 0,
-    VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = 0x00000001,
-    VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoDecodeFlagBitsKHR;
+typedef enum VkVideoDecodeUsageFlagBitsKHR {
+    VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0,
+    VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001,
+    VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002,
+    VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004,
+    VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoDecodeUsageFlagBitsKHR;
+typedef VkFlags VkVideoDecodeUsageFlagsKHR;
 typedef VkFlags VkVideoDecodeFlagsKHR;
 typedef struct VkVideoDecodeCapabilitiesKHR {
     VkStructureType                    sType;
@@ -342,25 +341,31 @@ typedef struct VkVideoDecodeCapabilitiesKHR {
     VkVideoDecodeCapabilityFlagsKHR    flags;
 } VkVideoDecodeCapabilitiesKHR;
 
+typedef struct VkVideoDecodeUsageInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkVideoDecodeUsageFlagsKHR    videoUsageHints;
+} VkVideoDecodeUsageInfoKHR;
+
 typedef struct VkVideoDecodeInfoKHR {
-    VkStructureType                   sType;
-    const void*                       pNext;
-    VkVideoDecodeFlagsKHR             flags;
-    VkBuffer                          srcBuffer;
-    VkDeviceSize                      srcBufferOffset;
-    VkDeviceSize                      srcBufferRange;
-    VkVideoPictureResourceKHR         dstPictureResource;
-    const VkVideoReferenceSlotKHR*    pSetupReferenceSlot;
-    uint32_t                          referenceSlotCount;
-    const VkVideoReferenceSlotKHR*    pReferenceSlots;
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkVideoDecodeFlagsKHR                 flags;
+    VkBuffer                              srcBuffer;
+    VkDeviceSize                          srcBufferOffset;
+    VkDeviceSize                          srcBufferRange;
+    VkVideoPictureResourceInfoKHR         dstPictureResource;
+    const VkVideoReferenceSlotInfoKHR*    pSetupReferenceSlot;
+    uint32_t                              referenceSlotCount;
+    const VkVideoReferenceSlotInfoKHR*    pReferenceSlots;
 } VkVideoDecodeInfoKHR;
 
-typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo);
 
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(
     VkCommandBuffer                             commandBuffer,
-    const VkVideoDecodeInfoKHR*                 pFrameInfo);
+    const VkVideoDecodeInfoKHR*                 pDecodeInfo);
 #endif
 
 
@@ -396,18 +401,20 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
 
 
 #define VK_KHR_video_encode_queue 1
-#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 5
+#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 7
 #define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
 
-typedef enum VkVideoEncodeFlagBitsKHR {
-    VK_VIDEO_ENCODE_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeFlagBitsKHR;
+typedef enum VkVideoEncodeTuningModeKHR {
+    VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1,
+    VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2,
+    VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3,
+    VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4,
+    VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeTuningModeKHR;
 typedef VkFlags VkVideoEncodeFlagsKHR;
 
 typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
-    VK_VIDEO_ENCODE_CAPABILITY_DEFAULT_KHR = 0,
     VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
     VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoEncodeCapabilityFlagBitsKHR;
@@ -421,25 +428,38 @@ typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
 } VkVideoEncodeRateControlModeFlagBitsKHR;
 typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
 
-typedef enum VkVideoEncodeRateControlFlagBitsKHR {
-    VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_RATE_CONTROL_RESERVED_0_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeRateControlFlagBitsKHR;
+typedef enum VkVideoEncodeUsageFlagBitsKHR {
+    VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeUsageFlagBitsKHR;
+typedef VkFlags VkVideoEncodeUsageFlagsKHR;
+
+typedef enum VkVideoEncodeContentFlagBitsKHR {
+    VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeContentFlagBitsKHR;
+typedef VkFlags VkVideoEncodeContentFlagsKHR;
 typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
 typedef struct VkVideoEncodeInfoKHR {
-    VkStructureType                   sType;
-    const void*                       pNext;
-    VkVideoEncodeFlagsKHR             flags;
-    uint32_t                          qualityLevel;
-    VkBuffer                          dstBitstreamBuffer;
-    VkDeviceSize                      dstBitstreamBufferOffset;
-    VkDeviceSize                      dstBitstreamBufferMaxRange;
-    VkVideoPictureResourceKHR         srcPictureResource;
-    const VkVideoReferenceSlotKHR*    pSetupReferenceSlot;
-    uint32_t                          referenceSlotCount;
-    const VkVideoReferenceSlotKHR*    pReferenceSlots;
-    uint32_t                          precedingExternallyEncodedBytes;
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkVideoEncodeFlagsKHR                 flags;
+    uint32_t                              qualityLevel;
+    VkBuffer                              dstBitstreamBuffer;
+    VkDeviceSize                          dstBitstreamBufferOffset;
+    VkDeviceSize                          dstBitstreamBufferMaxRange;
+    VkVideoPictureResourceInfoKHR         srcPictureResource;
+    const VkVideoReferenceSlotInfoKHR*    pSetupReferenceSlot;
+    uint32_t                              referenceSlotCount;
+    const VkVideoReferenceSlotInfoKHR*    pReferenceSlots;
+    uint32_t                              precedingExternallyEncodedBytes;
 } VkVideoEncodeInfoKHR;
 
 typedef struct VkVideoEncodeCapabilitiesKHR {
@@ -452,6 +472,14 @@ typedef struct VkVideoEncodeCapabilitiesKHR {
     VkExtent2D                              inputImageDataFillAlignment;
 } VkVideoEncodeCapabilitiesKHR;
 
+typedef struct VkVideoEncodeUsageInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkVideoEncodeUsageFlagsKHR      videoUsageHints;
+    VkVideoEncodeContentFlagsKHR    videoContentHints;
+    VkVideoEncodeTuningModeKHR      tuningMode;
+} VkVideoEncodeUsageInfoKHR;
+
 typedef struct VkVideoEncodeRateControlLayerInfoKHR {
     VkStructureType    sType;
     const void*        pNext;
@@ -484,9 +512,16 @@ 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 7
+#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 9
 #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,
@@ -532,14 +567,6 @@ typedef enum VkVideoEncodeH264OutputModeFlagBitsEXT {
     VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkVideoEncodeH264OutputModeFlagBitsEXT;
 typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT;
-
-typedef enum VkVideoEncodeH264RateControlStructureFlagBitsEXT {
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264RateControlStructureFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264RateControlStructureFlagsEXT;
 typedef struct VkVideoEncodeH264CapabilitiesEXT {
     VkStructureType                        sType;
     void*                                  pNext;
@@ -559,17 +586,17 @@ typedef struct VkVideoEncodeH264CapabilitiesEXT {
 typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {
     VkStructureType                            sType;
     const void*                                pNext;
-    uint32_t                                   spsStdCount;
-    const StdVideoH264SequenceParameterSet*    pSpsStd;
-    uint32_t                                   ppsStdCount;
-    const StdVideoH264PictureParameterSet*     pPpsStd;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH264SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH264PictureParameterSet*     pStdPPSs;
 } VkVideoEncodeH264SessionParametersAddInfoEXT;
 
 typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
     VkStructureType                                        sType;
     const void*                                            pNext;
-    uint32_t                                               maxSpsStdCount;
-    uint32_t                                               maxPpsStdCount;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
     const VkVideoEncodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;
 } VkVideoEncodeH264SessionParametersCreateInfoEXT;
 
@@ -580,7 +607,7 @@ typedef struct VkVideoEncodeH264DpbSlotInfoEXT {
     const StdVideoEncodeH264ReferenceInfo*    pStdReferenceInfo;
 } VkVideoEncodeH264DpbSlotInfoEXT;
 
-typedef struct VkVideoEncodeH264ReferenceListsEXT {
+typedef struct VkVideoEncodeH264ReferenceListsInfoEXT {
     VkStructureType                                      sType;
     const void*                                          pNext;
     uint8_t                                              referenceList0EntryCount;
@@ -588,48 +615,48 @@ typedef struct VkVideoEncodeH264ReferenceListsEXT {
     uint8_t                                              referenceList1EntryCount;
     const VkVideoEncodeH264DpbSlotInfoEXT*               pReferenceList1Entries;
     const StdVideoEncodeH264RefMemMgmtCtrlOperations*    pMemMgmtCtrlOperations;
-} VkVideoEncodeH264ReferenceListsEXT;
+} VkVideoEncodeH264ReferenceListsInfoEXT;
 
-typedef struct VkVideoEncodeH264NaluSliceEXT {
-    VkStructureType                              sType;
-    const void*                                  pNext;
-    uint32_t                                     mbCount;
-    const VkVideoEncodeH264ReferenceListsEXT*    pReferenceFinalLists;
-    const StdVideoEncodeH264SliceHeader*         pSliceHeaderStd;
-} VkVideoEncodeH264NaluSliceEXT;
+typedef struct VkVideoEncodeH264NaluSliceInfoEXT {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    uint32_t                                         mbCount;
+    const VkVideoEncodeH264ReferenceListsInfoEXT*    pReferenceFinalLists;
+    const StdVideoEncodeH264SliceHeader*             pSliceHeaderStd;
+} VkVideoEncodeH264NaluSliceInfoEXT;
 
 typedef struct VkVideoEncodeH264VclFrameInfoEXT {
-    VkStructureType                              sType;
-    const void*                                  pNext;
-    const VkVideoEncodeH264ReferenceListsEXT*    pReferenceFinalLists;
-    uint32_t                                     naluSliceEntryCount;
-    const VkVideoEncodeH264NaluSliceEXT*         pNaluSliceEntries;
-    const StdVideoEncodeH264PictureInfo*         pCurrentPictureInfo;
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    const VkVideoEncodeH264ReferenceListsInfoEXT*    pReferenceFinalLists;
+    uint32_t                                         naluSliceEntryCount;
+    const VkVideoEncodeH264NaluSliceInfoEXT*         pNaluSliceEntries;
+    const StdVideoEncodeH264PictureInfo*             pCurrentPictureInfo;
 } VkVideoEncodeH264VclFrameInfoEXT;
 
-typedef struct VkVideoEncodeH264EmitPictureParametersEXT {
+typedef struct VkVideoEncodeH264EmitPictureParametersInfoEXT {
     VkStructureType    sType;
     const void*        pNext;
     uint8_t            spsId;
     VkBool32           emitSpsEnable;
     uint32_t           ppsIdEntryCount;
     const uint8_t*     ppsIdEntries;
-} VkVideoEncodeH264EmitPictureParametersEXT;
+} VkVideoEncodeH264EmitPictureParametersInfoEXT;
 
-typedef struct VkVideoEncodeH264ProfileEXT {
+typedef struct VkVideoEncodeH264ProfileInfoEXT {
     VkStructureType           sType;
     const void*               pNext;
     StdVideoH264ProfileIdc    stdProfileIdc;
-} VkVideoEncodeH264ProfileEXT;
+} VkVideoEncodeH264ProfileInfoEXT;
 
 typedef struct VkVideoEncodeH264RateControlInfoEXT {
-    VkStructureType                                     sType;
-    const void*                                         pNext;
-    uint32_t                                            gopFrameCount;
-    uint32_t                                            idrPeriod;
-    uint32_t                                            consecutiveBFrameCount;
-    VkVideoEncodeH264RateControlStructureFlagBitsEXT    rateControlStructure;
-    uint8_t                                             temporalLayerCount;
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    gopFrameCount;
+    uint32_t                                    idrPeriod;
+    uint32_t                                    consecutiveBFrameCount;
+    VkVideoEncodeH264RateControlStructureEXT    rateControlStructure;
+    uint8_t                                     temporalLayerCount;
 } VkVideoEncodeH264RateControlInfoEXT;
 
 typedef struct VkVideoEncodeH264QpEXT {
@@ -663,9 +690,16 @@ typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
 #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 7
+#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 9
 #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,
@@ -729,14 +763,6 @@ typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT {
     VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkVideoEncodeH265TransformBlockSizeFlagBitsEXT;
 typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT;
-
-typedef enum VkVideoEncodeH265RateControlStructureFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265RateControlStructureFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265RateControlStructureFlagsEXT;
 typedef struct VkVideoEncodeH265CapabilitiesEXT {
     VkStructureType                                sType;
     void*                                          pNext;
@@ -765,20 +791,20 @@ typedef struct VkVideoEncodeH265CapabilitiesEXT {
 typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT {
     VkStructureType                            sType;
     const void*                                pNext;
-    uint32_t                                   vpsStdCount;
-    const StdVideoH265VideoParameterSet*       pVpsStd;
-    uint32_t                                   spsStdCount;
-    const StdVideoH265SequenceParameterSet*    pSpsStd;
-    uint32_t                                   ppsStdCount;
-    const StdVideoH265PictureParameterSet*     pPpsStd;
+    uint32_t                                   stdVPSCount;
+    const StdVideoH265VideoParameterSet*       pStdVPSs;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH265SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH265PictureParameterSet*     pStdPPSs;
 } VkVideoEncodeH265SessionParametersAddInfoEXT;
 
 typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT {
     VkStructureType                                        sType;
     const void*                                            pNext;
-    uint32_t                                               maxVpsStdCount;
-    uint32_t                                               maxSpsStdCount;
-    uint32_t                                               maxPpsStdCount;
+    uint32_t                                               maxStdVPSCount;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
     const VkVideoEncodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;
 } VkVideoEncodeH265SessionParametersCreateInfoEXT;
 
@@ -789,7 +815,7 @@ typedef struct VkVideoEncodeH265DpbSlotInfoEXT {
     const StdVideoEncodeH265ReferenceInfo*    pStdReferenceInfo;
 } VkVideoEncodeH265DpbSlotInfoEXT;
 
-typedef struct VkVideoEncodeH265ReferenceListsEXT {
+typedef struct VkVideoEncodeH265ReferenceListsInfoEXT {
     VkStructureType                                    sType;
     const void*                                        pNext;
     uint8_t                                            referenceList0EntryCount;
@@ -797,26 +823,26 @@ typedef struct VkVideoEncodeH265ReferenceListsEXT {
     uint8_t                                            referenceList1EntryCount;
     const VkVideoEncodeH265DpbSlotInfoEXT*             pReferenceList1Entries;
     const StdVideoEncodeH265ReferenceModifications*    pReferenceModifications;
-} VkVideoEncodeH265ReferenceListsEXT;
+} VkVideoEncodeH265ReferenceListsInfoEXT;
 
-typedef struct VkVideoEncodeH265NaluSliceSegmentEXT {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    uint32_t                                       ctbCount;
-    const VkVideoEncodeH265ReferenceListsEXT*      pReferenceFinalLists;
-    const StdVideoEncodeH265SliceSegmentHeader*    pSliceSegmentHeaderStd;
-} VkVideoEncodeH265NaluSliceSegmentEXT;
+typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    uint32_t                                         ctbCount;
+    const VkVideoEncodeH265ReferenceListsInfoEXT*    pReferenceFinalLists;
+    const StdVideoEncodeH265SliceSegmentHeader*      pSliceSegmentHeaderStd;
+} VkVideoEncodeH265NaluSliceSegmentInfoEXT;
 
 typedef struct VkVideoEncodeH265VclFrameInfoEXT {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    const VkVideoEncodeH265ReferenceListsEXT*      pReferenceFinalLists;
-    uint32_t                                       naluSliceSegmentEntryCount;
-    const VkVideoEncodeH265NaluSliceSegmentEXT*    pNaluSliceSegmentEntries;
-    const StdVideoEncodeH265PictureInfo*           pCurrentPictureInfo;
+    VkStructureType                                    sType;
+    const void*                                        pNext;
+    const VkVideoEncodeH265ReferenceListsInfoEXT*      pReferenceFinalLists;
+    uint32_t                                           naluSliceSegmentEntryCount;
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT*    pNaluSliceSegmentEntries;
+    const StdVideoEncodeH265PictureInfo*               pCurrentPictureInfo;
 } VkVideoEncodeH265VclFrameInfoEXT;
 
-typedef struct VkVideoEncodeH265EmitPictureParametersEXT {
+typedef struct VkVideoEncodeH265EmitPictureParametersInfoEXT {
     VkStructureType    sType;
     const void*        pNext;
     uint8_t            vpsId;
@@ -825,22 +851,22 @@ typedef struct VkVideoEncodeH265EmitPictureParametersEXT {
     VkBool32           emitSpsEnable;
     uint32_t           ppsIdEntryCount;
     const uint8_t*     ppsIdEntries;
-} VkVideoEncodeH265EmitPictureParametersEXT;
+} VkVideoEncodeH265EmitPictureParametersInfoEXT;
 
-typedef struct VkVideoEncodeH265ProfileEXT {
+typedef struct VkVideoEncodeH265ProfileInfoEXT {
     VkStructureType           sType;
     const void*               pNext;
     StdVideoH265ProfileIdc    stdProfileIdc;
-} VkVideoEncodeH265ProfileEXT;
+} VkVideoEncodeH265ProfileInfoEXT;
 
 typedef struct VkVideoEncodeH265RateControlInfoEXT {
-    VkStructureType                                     sType;
-    const void*                                         pNext;
-    uint32_t                                            gopFrameCount;
-    uint32_t                                            idrPeriod;
-    uint32_t                                            consecutiveBFrameCount;
-    VkVideoEncodeH265RateControlStructureFlagBitsEXT    rateControlStructure;
-    uint8_t                                             subLayerCount;
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    gopFrameCount;
+    uint32_t                                    idrPeriod;
+    uint32_t                                    consecutiveBFrameCount;
+    VkVideoEncodeH265RateControlStructureEXT    rateControlStructure;
+    uint8_t                                     subLayerCount;
 } VkVideoEncodeH265RateControlInfoEXT;
 
 typedef struct VkVideoEncodeH265QpEXT {
@@ -873,7 +899,7 @@ typedef struct VkVideoEncodeH265RateControlLayerInfoEXT {
 
 #define VK_EXT_video_decode_h264 1
 #include "vk_video/vulkan_video_codec_h264std_decode.h"
-#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 5
+#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 7
 #define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"
 
 typedef enum VkVideoDecodeH264PictureLayoutFlagBitsEXT {
@@ -883,34 +909,34 @@ typedef enum VkVideoDecodeH264PictureLayoutFlagBitsEXT {
     VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkVideoDecodeH264PictureLayoutFlagBitsEXT;
 typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsEXT;
-typedef struct VkVideoDecodeH264ProfileEXT {
-    VkStructureType                           sType;
-    const void*                               pNext;
-    StdVideoH264ProfileIdc                    stdProfileIdc;
-    VkVideoDecodeH264PictureLayoutFlagsEXT    pictureLayout;
-} VkVideoDecodeH264ProfileEXT;
+typedef struct VkVideoDecodeH264ProfileInfoEXT {
+    VkStructureType                              sType;
+    const void*                                  pNext;
+    StdVideoH264ProfileIdc                       stdProfileIdc;
+    VkVideoDecodeH264PictureLayoutFlagBitsEXT    pictureLayout;
+} VkVideoDecodeH264ProfileInfoEXT;
 
 typedef struct VkVideoDecodeH264CapabilitiesEXT {
-    VkStructureType      sType;
-    void*                pNext;
-    StdVideoH264Level    maxLevel;
-    VkOffset2D           fieldOffsetGranularity;
+    VkStructureType         sType;
+    void*                   pNext;
+    StdVideoH264LevelIdc    maxLevelIdc;
+    VkOffset2D              fieldOffsetGranularity;
 } VkVideoDecodeH264CapabilitiesEXT;
 
 typedef struct VkVideoDecodeH264SessionParametersAddInfoEXT {
     VkStructureType                            sType;
     const void*                                pNext;
-    uint32_t                                   spsStdCount;
-    const StdVideoH264SequenceParameterSet*    pSpsStd;
-    uint32_t                                   ppsStdCount;
-    const StdVideoH264PictureParameterSet*     pPpsStd;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH264SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH264PictureParameterSet*     pStdPPSs;
 } VkVideoDecodeH264SessionParametersAddInfoEXT;
 
 typedef struct VkVideoDecodeH264SessionParametersCreateInfoEXT {
     VkStructureType                                        sType;
     const void*                                            pNext;
-    uint32_t                                               maxSpsStdCount;
-    uint32_t                                               maxPpsStdCount;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
     const VkVideoDecodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;
 } VkVideoDecodeH264SessionParametersCreateInfoEXT;
 
@@ -918,16 +944,10 @@ typedef struct VkVideoDecodeH264PictureInfoEXT {
     VkStructureType                         sType;
     const void*                             pNext;
     const StdVideoDecodeH264PictureInfo*    pStdPictureInfo;
-    uint32_t                                slicesCount;
-    const uint32_t*                         pSlicesDataOffsets;
+    uint32_t                                sliceCount;
+    const uint32_t*                         pSliceOffsets;
 } VkVideoDecodeH264PictureInfoEXT;
 
-typedef struct VkVideoDecodeH264MvcEXT {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    const StdVideoDecodeH264Mvc*    pStdMvc;
-} VkVideoDecodeH264MvcEXT;
-
 typedef struct VkVideoDecodeH264DpbSlotInfoEXT {
     VkStructureType                           sType;
     const void*                               pNext;
@@ -938,37 +958,37 @@ typedef struct VkVideoDecodeH264DpbSlotInfoEXT {
 
 #define VK_EXT_video_decode_h265 1
 #include "vk_video/vulkan_video_codec_h265std_decode.h"
-#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 3
+#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 5
 #define VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME "VK_EXT_video_decode_h265"
-typedef struct VkVideoDecodeH265ProfileEXT {
+typedef struct VkVideoDecodeH265ProfileInfoEXT {
     VkStructureType           sType;
     const void*               pNext;
     StdVideoH265ProfileIdc    stdProfileIdc;
-} VkVideoDecodeH265ProfileEXT;
+} VkVideoDecodeH265ProfileInfoEXT;
 
 typedef struct VkVideoDecodeH265CapabilitiesEXT {
-    VkStructureType      sType;
-    void*                pNext;
-    StdVideoH265Level    maxLevel;
+    VkStructureType         sType;
+    void*                   pNext;
+    StdVideoH265LevelIdc    maxLevelIdc;
 } VkVideoDecodeH265CapabilitiesEXT;
 
 typedef struct VkVideoDecodeH265SessionParametersAddInfoEXT {
     VkStructureType                            sType;
     const void*                                pNext;
-    uint32_t                                   vpsStdCount;
-    const StdVideoH265VideoParameterSet*       pVpsStd;
-    uint32_t                                   spsStdCount;
-    const StdVideoH265SequenceParameterSet*    pSpsStd;
-    uint32_t                                   ppsStdCount;
-    const StdVideoH265PictureParameterSet*     pPpsStd;
+    uint32_t                                   stdVPSCount;
+    const StdVideoH265VideoParameterSet*       pStdVPSs;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH265SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH265PictureParameterSet*     pStdPPSs;
 } VkVideoDecodeH265SessionParametersAddInfoEXT;
 
 typedef struct VkVideoDecodeH265SessionParametersCreateInfoEXT {
     VkStructureType                                        sType;
     const void*                                            pNext;
-    uint32_t                                               maxVpsStdCount;
-    uint32_t                                               maxSpsStdCount;
-    uint32_t                                               maxPpsStdCount;
+    uint32_t                                               maxStdVPSCount;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
     const VkVideoDecodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;
 } VkVideoDecodeH265SessionParametersCreateInfoEXT;
 
@@ -976,8 +996,8 @@ typedef struct VkVideoDecodeH265PictureInfoEXT {
     VkStructureType                   sType;
     const void*                       pNext;
     StdVideoDecodeH265PictureInfo*    pStdPictureInfo;
-    uint32_t                          slicesCount;
-    const uint32_t*                   pSlicesDataOffsets;
+    uint32_t                          sliceCount;
+    const uint32_t*                   pSliceOffsets;
 } VkVideoDecodeH265PictureInfoEXT;
 
 typedef struct VkVideoDecodeH265DpbSlotInfoEXT {