[PATCH 0/1] MR6871: winevulkan: Update to VK spec version 1.3.302.

List overview All Threads

newer

older

[PATCH v6 0/4] MR6835: wintrust:...

[PATCH v5 0/2] MR6869: timeout:...

Georg Lehmann (＠DadSchoorse)

21 Nov 2024 21 Nov '24

11:51 a.m.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/6871

Show replies by date

Georg Lehmann

21 Nov 21 Nov

11:51 a.m.

New subject: [PATCH 1/1] winevulkan: Update to VK spec version 1.3.302.

From: Georg Lehmann dadschoorse@gmail.com

--- dlls/winevulkan/loader_thunks.c | 25 + dlls/winevulkan/loader_thunks.h | 17 + dlls/winevulkan/make_vulkan | 2 +- dlls/winevulkan/vulkan_thunks.c | 1348 +++++++++++++++++++++++++++++-- dlls/winevulkan/vulkan_thunks.h | 4 + dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 570 ++++++++++++- 7 files changed, 1873 insertions(+), 95 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index a427006cac1..ef6468cc0d9 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -4820,6 +4820,17 @@ VkResult WINAPI vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, return params.result; }

+uint64_t WINAPI vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) +{ + struct vkGetImageViewHandle64NVX_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + status = UNIX_CALL(vkGetImageViewHandle64NVX, &params); + assert(!status && "vkGetImageViewHandle64NVX"); + return params.result; +} + uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) { struct vkGetImageViewHandleNVX_params params; @@ -4915,6 +4926,18 @@ VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice return params.result; }

+VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *pProperties) +{ + struct vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV_params params; + NTSTATUS status; + params.physicalDevice = physicalDevice; + params.pPropertyCount = pPropertyCount; + params.pProperties = pProperties; + status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, &params); + assert(!status && "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"); + return params.result; +} + VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties) { struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params params; @@ -6964,6 +6987,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetImageSubresourceLayout2EXT", vkGetImageSubresourceLayout2EXT}, {"vkGetImageSubresourceLayout2KHR", vkGetImageSubresourceLayout2KHR}, {"vkGetImageViewAddressNVX", vkGetImageViewAddressNVX}, + {"vkGetImageViewHandle64NVX", vkGetImageViewHandle64NVX}, {"vkGetImageViewHandleNVX", vkGetImageViewHandleNVX}, {"vkGetImageViewOpaqueCaptureDescriptorDataEXT", vkGetImageViewOpaqueCaptureDescriptorDataEXT}, {"vkGetLatencyTimingsNV", vkGetLatencyTimingsNV}, @@ -7068,6 +7092,7 @@ static const struct vulkan_func vk_phys_dev_dispatch_table[] = {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", vkGetPhysicalDeviceCalibrateableTimeDomainsEXT}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", vkGetPhysicalDeviceCalibrateableTimeDomainsKHR}, + {"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixPropertiesNV}, {"vkGetPhysicalDeviceExternalBufferProperties", vkGetPhysicalDeviceExternalBufferProperties}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index 8ab16eebdf4..bdc5eb8c0dd 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -486,6 +486,7 @@ enum unix_call unix_vkGetImageSubresourceLayout2EXT, unix_vkGetImageSubresourceLayout2KHR, unix_vkGetImageViewAddressNVX, + unix_vkGetImageViewHandle64NVX, unix_vkGetImageViewHandleNVX, unix_vkGetImageViewOpaqueCaptureDescriptorDataEXT, unix_vkGetLatencyTimingsNV, @@ -494,6 +495,7 @@ enum unix_call unix_vkGetPerformanceParameterINTEL, unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, unix_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, + unix_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, unix_vkGetPhysicalDeviceExternalBufferProperties, @@ -4200,6 +4202,13 @@ struct vkGetImageViewAddressNVX_params VkResult result; };

+struct vkGetImageViewHandle64NVX_params +{ + VkDevice device; + const VkImageViewHandleInfoNVX *pInfo; + uint64_t result; +}; + struct vkGetImageViewHandleNVX_params { VkDevice device; @@ -4263,6 +4272,14 @@ struct vkGetPhysicalDeviceCalibrateableTimeDomainsKHR_params VkResult result; };

+struct vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV_params +{ + VkPhysicalDevice physicalDevice; + uint32_t *pPropertyCount; + VkCooperativeMatrixFlexibleDimensionsPropertiesNV *pProperties; + VkResult result; +}; + struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params { VkPhysicalDevice physicalDevice; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 20f9f440d91..5bd6db50fa1 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -64,7 +64,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler())

-VK_XML_VERSION = "1.3.296" +VK_XML_VERSION = "1.3.302" WINE_VK_VERSION = (1, 3)

# Filenames to create. diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 1a2d2487a4c..7bcc5d8929a 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -228,14 +228,6 @@ typedef struct VkAttachmentSampleCountInfoAMD32 } VkAttachmentSampleCountInfoAMD32; typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;

-typedef struct VkMultiviewPerViewAttributesInfoNVX32 -{ - VkStructureType sType; - PTR32 pNext; - VkBool32 perViewAttributes; - VkBool32 perViewAttributesPositionXOnly; -} VkMultiviewPerViewAttributesInfoNVX32; - typedef struct VkRenderingAttachmentLocationInfoKHR32 { VkStructureType sType; @@ -660,6 +652,18 @@ typedef struct VkVideoEncodeH265RateControlLayerInfoKHR32 VkVideoEncodeH265FrameSizeKHR maxFrameSize; } VkVideoEncodeH265RateControlLayerInfoKHR32;

+typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 useMinQIndex; + VkVideoEncodeAV1QIndexKHR minQIndex; + VkBool32 useMaxQIndex; + VkVideoEncodeAV1QIndexKHR maxQIndex; + VkBool32 useMaxFrameSize; + VkVideoEncodeAV1FrameSizeKHR maxFrameSize; +} VkVideoEncodeAV1RateControlLayerInfoKHR32; + typedef struct VkVideoEncodeRateControlLayerInfoKHR32 { VkStructureType sType; @@ -670,6 +674,16 @@ typedef struct VkVideoEncodeRateControlLayerInfoKHR32 uint32_t frameRateDenominator; } VkVideoEncodeRateControlLayerInfoKHR32;

+typedef struct StdVideoEncodeAV1ReferenceInfo32 +{ + StdVideoEncodeAV1ReferenceInfoFlags flags; + uint32_t RefFrameId; + StdVideoAV1FrameType frame_type; + uint8_t OrderHint; + uint8_t reserved1[3]; + PTR32 pExtensionHeader; +} StdVideoEncodeAV1ReferenceInfo32; + typedef struct VkVideoPictureResourceInfoKHR32 { VkStructureType sType; @@ -715,6 +729,13 @@ typedef struct VkVideoEncodeH265DpbSlotInfoKHR32 PTR32 pStdReferenceInfo; } VkVideoEncodeH265DpbSlotInfoKHR32;

+typedef struct VkVideoEncodeAV1DpbSlotInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pStdReferenceInfo; +} VkVideoEncodeAV1DpbSlotInfoKHR32; + typedef struct VkVideoReferenceSlotInfoKHR32 { VkStructureType sType; @@ -777,6 +798,27 @@ typedef struct VkVideoEncodeH265GopRemainingFrameInfoKHR32 uint32_t gopRemainingB; } VkVideoEncodeH265GopRemainingFrameInfoKHR32;

+typedef struct VkVideoEncodeAV1RateControlInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeAV1RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t keyFramePeriod; + uint32_t consecutiveBipredictiveFrameCount; + uint32_t temporalLayerCount; +} VkVideoEncodeAV1RateControlInfoKHR32; + +typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingIntra; + uint32_t gopRemainingPredictive; + uint32_t gopRemainingBipredictive; +} VkVideoEncodeAV1GopRemainingFrameInfoKHR32; + typedef struct VkVideoBeginCodingInfoKHR32 { VkStructureType sType; @@ -1346,6 +1388,45 @@ typedef struct StdVideoEncodeH265PictureInfo32 PTR32 pLongTermRefPics; } StdVideoEncodeH265PictureInfo32;

+typedef struct StdVideoEncodeAV1PictureInfo32 +{ + StdVideoEncodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t frame_presentation_time; + uint32_t current_frame_id; + uint8_t order_hint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t coded_denom; + uint16_t render_width_minus_1; + uint16_t render_height_minus_1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME]; + uint8_t reserved1[3]; + uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME]; + PTR32 pTileInfo; + PTR32 pQuantization; + PTR32 pSegmentation; + PTR32 pLoopFilter; + PTR32 pCDEF; + PTR32 pLoopRestoration; + PTR32 pGlobalMotion; + PTR32 pExtensionHeader; + PTR32 pBufferRemovalTimes; +} StdVideoEncodeAV1PictureInfo32; + +typedef struct VkVideoEncodeQuantizationMapInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageView DECLSPEC_ALIGN(8) quantizationMap; + VkExtent2D quantizationMapExtent; +} VkVideoEncodeQuantizationMapInfoKHR32; + typedef struct VkVideoEncodeH264PictureInfoKHR32 { VkStructureType sType; @@ -1365,6 +1446,19 @@ typedef struct VkVideoEncodeH265PictureInfoKHR32 PTR32 pStdPictureInfo; } VkVideoEncodeH265PictureInfoKHR32;

+typedef struct VkVideoEncodeAV1PictureInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeAV1PredictionModeKHR predictionMode; + VkVideoEncodeAV1RateControlGroupKHR rateControlGroup; + uint32_t constantQIndex; + PTR32 pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + VkBool32 primaryReferenceCdfOnly; + VkBool32 generateObuExtensionHeader; +} VkVideoEncodeAV1PictureInfoKHR32; + typedef struct VkVideoEncodeInfoKHR32 { VkStructureType sType; @@ -1917,6 +2011,13 @@ typedef struct VkVideoEncodeH265ProfileInfoKHR32 StdVideoH265ProfileIdc stdProfileIdc; } VkVideoEncodeH265ProfileInfoKHR32;

+typedef struct VkVideoEncodeAV1ProfileInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + StdVideoAV1Profile stdProfile; +} VkVideoEncodeAV1ProfileInfoKHR32; + typedef struct VkVideoProfileInfoKHR32 { VkStructureType sType; @@ -2149,6 +2250,13 @@ typedef struct VkCuFunctionCreateInfoNVX32 PTR32 pName; } VkCuFunctionCreateInfoNVX32;

+typedef struct VkCuModuleTexturingModeCreateInfoNVX32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 use64bitTexturing; +} VkCuModuleTexturingModeCreateInfoNVX32; + typedef struct VkCuModuleCreateInfoNVX32 { VkStructureType sType; @@ -3430,6 +3538,20 @@ typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 VkBool32 videoMaintenance1; } VkPhysicalDeviceVideoMaintenance1FeaturesKHR32;

+typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 videoEncodeQuantizationMap; +} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32; + +typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 videoEncodeAV1; +} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32; + typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 { VkStructureType sType; @@ -3955,6 +4077,40 @@ typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 VkBool32 shaderReplicatedComposites; } VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32;

+typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 presentModeFifoLatestReady; +} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32; + +typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 cooperativeMatrixWorkgroupScope; + VkBool32 cooperativeMatrixFlexibleDimensions; + VkBool32 cooperativeMatrixReductions; + VkBool32 cooperativeMatrixConversions; + VkBool32 cooperativeMatrixPerElementOperations; + VkBool32 cooperativeMatrixTensorAddressing; + VkBool32 cooperativeMatrixBlockLoads; +} VkPhysicalDeviceCooperativeMatrix2FeaturesNV32; + +typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 hdrVivid; +} VkPhysicalDeviceHdrVividFeaturesHUAWEI32; + +typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 vertexAttributeRobustness; +} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32; + typedef struct VkDeviceCreateInfo32 { VkStructureType sType; @@ -5316,6 +5472,14 @@ typedef struct VkVideoEncodeH265SessionCreateInfoKHR32 StdVideoH265LevelIdc maxLevelIdc; } VkVideoEncodeH265SessionCreateInfoKHR32;

+typedef struct VkVideoEncodeAV1SessionCreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 useMaxLevel; + StdVideoAV1Level maxLevel; +} VkVideoEncodeAV1SessionCreateInfoKHR32; + typedef struct VkVideoSessionCreateInfoKHR32 { VkStructureType sType; @@ -5631,6 +5795,13 @@ typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR32 PTR32 pStdSequenceHeader; } VkVideoDecodeAV1SessionParametersCreateInfoKHR32;

+typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkExtent2D quantizationMapTexelSize; +} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32; + typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR32 { VkStructureType sType; @@ -5650,6 +5821,16 @@ typedef struct VkVideoEncodeH265SessionParametersCreateInfoKHR32 PTR32 pParametersAddInfo; } VkVideoEncodeH265SessionParametersCreateInfoKHR32;

+typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pStdSequenceHeader; + PTR32 pStdDecoderModelInfo; + uint32_t stdOperatingPointCount; + PTR32 pStdOperatingPoints; +} VkVideoEncodeAV1SessionParametersCreateInfoKHR32; + typedef struct VkVideoSessionParametersCreateInfoKHR32 { VkStructureType sType; @@ -6229,6 +6410,22 @@ typedef struct VkPerformanceValueINTEL32 VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data; } VkPerformanceValueINTEL32;

+typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t MGranularity; + uint32_t NGranularity; + uint32_t KGranularity; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; + uint32_t workgroupInvocations; +} VkCooperativeMatrixFlexibleDimensionsPropertiesNV32; + typedef struct VkCooperativeMatrixPropertiesKHR32 { VkStructureType sType; @@ -7659,6 +7856,15 @@ typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA32 uint32_t supportedImageAlignmentMask; } VkPhysicalDeviceImageAlignmentControlPropertiesMESA32;

+typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; + uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension; + uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory; +} VkPhysicalDeviceCooperativeMatrix2PropertiesNV32; + typedef struct VkPhysicalDeviceProperties232 { VkStructureType sType; @@ -7816,6 +8022,37 @@ typedef struct VkPhysicalDeviceToolProperties32 } VkPhysicalDeviceToolProperties32; typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;

+typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkExtent2D maxQuantizationMapExtent; +} VkVideoEncodeQuantizationMapCapabilitiesKHR32; + +typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH264QuantizationMapCapabilitiesKHR32; + +typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH265QuantizationMapCapabilitiesKHR32; + +typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + int32_t minQIndexDelta; + int32_t maxQIndexDelta; +} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32; + typedef struct VkVideoDecodeCapabilitiesKHR32 { VkStructureType sType; @@ -7899,6 +8136,36 @@ typedef struct VkVideoEncodeH265CapabilitiesKHR32 VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags; } VkVideoEncodeH265CapabilitiesKHR32;

+typedef struct VkVideoEncodeAV1CapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeAV1CapabilityFlagsKHR flags; + StdVideoAV1Level maxLevel; + VkExtent2D codedPictureAlignment; + VkExtent2D maxTiles; + VkExtent2D minTileSize; + VkExtent2D maxTileSize; + VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes; + uint32_t maxSingleReferenceCount; + uint32_t singleReferenceNameMask; + uint32_t maxUnidirectionalCompoundReferenceCount; + uint32_t maxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t unidirectionalCompoundReferenceNameMask; + uint32_t maxBidirectionalCompoundReferenceCount; + uint32_t maxBidirectionalCompoundGroup1ReferenceCount; + uint32_t maxBidirectionalCompoundGroup2ReferenceCount; + uint32_t bidirectionalCompoundReferenceNameMask; + uint32_t maxTemporalLayerCount; + uint32_t maxSpatialLayerCount; + uint32_t maxOperatingPoints; + uint32_t minQIndex; + uint32_t maxQIndex; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeAV1CapabilitiesKHR32; + typedef struct VkVideoCapabilitiesKHR32 { VkStructureType sType; @@ -7951,6 +8218,27 @@ typedef struct VkVideoEncodeH265QualityLevelPropertiesKHR32 uint32_t preferredMaxL1ReferenceCount; } VkVideoEncodeH265QualityLevelPropertiesKHR32;

+typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredKeyFramePeriod; + uint32_t preferredConsecutiveBipredictiveFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeAV1QIndexKHR preferredConstantQIndex; + uint32_t preferredMaxSingleReferenceCount; + uint32_t preferredSingleReferenceNameMask; + uint32_t preferredMaxUnidirectionalCompoundReferenceCount; + uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredUnidirectionalCompoundReferenceNameMask; + uint32_t preferredMaxBidirectionalCompoundReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount; + uint32_t preferredBidirectionalCompoundReferenceNameMask; +} VkVideoEncodeAV1QualityLevelPropertiesKHR32; + typedef struct VkVideoEncodeQualityLevelPropertiesKHR32 { VkStructureType sType; @@ -7966,6 +8254,27 @@ typedef struct VkPhysicalDeviceVideoFormatInfoKHR32 VkImageUsageFlags imageUsage; } VkPhysicalDeviceVideoFormatInfoKHR32;

+typedef struct VkVideoFormatQuantizationMapPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkExtent2D quantizationMapTexelSize; +} VkVideoFormatQuantizationMapPropertiesKHR32; + +typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes; +} VkVideoFormatH265QuantizationMapPropertiesKHR32; + +typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes; +} VkVideoFormatAV1QuantizationMapPropertiesKHR32; + typedef struct VkVideoFormatPropertiesKHR32 { VkStructureType sType; @@ -8404,6 +8713,14 @@ typedef struct VkDebugUtilsObjectTagInfoEXT32 PTR32 pTag; } VkDebugUtilsObjectTagInfoEXT32;

+typedef struct VkHdrVividDynamicMetadataHUAWEI32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 dynamicMetadataSize; + PTR32 pDynamicMetadata; +} VkHdrVividDynamicMetadataHUAWEI32; + typedef struct VkHdrMetadataEXT32 { VkStructureType sType; @@ -8928,18 +9245,6 @@ static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: - { - VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; - out_ext->pNext = NULL; - out_ext->perViewAttributes = in_ext->perViewAttributes; - out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: { VkRenderingAttachmentLocationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -10002,18 +10307,6 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: - { - VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; - out_ext->pNext = NULL; - out_ext->perViewAttributes = in_ext->perViewAttributes; - out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: { VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -10095,6 +10388,22 @@ static inline void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(st out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: + { + VkVideoEncodeAV1RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlLayerInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; + out_ext->pNext = NULL; + out_ext->useMinQIndex = in_ext->useMinQIndex; + out_ext->minQIndex = in_ext->minQIndex; + out_ext->useMaxQIndex = in_ext->useMaxQIndex; + out_ext->maxQIndex = in_ext->maxQIndex; + out_ext->useMaxFrameSize = in_ext->useMaxFrameSize; + out_ext->maxFrameSize = in_ext->maxFrameSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -10118,6 +10427,34 @@ static inline const VkVideoEncodeRateControlLayerInfoKHR *convert_VkVideoEncodeR return out; }

+static inline void convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(const StdVideoEncodeAV1ReferenceInfo32 *in, StdVideoEncodeAV1ReferenceInfo *out) +{ + if (!in) return; + + out->flags = in->flags; + out->RefFrameId = in->RefFrameId; + out->frame_type = in->frame_type; + out->OrderHint = in->OrderHint; + memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint8_t)); + out->pExtensionHeader = UlongToPtr(in->pExtensionHeader); +} + +static inline const StdVideoEncodeAV1ReferenceInfo *convert_StdVideoEncodeAV1ReferenceInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1ReferenceInfo32 *in, uint32_t count) +{ + StdVideoEncodeAV1ReferenceInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static inline void convert_VkVideoPictureResourceInfoKHR_win32_to_host(const VkVideoPictureResourceInfoKHR32 *in, VkVideoPictureResourceInfoKHR *out) { if (!in) return; @@ -10219,6 +10556,17 @@ static inline void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: + { + VkVideoEncodeAV1DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1DpbSlotInfoKHR32 *in_ext = (const VkVideoEncodeAV1DpbSlotInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pStdReferenceInfo = convert_StdVideoEncodeAV1ReferenceInfo_array_win32_to_host(ctx, (const StdVideoEncodeAV1ReferenceInfo32 *)UlongToPtr(in_ext->pStdReferenceInfo), 1); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -10335,6 +10683,35 @@ static inline void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: + { + VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->gopFrameCount = in_ext->gopFrameCount; + out_ext->keyFramePeriod = in_ext->keyFramePeriod; + out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount; + out_ext->temporalLayerCount = in_ext->temporalLayerCount; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: + { + VkVideoEncodeAV1GopRemainingFrameInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *in_ext = (const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; + out_ext->pNext = NULL; + out_ext->useGopRemainingFrames = in_ext->useGopRemainingFrames; + out_ext->gopRemainingIntra = in_ext->gopRemainingIntra; + out_ext->gopRemainingPredictive = in_ext->gopRemainingPredictive; + out_ext->gopRemainingBipredictive = in_ext->gopRemainingBipredictive; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -10763,6 +11140,21 @@ static inline void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: + { + VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->gopFrameCount = in_ext->gopFrameCount; + out_ext->keyFramePeriod = in_ext->keyFramePeriod; + out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount; + out_ext->temporalLayerCount = in_ext->temporalLayerCount; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -11545,6 +11937,55 @@ static inline const StdVideoEncodeH265PictureInfo *convert_StdVideoEncodeH265Pic return out; }

+static inline void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out) +{ + if (!in) return; + + out->flags = in->flags; + out->frame_type = in->frame_type; + out->frame_presentation_time = in->frame_presentation_time; + out->current_frame_id = in->current_frame_id; + out->order_hint = in->order_hint; + out->primary_ref_frame = in->primary_ref_frame; + out->refresh_frame_flags = in->refresh_frame_flags; + out->coded_denom = in->coded_denom; + out->render_width_minus_1 = in->render_width_minus_1; + out->render_height_minus_1 = in->render_height_minus_1; + out->interpolation_filter = in->interpolation_filter; + out->TxMode = in->TxMode; + out->delta_q_res = in->delta_q_res; + out->delta_lf_res = in->delta_lf_res; + memcpy(out->ref_order_hint, in->ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES * sizeof(uint8_t)); + memcpy(out->ref_frame_idx, in->ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(int8_t)); + memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint8_t)); + memcpy(out->delta_frame_id_minus_1, in->delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(uint32_t)); + out->pTileInfo = convert_StdVideoAV1TileInfo_array_win32_to_host(ctx, (const StdVideoAV1TileInfo32 *)UlongToPtr(in->pTileInfo), 1); + out->pQuantization = UlongToPtr(in->pQuantization); + out->pSegmentation = UlongToPtr(in->pSegmentation); + out->pLoopFilter = UlongToPtr(in->pLoopFilter); + out->pCDEF = UlongToPtr(in->pCDEF); + out->pLoopRestoration = UlongToPtr(in->pLoopRestoration); + out->pGlobalMotion = UlongToPtr(in->pGlobalMotion); + out->pExtensionHeader = UlongToPtr(in->pExtensionHeader); + out->pBufferRemovalTimes = UlongToPtr(in->pBufferRemovalTimes); +} + +static inline const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count) +{ + StdVideoEncodeAV1PictureInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_StdVideoEncodeAV1PictureInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeInfoKHR32 *in, VkVideoEncodeInfoKHR *out) { const VkBaseInStructure32 *in_header; @@ -11581,6 +12022,18 @@ static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: + { + VkVideoEncodeQuantizationMapInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeQuantizationMapInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; + out_ext->pNext = NULL; + out_ext->quantizationMap = in_ext->quantizationMap; + out_ext->quantizationMapExtent = in_ext->quantizationMapExtent; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: { VkVideoEncodeH264PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -11608,6 +12061,23 @@ static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: + { + VkVideoEncodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1PictureInfoKHR32 *in_ext = (const VkVideoEncodeAV1PictureInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->predictionMode = in_ext->predictionMode; + out_ext->rateControlGroup = in_ext->rateControlGroup; + out_ext->constantQIndex = in_ext->constantQIndex; + out_ext->pStdPictureInfo = convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoEncodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1); + memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t)); + out_ext->primaryReferenceCdfOnly = in_ext->primaryReferenceCdfOnly; + out_ext->generateObuExtensionHeader = in_ext->generateObuExtensionHeader; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -13004,6 +13474,17 @@ static inline void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: + { + VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stdProfile = in_ext->stdProfile; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -13677,16 +14158,38 @@ static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFun FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out) +static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversion_context *ctx, const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return;

out->sType = in->sType; out->pNext = NULL; out->dataSize = in->dataSize; out->pData = UlongToPtr(in->pData); - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: + { + VkCuModuleTexturingModeCreateInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkCuModuleTexturingModeCreateInfoNVX32 *in_ext = (const VkCuModuleTexturingModeCreateInfoNVX32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; + out_ext->pNext = NULL; + out_ext->use64bitTexturing = in_ext->use64bitTexturing; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } }

static inline void convert_VkCudaFunctionCreateInfoNV_win32_to_host(const VkCudaFunctionCreateInfoNV32 *in, VkCudaFunctionCreateInfoNV *out) @@ -15651,6 +16154,28 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -16467,6 +16992,56 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + { + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + { + VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + out_ext->pNext = NULL; + out_ext->hdrVivid = in_ext->hdrVivid; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -18078,6 +18653,28 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -18894,6 +19491,56 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + { + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + { + VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + out_ext->pNext = NULL; + out_ext->hdrVivid = in_ext->hdrVivid; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -19921,18 +20568,6 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: - { - VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; - out_ext->pNext = NULL; - out_ext->perViewAttributes = in_ext->perViewAttributes; - out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: { VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20174,18 +20809,6 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: - { - VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; - out_ext->pNext = NULL; - out_ext->perViewAttributes = in_ext->perViewAttributes; - out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: { VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20727,7 +21350,7 @@ static inline void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const Vk { if (!in) return;

- if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT) + if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT || selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT) out->pPushConstant = UlongToPtr(in->pPushConstant); if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT) out->pVertexBuffer = UlongToPtr(in->pVertexBuffer); @@ -21605,6 +22228,17 @@ static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: + { + VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stdProfile = in_ext->stdProfile; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -23011,6 +23645,18 @@ static inline void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: + { + VkVideoEncodeAV1SessionCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1SessionCreateInfoKHR32 *in_ext = (const VkVideoEncodeAV1SessionCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->useMaxLevel = in_ext->useMaxLevel; + out_ext->maxLevel = in_ext->maxLevel; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -23589,6 +24235,17 @@ static inline void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(s out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: + { + VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: { VkVideoEncodeQualityLevelInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23627,6 +24284,20 @@ static inline void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(s out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + { + VkVideoEncodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pStdSequenceHeader = convert_StdVideoAV1SequenceHeader_array_win32_to_host(ctx, (const StdVideoAV1SequenceHeader32 *)UlongToPtr(in_ext->pStdSequenceHeader), 1); + out_ext->pStdDecoderModelInfo = UlongToPtr(in_ext->pStdDecoderModelInfo); + out_ext->stdOperatingPointCount = in_ext->stdOperatingPointCount; + out_ext->pStdOperatingPoints = UlongToPtr(in_ext->pStdOperatingPoints); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25005,12 +25676,6 @@ static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to } }

-static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_host_to_win32(const VkGeneratedCommandsMemoryRequirementsInfoEXT *in, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *out) -{ - if (!in) return; - -} - static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out) { if (!in) return; @@ -25289,6 +25954,60 @@ static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerform convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type); }

+static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win32_to_host(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out) +{ + if (!in) return; + + out->MGranularity = in->MGranularity; + out->NGranularity = in->NGranularity; + out->KGranularity = in->KGranularity; + out->AType = in->AType; + out->BType = in->BType; + out->CType = in->CType; + out->ResultType = in->ResultType; + out->saturatingAccumulation = in->saturatingAccumulation; + out->scope = in->scope; + out->workgroupInvocations = in->workgroupInvocations; +} + +static inline VkCooperativeMatrixFlexibleDimensionsPropertiesNV *convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, uint32_t count) +{ + VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_host_to_win32(&in[i], &out[i]); + } +} + static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out) { if (!in) return; @@ -27056,6 +27775,28 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -27850,6 +28591,56 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + { + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + { + VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + out_ext->pNext = NULL; + out_ext->hdrVivid = in_ext->hdrVivid; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -29146,6 +29937,24 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV); @@ -29800,6 +30609,48 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + { + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + { + VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + out_ext->hdrVivid = in_ext->hdrVivid; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + { + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; + out_header = (void *)out_ext; + break; + } default: break; } @@ -31322,6 +32173,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: + { + VkPhysicalDeviceCooperativeMatrix2PropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -32566,6 +33426,17 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: + { + VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV); + const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; + out_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = in_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; + out_ext->cooperativeMatrixFlexibleDimensionsMaxDimension = in_ext->cooperativeMatrixFlexibleDimensionsMaxDimension; + out_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory = in_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory; + out_header = (void *)out_ext; + break; + } default: break; } @@ -33159,6 +34030,42 @@ static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversio { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeQuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeH264QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeH265QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: { VkVideoDecodeCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -33222,6 +34129,15 @@ static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversio out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: + { + VkVideoEncodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -33250,6 +34166,45 @@ static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCap { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeQuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeQuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeQuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->maxQuantizationMapExtent = in_ext->maxQuantizationMapExtent; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->minQpDelta = in_ext->minQpDelta; + out_ext->maxQpDelta = in_ext->maxQpDelta; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->minQpDelta = in_ext->minQpDelta; + out_ext->maxQpDelta = in_ext->maxQpDelta; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->minQIndexDelta = in_ext->minQIndexDelta; + out_ext->maxQIndexDelta = in_ext->maxQIndexDelta; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: { VkVideoDecodeCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR); @@ -33347,6 +34302,38 @@ static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCap out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: + { + VkVideoEncodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR); + const VkVideoEncodeAV1CapabilitiesKHR *in_ext = (const VkVideoEncodeAV1CapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + out_ext->flags = in_ext->flags; + out_ext->maxLevel = in_ext->maxLevel; + out_ext->codedPictureAlignment = in_ext->codedPictureAlignment; + out_ext->maxTiles = in_ext->maxTiles; + out_ext->minTileSize = in_ext->minTileSize; + out_ext->maxTileSize = in_ext->maxTileSize; + out_ext->superblockSizes = in_ext->superblockSizes; + out_ext->maxSingleReferenceCount = in_ext->maxSingleReferenceCount; + out_ext->singleReferenceNameMask = in_ext->singleReferenceNameMask; + out_ext->maxUnidirectionalCompoundReferenceCount = in_ext->maxUnidirectionalCompoundReferenceCount; + out_ext->maxUnidirectionalCompoundGroup1ReferenceCount = in_ext->maxUnidirectionalCompoundGroup1ReferenceCount; + out_ext->unidirectionalCompoundReferenceNameMask = in_ext->unidirectionalCompoundReferenceNameMask; + out_ext->maxBidirectionalCompoundReferenceCount = in_ext->maxBidirectionalCompoundReferenceCount; + out_ext->maxBidirectionalCompoundGroup1ReferenceCount = in_ext->maxBidirectionalCompoundGroup1ReferenceCount; + out_ext->maxBidirectionalCompoundGroup2ReferenceCount = in_ext->maxBidirectionalCompoundGroup2ReferenceCount; + out_ext->bidirectionalCompoundReferenceNameMask = in_ext->bidirectionalCompoundReferenceNameMask; + out_ext->maxTemporalLayerCount = in_ext->maxTemporalLayerCount; + out_ext->maxSpatialLayerCount = in_ext->maxSpatialLayerCount; + out_ext->maxOperatingPoints = in_ext->maxOperatingPoints; + out_ext->minQIndex = in_ext->minQIndex; + out_ext->maxQIndex = in_ext->maxQIndex; + out_ext->prefersGopRemainingFrames = in_ext->prefersGopRemainingFrames; + out_ext->requiresGopRemainingFrames = in_ext->requiresGopRemainingFrames; + out_ext->stdSyntaxFlags = in_ext->stdSyntaxFlags; + out_header = (void *)out_ext; + break; + } default: break; } @@ -33397,6 +34384,15 @@ static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host( out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: + { + VkVideoEncodeAV1QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -33451,6 +34447,29 @@ static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32( out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: + { + VkVideoEncodeAV1QualityLevelPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR); + const VkVideoEncodeAV1QualityLevelPropertiesKHR *in_ext = (const VkVideoEncodeAV1QualityLevelPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; + out_ext->preferredRateControlFlags = in_ext->preferredRateControlFlags; + out_ext->preferredGopFrameCount = in_ext->preferredGopFrameCount; + out_ext->preferredKeyFramePeriod = in_ext->preferredKeyFramePeriod; + out_ext->preferredConsecutiveBipredictiveFrameCount = in_ext->preferredConsecutiveBipredictiveFrameCount; + out_ext->preferredTemporalLayerCount = in_ext->preferredTemporalLayerCount; + out_ext->preferredConstantQIndex = in_ext->preferredConstantQIndex; + out_ext->preferredMaxSingleReferenceCount = in_ext->preferredMaxSingleReferenceCount; + out_ext->preferredSingleReferenceNameMask = in_ext->preferredSingleReferenceNameMask; + out_ext->preferredMaxUnidirectionalCompoundReferenceCount = in_ext->preferredMaxUnidirectionalCompoundReferenceCount; + out_ext->preferredMaxUnidirectionalCompoundGroup1ReferenceCount = in_ext->preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + out_ext->preferredUnidirectionalCompoundReferenceNameMask = in_ext->preferredUnidirectionalCompoundReferenceNameMask; + out_ext->preferredMaxBidirectionalCompoundReferenceCount = in_ext->preferredMaxBidirectionalCompoundReferenceCount; + out_ext->preferredMaxBidirectionalCompoundGroup1ReferenceCount = in_ext->preferredMaxBidirectionalCompoundGroup1ReferenceCount; + out_ext->preferredMaxBidirectionalCompoundGroup2ReferenceCount = in_ext->preferredMaxBidirectionalCompoundGroup2ReferenceCount; + out_ext->preferredBidirectionalCompoundReferenceNameMask = in_ext->preferredBidirectionalCompoundReferenceNameMask; + out_header = (void *)out_ext; + break; + } default: break; } @@ -33491,18 +34510,59 @@ static inline void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(stru } }

-static inline void convert_VkVideoFormatPropertiesKHR_win32_to_host(const VkVideoFormatPropertiesKHR32 *in, VkVideoFormatPropertiesKHR *out) +static inline void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, VkVideoFormatPropertiesKHR *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return;

out->sType = in->sType; out->pNext = NULL; - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + { + VkVideoFormatQuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: + { + VkVideoFormatH265QuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + { + VkVideoFormatAV1QuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } }

static inline void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out) { + const VkBaseInStructure *in_header; + VkBaseOutStructure32 *out_header = (void *)out; + if (!in) return;

out->format = in->format; @@ -33511,6 +34571,42 @@ static inline void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVide out->imageType = in->imageType; out->imageTiling = in->imageTiling; out->imageUsageFlags = in->imageUsageFlags; + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + { + VkVideoFormatQuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR); + const VkVideoFormatQuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatQuantizationMapPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: + { + VkVideoFormatH265QuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR); + const VkVideoFormatH265QuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatH265QuantizationMapPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->compatibleCtbSizes = in_ext->compatibleCtbSizes; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + { + VkVideoFormatAV1QuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR); + const VkVideoFormatAV1QuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatAV1QuantizationMapPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->compatibleSuperblockSizes = in_ext->compatibleSuperblockSizes; + out_header = (void *)out_ext; + break; + } + default: + break; + } + } }

static inline VkVideoFormatPropertiesKHR *convert_VkVideoFormatPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, uint32_t count) @@ -33523,7 +34619,7 @@ static inline VkVideoFormatPropertiesKHR *convert_VkVideoFormatPropertiesKHR_arr out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkVideoFormatPropertiesKHR_win32_to_host(&in[i], &out[i]); + convert_VkVideoFormatPropertiesKHR_win32_to_host(ctx, &in[i], &out[i]); }

return out; @@ -35077,8 +36173,11 @@ static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win32_to_host(s return out; }

-static inline void convert_VkHdrMetadataEXT_win32_to_host(const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out) +static inline void convert_VkHdrMetadataEXT_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return;

out->sType = in->sType; @@ -35091,8 +36190,28 @@ static inline void convert_VkHdrMetadataEXT_win32_to_host(const VkHdrMetadataEXT out->minLuminance = in->minLuminance; out->maxContentLightLevel = in->maxContentLightLevel; out->maxFrameAverageLightLevel = in->maxFrameAverageLightLevel; - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: + { + VkHdrVividDynamicMetadataHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkHdrVividDynamicMetadataHUAWEI32 *in_ext = (const VkHdrVividDynamicMetadataHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI; + out_ext->pNext = NULL; + out_ext->dynamicMetadataSize = in_ext->dynamicMetadataSize; + out_ext->pDynamicMetadata = UlongToPtr(in_ext->pDynamicMetadata); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } }

static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count) @@ -35105,7 +36224,7 @@ static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_ho out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkHdrMetadataEXT_win32_to_host(&in[i], &out[i]); + convert_VkHdrMetadataEXT_win32_to_host(ctx, &in[i], &out[i]); }

return out; @@ -42634,11 +43753,15 @@ static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args) VkResult result; } *params = args; VkCuModuleCreateInfoNVX pCreateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx;

TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);

- convert_VkCuModuleCreateInfoNVX_win32_to_host((const VkCuModuleCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + init_conversion_context(ctx); + convert_VkCuModuleCreateInfoNVX_win32_to_host(ctx, (const VkCuModuleCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, (VkCuModuleNVX *)UlongToPtr(params->pModule)); + free_conversion_context(ctx); return STATUS_SUCCESS; }

@@ -47723,7 +48846,6 @@ static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsEXT(void *args) convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(ctx, (const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host); convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host); wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pInfo_host, &pMemoryRequirements_host); - convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_host_to_win32(&pInfo_host, (const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *)UlongToPtr(params->pInfo)); convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -48141,6 +49263,35 @@ static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetImageViewHandle64NVX(void *args) +{ + struct vkGetImageViewHandle64NVX_params *params = args; + + TRACE("%p, %p\n", params->device, params->pInfo); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandle64NVX(wine_device_from_handle(params->device)->host_device, params->pInfo); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetImageViewHandle64NVX(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + uint64_t result; + } *params = args; + VkImageViewHandleInfoNVX pInfo_host; + + TRACE("%#x, %#x\n", params->device, params->pInfo); + + convert_VkImageViewHandleInfoNVX_win32_to_host((const VkImageViewHandleInfoNVX32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewHandle64NVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pInfo_host); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args) { @@ -48389,6 +49540,41 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(void *arg return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(void *args) +{ + struct vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV_params *params = args; + + TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties); + + params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->host_physical_device, params->pPropertyCount, params->pProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(void *args) +{ + struct + { + PTR32 physicalDevice; + PTR32 pPropertyCount; + PTR32 pProperties; + VkResult result; + } *params = args; + VkCooperativeMatrixFlexibleDimensionsPropertiesNV *pProperties_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties); + + init_conversion_context(ctx); + pProperties_host = convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_win32_to_host(ctx, (VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); + params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->host_physical_device, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host); + convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_host_to_win32(pProperties_host, (VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(void *args) { @@ -52829,6 +54015,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_pipeline_protected_access", "VK_EXT_pipeline_robustness", "VK_EXT_post_depth_coverage", + "VK_EXT_present_mode_fifo_latest_ready", "VK_EXT_primitive_topology_list_restart", "VK_EXT_primitives_generated_query", "VK_EXT_private_data", @@ -52862,6 +54049,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_transform_feedback", "VK_EXT_validation_cache", "VK_EXT_vertex_attribute_divisor", + "VK_EXT_vertex_attribute_robustness", "VK_EXT_vertex_input_dynamic_state", "VK_EXT_ycbcr_2plane_444_formats", "VK_EXT_ycbcr_image_arrays", @@ -52869,6 +54057,7 @@ static const char * const vk_device_extensions[] = "VK_GOOGLE_hlsl_functionality1", "VK_GOOGLE_user_type", "VK_HUAWEI_cluster_culling_shader", + "VK_HUAWEI_hdr_vivid", "VK_HUAWEI_invocation_mask", "VK_HUAWEI_subpass_shading", "VK_IMG_filter_cubic", @@ -52961,8 +54150,10 @@ static const char * const vk_device_extensions[] = "VK_KHR_video_decode_h264", "VK_KHR_video_decode_h265", "VK_KHR_video_decode_queue", + "VK_KHR_video_encode_av1", "VK_KHR_video_encode_h264", "VK_KHR_video_encode_h265", + "VK_KHR_video_encode_quantization_map", "VK_KHR_video_encode_queue", "VK_KHR_video_maintenance1", "VK_KHR_video_queue", @@ -52977,6 +54168,7 @@ static const char * const vk_device_extensions[] = "VK_NV_command_buffer_inheritance", "VK_NV_compute_shader_derivatives", "VK_NV_cooperative_matrix", + "VK_NV_cooperative_matrix2", "VK_NV_copy_memory_indirect", "VK_NV_corner_sampled_image", "VK_NV_coverage_reduction_mode", @@ -53594,6 +54786,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetImageSubresourceLayout2EXT, thunk64_vkGetImageSubresourceLayout2KHR, thunk64_vkGetImageViewAddressNVX, + thunk64_vkGetImageViewHandle64NVX, thunk64_vkGetImageViewHandleNVX, thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT, thunk64_vkGetLatencyTimingsNV, @@ -53602,6 +54795,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetPerformanceParameterINTEL, thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, + thunk64_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, thunk64_vkGetPhysicalDeviceExternalBufferProperties, @@ -54215,6 +55409,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetImageSubresourceLayout2EXT, thunk32_vkGetImageSubresourceLayout2KHR, thunk32_vkGetImageViewAddressNVX, + thunk32_vkGetImageViewHandle64NVX, thunk32_vkGetImageViewHandleNVX, thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT, thunk32_vkGetLatencyTimingsNV, @@ -54223,6 +55418,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetPerformanceParameterINTEL, thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, + thunk32_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, thunk32_vkGetPhysicalDeviceExternalBufferProperties, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 82c23d3dde4..2fb584ae2ee 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -524,6 +524,7 @@ struct vulkan_device_funcs void (*p_vkGetImageSubresourceLayout2EXT)(VkDevice, VkImage, const VkImageSubresource2KHR *, VkSubresourceLayout2KHR *); void (*p_vkGetImageSubresourceLayout2KHR)(VkDevice, VkImage, const VkImageSubresource2KHR *, VkSubresourceLayout2KHR *); VkResult (*p_vkGetImageViewAddressNVX)(VkDevice, VkImageView, VkImageViewAddressPropertiesNVX *); + uint64_t (*p_vkGetImageViewHandle64NVX)(VkDevice, const VkImageViewHandleInfoNVX *); uint32_t (*p_vkGetImageViewHandleNVX)(VkDevice, const VkImageViewHandleInfoNVX *); VkResult (*p_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageViewCaptureDescriptorDataInfoEXT *, void *); void (*p_vkGetLatencyTimingsNV)(VkDevice, VkSwapchainKHR, VkGetLatencyMarkerInfoNV *); @@ -641,6 +642,7 @@ struct vulkan_instance_funcs VkResult (*p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice, uint32_t, uint32_t *, VkPerformanceCounterKHR *, VkPerformanceCounterDescriptionKHR *); VkResult (*p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); VkResult (*p_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); + VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *); VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *); VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *); void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *); @@ -1130,6 +1132,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetImageSubresourceLayout2EXT) \ USE_VK_FUNC(vkGetImageSubresourceLayout2KHR) \ USE_VK_FUNC(vkGetImageViewAddressNVX) \ + USE_VK_FUNC(vkGetImageViewHandle64NVX) \ USE_VK_FUNC(vkGetImageViewHandleNVX) \ USE_VK_FUNC(vkGetImageViewOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetLatencyTimingsNV) \ @@ -1244,6 +1247,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) \ USE_VK_FUNC(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR) \ + USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \ diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index 2e77e6f042e..67733baa0a6 100644 --- a/dlls/winevulkan/winevulkan.json +++ b/dlls/winevulkan/winevulkan.json @@ -2,6 +2,6 @@ "file_format_version": "1.0.0", "ICD": { "library_path": ".\winevulkan.dll", - "api_version": "1.3.296" + "api_version": "1.3.302" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 8f1afc519ca..e7f146d2210 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -108,9 +108,9 @@ #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" #define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1 #define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback" -#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1 +#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 2 #define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import" -#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2 +#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 3 #define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle" #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" @@ -538,6 +538,8 @@ #define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart" #define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2 #define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2" +#define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 +#define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_EXT_present_mode_fifo_latest_ready" #define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 3 #define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading" #define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1 @@ -670,6 +672,8 @@ #define VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_KHR_compute_shader_derivatives" #define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1 #define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" +#define VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME "VK_KHR_video_encode_av1" #define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 #define VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_video_maintenance1" #define VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION 1 @@ -704,6 +708,8 @@ #define VK_KHR_MAINTENANCE_6_EXTENSION_NAME "VK_KHR_maintenance6" #define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION 1 #define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation" +#define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION 2 +#define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME "VK_KHR_video_encode_quantization_map" #define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1 #define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains" #define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION 1 @@ -722,6 +728,12 @@ #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control" #define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1 #define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control" +#define VK_HUAWEI_HDR_VIVID_SPEC_VERSION 1 +#define VK_HUAWEI_HDR_VIVID_EXTENSION_NAME "VK_HUAWEI_hdr_vivid" +#define VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION 1 +#define VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME "VK_NV_cooperative_matrix2" +#define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_vertex_attribute_robustness" #define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 @@ -786,6 +798,8 @@ #define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25 #define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 #define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode" +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_encode" #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 #define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure" #define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1 @@ -812,7 +826,7 @@ #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0) #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0) #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0) -#define VK_HEADER_VERSION 296 +#define VK_HEADER_VERSION 302 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; #define VK_USE_64_BIT_PTR_DEFINES 0 @@ -846,6 +860,7 @@ #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) #define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) @@ -1114,6 +1129,10 @@ typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; typedef VkFlags VkVideoDecodeFlagsKHR; typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; typedef VkFlags VkVideoDecodeUsageFlagsKHR; +typedef VkFlags VkVideoEncodeAV1CapabilityFlagsKHR; +typedef VkFlags VkVideoEncodeAV1RateControlFlagsKHR; +typedef VkFlags VkVideoEncodeAV1StdFlagsKHR; +typedef VkFlags VkVideoEncodeAV1SuperblockSizeFlagsKHR; typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; typedef VkFlags VkVideoEncodeContentFlagsKHR; typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; @@ -1149,7 +1168,7 @@ typedef enum StdVideoAV1ChromaSamplePosition typedef enum StdVideoAV1ColorPrimaries { STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2, + STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED = 2, STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, @@ -1160,6 +1179,7 @@ typedef enum StdVideoAV1ColorPrimaries STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7fffffff, } StdVideoAV1ColorPrimaries;

@@ -3098,6 +3118,8 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ull; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ull; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ull; typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;

typedef enum VkFragmentShadingRateCombinerOpKHR @@ -3324,6 +3346,7 @@ typedef enum VkImageLayout VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, + VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR = 1000553000, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, @@ -3374,6 +3397,8 @@ typedef enum VkImageUsageFlagBits VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = 0x00400000, + VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000, + VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkImageUsageFlagBits; @@ -3948,10 +3973,10 @@ typedef enum VkPipelineCreateFlagBits VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000, VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, @@ -4209,6 +4234,7 @@ typedef enum VkPresentModeKHR VK_PRESENT_MODE_MAILBOX_KHR = 1, VK_PRESENT_MODE_FIFO_KHR = 2, VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = 1000361000, VK_PRESENT_MODE_KHR_MAX_ENUM = 0x7fffffff, } VkPresentModeKHR;

@@ -4822,6 +4848,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, + VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX = 1000029004, VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR = 1000038000, @@ -4867,7 +4894,6 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, - VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, @@ -5330,6 +5356,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = 1000361000, VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, @@ -5487,6 +5514,17 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR = 1000513000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000513001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR = 1000513002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR = 1000513003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR = 1000513004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR = 1000513005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR = 1000513006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR = 1000513007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR = 1000513008, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR = 1000513009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR = 1000513010, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, @@ -5514,6 +5552,16 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR = 1000553002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000553005, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553007, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR = 1000553009, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV = 1000559000, @@ -5539,6 +5587,12 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000, + VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -5547,7 +5601,6 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, - VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, @@ -5619,6 +5672,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, @@ -5947,6 +6001,7 @@ typedef enum VkVideoCodecOperationFlagBitsKHR VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004, VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR = 0x00010000, VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000, + VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR = 0x00040000, VK_VIDEO_CODEC_OPERATION_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoCodecOperationFlagBitsKHR;

@@ -5991,10 +6046,64 @@ typedef enum VkVideoDecodeUsageFlagBitsKHR VK_VIDEO_DECODE_USAGE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoDecodeUsageFlagBitsKHR;

+typedef enum VkVideoEncodeAV1CapabilityFlagBitsKHR +{ + VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_AV1_CAPABILITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeAV1CapabilityFlagBitsKHR; + +typedef enum VkVideoEncodeAV1PredictionModeKHR +{ + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR = 0, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR = 1, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR = 2, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR = 3, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeAV1PredictionModeKHR; + +typedef enum VkVideoEncodeAV1RateControlFlagBitsKHR +{ + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeAV1RateControlFlagBitsKHR; + +typedef enum VkVideoEncodeAV1RateControlGroupKHR +{ + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR = 0, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR = 1, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR = 2, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeAV1RateControlGroupKHR; + +typedef enum VkVideoEncodeAV1StdFlagBitsKHR +{ + VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_AV1_STD_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeAV1StdFlagBitsKHR; + +typedef enum VkVideoEncodeAV1SuperblockSizeFlagBitsKHR +{ + VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeAV1SuperblockSizeFlagBitsKHR; + typedef enum VkVideoEncodeCapabilityFlagBitsKHR { VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001, VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR = 0x00000008, VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeCapabilityFlagBitsKHR;

@@ -6015,6 +6124,13 @@ typedef enum VkVideoEncodeFeedbackFlagBitsKHR VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeFeedbackFlagBitsKHR;

+typedef enum VkVideoEncodeFlagBitsKHR +{ + VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeFlagBitsKHR; + typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR { VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, @@ -6026,6 +6142,7 @@ typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 0x00000080, VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000200, VK_VIDEO_ENCODE_H2_64_CAPABILITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeH264CapabilityFlagBitsKHR;

@@ -6076,6 +6193,7 @@ typedef enum VkVideoEncodeH265CapabilityFlagBitsKHR VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR = 0x00000080, VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR = 0x00000100, VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000400, VK_VIDEO_ENCODE_H2_65_CAPABILITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeH265CapabilityFlagBitsKHR;

@@ -6166,9 +6284,17 @@ typedef enum VkVideoSessionCreateFlagBitsKHR VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR = 0x00000002, VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 0x00000004, + VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000008, + VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x00000010, VK_VIDEO_SESSION_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoSessionCreateFlagBitsKHR;

+typedef enum VkVideoSessionParametersCreateFlagBitsKHR +{ + VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR = 0x00000001, + VK_VIDEO_SESSION_PARAMETERS_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoSessionParametersCreateFlagBitsKHR; + typedef enum VkViewportCoordinateSwizzleNV { VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, @@ -6393,6 +6519,70 @@ typedef struct StdVideoDecodeH265ReferenceInfoFlags uint32_t unused_for_reference:1; } StdVideoDecodeH265ReferenceInfoFlags;

+typedef struct StdVideoEncodeAV1DecoderModelInfo +{ + uint8_t buffer_delay_length_minus_1; + uint8_t buffer_removal_time_length_minus_1; + uint8_t frame_presentation_time_length_minus_1; + uint8_t reserved1; + uint32_t num_units_in_decoding_tick; +} StdVideoEncodeAV1DecoderModelInfo; + +typedef struct StdVideoEncodeAV1ExtensionHeader +{ + uint8_t temporal_id; + uint8_t spatial_id; +} StdVideoEncodeAV1ExtensionHeader; + +typedef struct StdVideoEncodeAV1OperatingPointInfoFlags +{ + uint32_t decoder_model_present_for_this_op:1; + uint32_t low_delay_mode_flag:1; + uint32_t initial_display_delay_present_for_this_op:1; + uint32_t reserved:29; +} StdVideoEncodeAV1OperatingPointInfoFlags; + +typedef struct StdVideoEncodeAV1PictureInfoFlags +{ + uint32_t error_resilient_mode:1; + uint32_t disable_cdf_update:1; + uint32_t use_superres:1; + uint32_t render_and_frame_size_different:1; + uint32_t allow_screen_content_tools:1; + uint32_t is_filter_switchable:1; + uint32_t force_integer_mv:1; + uint32_t frame_size_override_flag:1; + uint32_t buffer_removal_time_present_flag:1; + uint32_t allow_intrabc:1; + uint32_t frame_refs_short_signaling:1; + uint32_t allow_high_precision_mv:1; + uint32_t is_motion_mode_switchable:1; + uint32_t use_ref_frame_mvs:1; + uint32_t disable_frame_end_update_cdf:1; + uint32_t allow_warped_motion:1; + uint32_t reduced_tx_set:1; + uint32_t skip_mode_present:1; + uint32_t delta_q_present:1; + uint32_t delta_lf_present:1; + uint32_t delta_lf_multi:1; + uint32_t segmentation_enabled:1; + uint32_t segmentation_update_map:1; + uint32_t segmentation_temporal_update:1; + uint32_t segmentation_update_data:1; + uint32_t UsesLr:1; + uint32_t usesChromaLr:1; + uint32_t show_frame:1; + uint32_t showable_frame:1; + uint32_t reserved:3; +} StdVideoEncodeAV1PictureInfoFlags; + +typedef struct StdVideoEncodeAV1ReferenceInfoFlags +{ + uint32_t disable_frame_end_update_cdf:1; + uint32_t segmentation_enabled:1; + uint32_t reserved:30; +} StdVideoEncodeAV1ReferenceInfoFlags; + typedef struct StdVideoEncodeH264PictureInfoFlags { uint32_t IdrPicFlag:1; @@ -7380,6 +7570,22 @@ typedef struct VkConformanceVersion } VkConformanceVersion; typedef VkConformanceVersion VkConformanceVersionKHR;

+typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV +{ + VkStructureType sType; + void *pNext; + uint32_t MGranularity; + uint32_t NGranularity; + uint32_t KGranularity; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; + uint32_t workgroupInvocations; +} VkCooperativeMatrixFlexibleDimensionsPropertiesNV; + typedef struct VkCooperativeMatrixPropertiesKHR { VkStructureType sType; @@ -7499,6 +7705,13 @@ typedef struct VkCuModuleCreateInfoNVX const void *pData; } VkCuModuleCreateInfoNVX;

+typedef struct VkCuModuleTexturingModeCreateInfoNVX +{ + VkStructureType sType; + const void *pNext; + VkBool32 use64bitTexturing; +} VkCuModuleTexturingModeCreateInfoNVX; + typedef struct VkCudaFunctionCreateInfoNV { VkStructureType sType; @@ -8287,7 +8500,7 @@ typedef struct VkGeneratedCommandsInfoEXT typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT { VkStructureType sType; - void *pNext; + const void *pNext; VkIndirectExecutionSetEXT WINE_VK_ALIGN(8) indirectExecutionSet; VkIndirectCommandsLayoutEXT WINE_VK_ALIGN(8) indirectCommandsLayout; uint32_t maxSequenceCount; @@ -8353,6 +8566,14 @@ typedef struct VkGraphicsPipelineLibraryCreateInfoEXT VkGraphicsPipelineLibraryFlagsEXT flags; } VkGraphicsPipelineLibraryCreateInfoEXT;

+typedef struct VkHdrVividDynamicMetadataHUAWEI +{ + VkStructureType sType; + const void *pNext; + size_t dynamicMetadataSize; + const void *pDynamicMetadata; +} VkHdrVividDynamicMetadataHUAWEI; + typedef struct VkHostImageCopyDevicePerformanceQueryEXT { VkStructureType sType; @@ -8975,14 +9196,6 @@ typedef struct VkMultisampledRenderToSingleSampledInfoEXT VkSampleCountFlagBits rasterizationSamples; } VkMultisampledRenderToSingleSampledInfoEXT;

-typedef struct VkMultiviewPerViewAttributesInfoNVX -{ - VkStructureType sType; - const void *pNext; - VkBool32 perViewAttributes; - VkBool32 perViewAttributesPositionXOnly; -} VkMultiviewPerViewAttributesInfoNVX; - typedef struct VkMutableDescriptorTypeListEXT { uint32_t descriptorTypeCount; @@ -9365,6 +9578,28 @@ typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT VkBool32 conservativeRasterizationPostDepthCoverage; } VkPhysicalDeviceConservativeRasterizationPropertiesEXT;

+typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV +{ + VkStructureType sType; + void *pNext; + VkBool32 cooperativeMatrixWorkgroupScope; + VkBool32 cooperativeMatrixFlexibleDimensions; + VkBool32 cooperativeMatrixReductions; + VkBool32 cooperativeMatrixConversions; + VkBool32 cooperativeMatrixPerElementOperations; + VkBool32 cooperativeMatrixTensorAddressing; + VkBool32 cooperativeMatrixBlockLoads; +} VkPhysicalDeviceCooperativeMatrix2FeaturesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV +{ + VkStructureType sType; + void *pNext; + uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; + uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension; + uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory; +} VkPhysicalDeviceCooperativeMatrix2PropertiesNV; + typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR { VkStructureType sType; @@ -10146,6 +10381,13 @@ typedef struct VkPhysicalDeviceGroupProperties } VkPhysicalDeviceGroupProperties; typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;

+typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI +{ + VkStructureType sType; + void *pNext; + VkBool32 hdrVivid; +} VkPhysicalDeviceHdrVividFeaturesHUAWEI; + typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT { VkStructureType sType; @@ -10965,6 +11207,13 @@ typedef struct VkPhysicalDevicePresentIdFeaturesKHR VkBool32 presentId; } VkPhysicalDevicePresentIdFeaturesKHR;

+typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 presentModeFifoLatestReady; +} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; + typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { VkStructureType sType; @@ -11841,6 +12090,13 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR VkBool32 supportsNonZeroFirstInstance; } VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR;

+typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 vertexAttributeRobustness; +} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { VkStructureType sType; @@ -11848,6 +12104,20 @@ typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT VkBool32 vertexInputDynamicState; } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;

+typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 videoEncodeAV1; +} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR; + +typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 videoEncodeQuantizationMap; +} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + typedef struct VkPhysicalDeviceVideoFormatInfoKHR { VkStructureType sType; @@ -13787,6 +14057,127 @@ typedef struct VkVideoDecodeUsageInfoKHR VkVideoDecodeUsageFlagsKHR videoUsageHints; } VkVideoDecodeUsageInfoKHR;

+typedef struct VkVideoEncodeAV1CapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + VkVideoEncodeAV1CapabilityFlagsKHR flags; + StdVideoAV1Level maxLevel; + VkExtent2D codedPictureAlignment; + VkExtent2D maxTiles; + VkExtent2D minTileSize; + VkExtent2D maxTileSize; + VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes; + uint32_t maxSingleReferenceCount; + uint32_t singleReferenceNameMask; + uint32_t maxUnidirectionalCompoundReferenceCount; + uint32_t maxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t unidirectionalCompoundReferenceNameMask; + uint32_t maxBidirectionalCompoundReferenceCount; + uint32_t maxBidirectionalCompoundGroup1ReferenceCount; + uint32_t maxBidirectionalCompoundGroup2ReferenceCount; + uint32_t bidirectionalCompoundReferenceNameMask; + uint32_t maxTemporalLayerCount; + uint32_t maxSpatialLayerCount; + uint32_t maxOperatingPoints; + uint32_t minQIndex; + uint32_t maxQIndex; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeAV1CapabilitiesKHR; + +typedef struct VkVideoEncodeAV1FrameSizeKHR +{ + uint32_t intraFrameSize; + uint32_t predictiveFrameSize; + uint32_t bipredictiveFrameSize; +} VkVideoEncodeAV1FrameSizeKHR; + +typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingIntra; + uint32_t gopRemainingPredictive; + uint32_t gopRemainingBipredictive; +} VkVideoEncodeAV1GopRemainingFrameInfoKHR; + +typedef struct VkVideoEncodeAV1ProfileInfoKHR +{ + VkStructureType sType; + const void *pNext; + StdVideoAV1Profile stdProfile; +} VkVideoEncodeAV1ProfileInfoKHR; + +typedef struct VkVideoEncodeAV1QIndexKHR +{ + uint32_t intraQIndex; + uint32_t predictiveQIndex; + uint32_t bipredictiveQIndex; +} VkVideoEncodeAV1QIndexKHR; + +typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredKeyFramePeriod; + uint32_t preferredConsecutiveBipredictiveFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeAV1QIndexKHR preferredConstantQIndex; + uint32_t preferredMaxSingleReferenceCount; + uint32_t preferredSingleReferenceNameMask; + uint32_t preferredMaxUnidirectionalCompoundReferenceCount; + uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredUnidirectionalCompoundReferenceNameMask; + uint32_t preferredMaxBidirectionalCompoundReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount; + uint32_t preferredBidirectionalCompoundReferenceNameMask; +} VkVideoEncodeAV1QualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + int32_t minQIndexDelta; + int32_t maxQIndexDelta; +} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR; + +typedef struct VkVideoEncodeAV1RateControlInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkVideoEncodeAV1RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t keyFramePeriod; + uint32_t consecutiveBipredictiveFrameCount; + uint32_t temporalLayerCount; +} VkVideoEncodeAV1RateControlInfoKHR; + +typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkBool32 useMinQIndex; + VkVideoEncodeAV1QIndexKHR minQIndex; + VkBool32 useMaxQIndex; + VkVideoEncodeAV1QIndexKHR maxQIndex; + VkBool32 useMaxFrameSize; + VkVideoEncodeAV1FrameSizeKHR maxFrameSize; +} VkVideoEncodeAV1RateControlLayerInfoKHR; + +typedef struct VkVideoEncodeAV1SessionCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkBool32 useMaxLevel; + StdVideoAV1Level maxLevel; +} VkVideoEncodeAV1SessionCreateInfoKHR; + typedef struct VkVideoEncodeCapabilitiesKHR { VkStructureType sType; @@ -13865,6 +14256,14 @@ typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR VkBool32 preferredStdEntropyCodingModeFlag; } VkVideoEncodeH264QualityLevelPropertiesKHR;

+typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH264QuantizationMapCapabilitiesKHR; + typedef struct VkVideoEncodeH264RateControlInfoKHR { VkStructureType sType; @@ -13981,6 +14380,14 @@ typedef struct VkVideoEncodeH265QualityLevelPropertiesKHR uint32_t preferredMaxL1ReferenceCount; } VkVideoEncodeH265QualityLevelPropertiesKHR;

+typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH265QuantizationMapCapabilitiesKHR; + typedef struct VkVideoEncodeH265RateControlInfoKHR { VkStructureType sType; @@ -14048,6 +14455,28 @@ typedef struct VkVideoEncodeQualityLevelPropertiesKHR uint32_t preferredRateControlLayerCount; } VkVideoEncodeQualityLevelPropertiesKHR;

+typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + VkExtent2D maxQuantizationMapExtent; +} VkVideoEncodeQuantizationMapCapabilitiesKHR; + +typedef struct VkVideoEncodeQuantizationMapInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkImageView WINE_VK_ALIGN(8) quantizationMap; + VkExtent2D quantizationMapExtent; +} VkVideoEncodeQuantizationMapInfoKHR; + +typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkExtent2D quantizationMapTexelSize; +} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + typedef struct VkVideoEncodeRateControlLayerInfoKHR { VkStructureType sType; @@ -14088,6 +14517,20 @@ typedef struct VkVideoEndCodingInfoKHR VkVideoEndCodingFlagsKHR flags; } VkVideoEndCodingInfoKHR;

+typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes; +} VkVideoFormatAV1QuantizationMapPropertiesKHR; + +typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes; +} VkVideoFormatH265QuantizationMapPropertiesKHR; + typedef struct VkVideoFormatPropertiesKHR { VkStructureType sType; @@ -14100,6 +14543,13 @@ typedef struct VkVideoFormatPropertiesKHR VkImageUsageFlags imageUsageFlags; } VkVideoFormatPropertiesKHR;

+typedef struct VkVideoFormatQuantizationMapPropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkExtent2D quantizationMapTexelSize; +} VkVideoFormatQuantizationMapPropertiesKHR; + typedef struct VkVideoInlineQueryInfoKHR { VkStructureType sType; @@ -14445,6 +14895,58 @@ typedef struct StdVideoDecodeH265ReferenceInfo int32_t PicOrderCntVal; } StdVideoDecodeH265ReferenceInfo;

+typedef struct StdVideoEncodeAV1OperatingPointInfo +{ + StdVideoEncodeAV1OperatingPointInfoFlags flags; + uint16_t operating_point_idc; + uint8_t seq_level_idx; + uint8_t seq_tier; + uint32_t decoder_buffer_delay; + uint32_t encoder_buffer_delay; + uint8_t initial_display_delay_minus_1; +} StdVideoEncodeAV1OperatingPointInfo; + +typedef struct StdVideoEncodeAV1PictureInfo +{ + StdVideoEncodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t frame_presentation_time; + uint32_t current_frame_id; + uint8_t order_hint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t coded_denom; + uint16_t render_width_minus_1; + uint16_t render_height_minus_1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME]; + uint8_t reserved1[3]; + uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME]; + const StdVideoAV1TileInfo *pTileInfo; + const StdVideoAV1Quantization *pQuantization; + const StdVideoAV1Segmentation *pSegmentation; + const StdVideoAV1LoopFilter *pLoopFilter; + const StdVideoAV1CDEF *pCDEF; + const StdVideoAV1LoopRestoration *pLoopRestoration; + const StdVideoAV1GlobalMotion *pGlobalMotion; + const StdVideoEncodeAV1ExtensionHeader *pExtensionHeader; + const uint32_t *pBufferRemovalTimes; +} StdVideoEncodeAV1PictureInfo; + +typedef struct StdVideoEncodeAV1ReferenceInfo +{ + StdVideoEncodeAV1ReferenceInfoFlags flags; + uint32_t RefFrameId; + StdVideoAV1FrameType frame_type; + uint8_t OrderHint; + uint8_t reserved1[3]; + const StdVideoEncodeAV1ExtensionHeader *pExtensionHeader; +} StdVideoEncodeAV1ReferenceInfo; + typedef struct StdVideoEncodeH264ReferenceInfo { StdVideoEncodeH264ReferenceInfoFlags flags; @@ -15706,6 +16208,26 @@ typedef struct VkVideoDecodeInfoKHR const VkVideoReferenceSlotInfoKHR *pReferenceSlots; } VkVideoDecodeInfoKHR;

+typedef struct VkVideoEncodeAV1DpbSlotInfoKHR +{ + VkStructureType sType; + const void *pNext; + const StdVideoEncodeAV1ReferenceInfo *pStdReferenceInfo; +} VkVideoEncodeAV1DpbSlotInfoKHR; + +typedef struct VkVideoEncodeAV1PictureInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkVideoEncodeAV1PredictionModeKHR predictionMode; + VkVideoEncodeAV1RateControlGroupKHR rateControlGroup; + uint32_t constantQIndex; + const StdVideoEncodeAV1PictureInfo *pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + VkBool32 primaryReferenceCdfOnly; + VkBool32 generateObuExtensionHeader; +} VkVideoEncodeAV1PictureInfoKHR; + typedef struct VkVideoEncodeH264DpbSlotInfoKHR { VkStructureType sType; @@ -16158,6 +16680,16 @@ typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR const VkVideoDecodeH265SessionParametersAddInfoKHR *pParametersAddInfo; } VkVideoDecodeH265SessionParametersCreateInfoKHR;

+typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + const StdVideoAV1SequenceHeader *pStdSequenceHeader; + const StdVideoEncodeAV1DecoderModelInfo *pStdDecoderModelInfo; + uint32_t stdOperatingPointCount; + const StdVideoEncodeAV1OperatingPointInfo *pStdOperatingPoints; +} VkVideoEncodeAV1SessionParametersCreateInfoKHR; + typedef struct VkVideoEncodeH264NaluSliceInfoKHR { VkStructureType sType; @@ -16796,6 +17328,7 @@ typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice, VkImage, con typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice, VkImage, const VkImageSubresource2KHR *, VkSubresourceLayout2KHR *); typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2KHR)(VkDevice, VkImage, const VkImageSubresource2KHR *, VkSubresourceLayout2KHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice, VkImageView, VkImageViewAddressPropertiesNVX *); +typedef uint64_t (VKAPI_PTR *PFN_vkGetImageViewHandle64NVX)(VkDevice, const VkImageViewHandleInfoNVX *); typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice, const VkImageViewHandleInfoNVX *); typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageViewCaptureDescriptorDataInfoEXT *, void *); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance, const char *); @@ -16807,6 +17340,7 @@ typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice, VkAcceleratio typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice, const VkPhysicalDeviceExternalBufferInfo *, VkExternalBufferProperties *); @@ -17410,6 +17944,7 @@ void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, cons void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout); void VKAPI_CALL vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout); VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties); +uint64_t VKAPI_CALL vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo); uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo); VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData); PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName); @@ -17421,6 +17956,7 @@ void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStruct VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue); VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); +VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *pProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties); void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties);

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6871

Marvin

12:59 p.m.

New subject: [PATCH 1/1] winevulkan: Update to VK spec version 1.3.302.

Hi,

It looks like your patch introduced the new failures shown below. Please investigate and fix them before resubmitting your patch. If they are not new, fixing them anyway would help a lot. Otherwise please ask for the known failures list to be updated.

The tests also ran into some preexisting test failures. If you know how to fix them that would be helpful. See the TestBot job for the details:

The full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=149830

Your paranoid android.

=== debian11b (64 bit WoW report) ===

user32: win.c:4070: Test failed: Expected active window 0000000000E30156, got 0000000000000000. win.c:4071: Test failed: Expected focus window 0000000000E30156, got 0000000000000000.

Age (days ago)

Last active (days ago)

wine-gitlab@winehq.org

2 comments

3 participants

tags (0)

participants (3)

Georg Lehmann
Georg Lehmann (＠DadSchoorse)
Marvin