[Mesa-dev] [PATCH] radv: get rid of bunch of KHR suffixes
Eric Engestrom
eric.engestrom at intel.com
Tue Jan 8 18:33:24 UTC 2019
On Tuesday, 2019-01-08 14:30:32 +0100, Samuel Pitoiset wrote:
> Signed-off-by: Samuel Pitoiset <samuel.pitoiset at gmail.com>
Acked-by: Eric Engestrom <eric.engestrom at intel.com>
You've inspired me, I'll send the same for anv in a bit ;)
> ---
> src/amd/vulkan/radv_android.c | 18 +--
> src/amd/vulkan/radv_cmd_buffer.c | 4 +-
> src/amd/vulkan/radv_descriptor_set.c | 22 ++--
> src/amd/vulkan/radv_device.c | 176 +++++++++++++--------------
> src/amd/vulkan/radv_formats.c | 82 ++++++-------
> src/amd/vulkan/radv_image.c | 8 +-
> src/amd/vulkan/radv_meta_bufimage.c | 2 +-
> src/amd/vulkan/radv_pass.c | 6 +-
> src/amd/vulkan/radv_pipeline.c | 6 +-
> src/amd/vulkan/radv_private.h | 4 +-
> 10 files changed, 164 insertions(+), 164 deletions(-)
>
> diff --git a/src/amd/vulkan/radv_android.c b/src/amd/vulkan/radv_android.c
> index 1a4425f26a5..9613eabbe87 100644
> --- a/src/amd/vulkan/radv_android.c
> +++ b/src/amd/vulkan/radv_android.c
> @@ -111,7 +111,7 @@ radv_image_from_gralloc(VkDevice device_h,
> VkResult result;
>
> if (gralloc_info->handle->numFds != 1) {
> - return vk_errorf(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
> + return vk_errorf(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE,
> "VkNativeBufferANDROID::handle::numFds is %d, "
> "expected 1", gralloc_info->handle->numFds);
> }
> @@ -126,7 +126,7 @@ radv_image_from_gralloc(VkDevice device_h,
>
> const VkImportMemoryFdInfoKHR import_info = {
> .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
> - .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
> + .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
> .fd = dup(dma_buf),
> };
>
> @@ -230,16 +230,16 @@ VkResult radv_GetSwapchainGrallocUsageANDROID(
> * dEQP-VK.wsi.android.swapchain.*.image_usage to fail.
> */
>
> - const VkPhysicalDeviceImageFormatInfo2KHR image_format_info = {
> - .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
> + const VkPhysicalDeviceImageFormatInfo2 image_format_info = {
> + .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
> .format = format,
> .type = VK_IMAGE_TYPE_2D,
> .tiling = VK_IMAGE_TILING_OPTIMAL,
> .usage = imageUsage,
> };
>
> - VkImageFormatProperties2KHR image_format_props = {
> - .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
> + VkImageFormatProperties2 image_format_props = {
> + .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
> };
>
> /* Check that requested format and usage are supported. */
> @@ -303,7 +303,7 @@ radv_AcquireImageANDROID(
> semaphore_result = radv_ImportSemaphoreFdKHR(device,
> &(VkImportSemaphoreFdInfoKHR) {
> .sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
> - .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR,
> + .flags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
> .fd = semaphore_fd,
> .semaphore = semaphore,
> });
> @@ -314,7 +314,7 @@ radv_AcquireImageANDROID(
> fence_result = radv_ImportFenceFdKHR(device,
> &(VkImportFenceFdInfoKHR) {
> .sType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
> - .flags = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR,
> + .flags = VK_FENCE_IMPORT_TEMPORARY_BIT,
> .fd = fence_fd,
> .fence = fence,
> });
> @@ -351,7 +351,7 @@ radv_QueueSignalReleaseImageANDROID(
> result = radv_GetSemaphoreFdKHR(radv_device_to_handle(queue->device),
> &(VkSemaphoreGetFdInfoKHR) {
> .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
> - .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR,
> + .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
> .semaphore = pWaitSemaphores[i],
> }, &tmp_fd);
> if (result != VK_SUCCESS) {
> diff --git a/src/amd/vulkan/radv_cmd_buffer.c b/src/amd/vulkan/radv_cmd_buffer.c
> index d1b8b3dee6a..4382062c411 100644
> --- a/src/amd/vulkan/radv_cmd_buffer.c
> +++ b/src/amd/vulkan/radv_cmd_buffer.c
> @@ -2787,7 +2787,7 @@ void radv_CmdPushDescriptorSetKHR(
>
> void radv_CmdPushDescriptorSetWithTemplateKHR(
> VkCommandBuffer commandBuffer,
> - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
> + VkDescriptorUpdateTemplate descriptorUpdateTemplate,
> VkPipelineLayout _layout,
> uint32_t set,
> const void* pData)
> @@ -3247,7 +3247,7 @@ VkResult radv_ResetCommandPool(
> void radv_TrimCommandPool(
> VkDevice device,
> VkCommandPool commandPool,
> - VkCommandPoolTrimFlagsKHR flags)
> + VkCommandPoolTrimFlags flags)
> {
> RADV_FROM_HANDLE(radv_cmd_pool, pool, commandPool);
>
> diff --git a/src/amd/vulkan/radv_descriptor_set.c b/src/amd/vulkan/radv_descriptor_set.c
> index 351cc1613ed..526bb77a553 100644
> --- a/src/amd/vulkan/radv_descriptor_set.c
> +++ b/src/amd/vulkan/radv_descriptor_set.c
> @@ -412,7 +412,7 @@ radv_descriptor_set_create(struct radv_device *device,
>
> if (pool->host_memory_base) {
> if (pool->host_memory_end - pool->host_memory_ptr < mem_size)
> - return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
> + return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
>
> set = (struct radv_descriptor_set*)pool->host_memory_ptr;
> pool->host_memory_ptr += mem_size;
> @@ -437,7 +437,7 @@ radv_descriptor_set_create(struct radv_device *device,
>
> if (!pool->host_memory_base && pool->entry_count == pool->max_entry_count) {
> vk_free2(&device->alloc, NULL, set);
> - return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
> + return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
> }
>
> /* try to allocate linearly first, so that we don't spend
> @@ -466,7 +466,7 @@ radv_descriptor_set_create(struct radv_device *device,
>
> if (pool->size - offset < layout_size) {
> vk_free2(&device->alloc, NULL, set);
> - return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
> + return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
> }
> set->bo = pool->bo;
> set->mapped_ptr = (uint32_t*)(pool->mapped_ptr + offset);
> @@ -478,7 +478,7 @@ radv_descriptor_set_create(struct radv_device *device,
> pool->entries[index].set = set;
> pool->entry_count++;
> } else
> - return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
> + return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
> }
>
> if (layout->has_immutable_samplers) {
> @@ -982,9 +982,9 @@ void radv_UpdateDescriptorSets(
> }
>
> VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
> - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo,
> + const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
> const VkAllocationCallbacks *pAllocator,
> - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate)
> + VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
> {
> RADV_FROM_HANDLE(radv_device, device, _device);
> RADV_FROM_HANDLE(radv_descriptor_set_layout, set_layout, pCreateInfo->descriptorSetLayout);
> @@ -1002,7 +1002,7 @@ VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
> templ->bind_point = pCreateInfo->pipelineBindPoint;
>
> for (i = 0; i < entry_count; i++) {
> - const VkDescriptorUpdateTemplateEntryKHR *entry = &pCreateInfo->pDescriptorUpdateEntries[i];
> + const VkDescriptorUpdateTemplateEntry *entry = &pCreateInfo->pDescriptorUpdateEntries[i];
> const struct radv_descriptor_set_binding_layout *binding_layout =
> set_layout->binding + entry->dstBinding;
> const uint32_t buffer_offset = binding_layout->buffer_offset + entry->dstArrayElement;
> @@ -1015,7 +1015,7 @@ VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
> switch (entry->descriptorType) {
> case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
> case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
> - assert(pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR);
> + assert(pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET);
> dst_offset = binding_layout->dynamic_offset_offset + entry->dstArrayElement;
> dst_stride = 0; /* Not used */
> break;
> @@ -1055,7 +1055,7 @@ VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
> }
>
> void radv_DestroyDescriptorUpdateTemplate(VkDevice _device,
> - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
> + VkDescriptorUpdateTemplate descriptorUpdateTemplate,
> const VkAllocationCallbacks *pAllocator)
> {
> RADV_FROM_HANDLE(radv_device, device, _device);
> @@ -1070,7 +1070,7 @@ void radv_DestroyDescriptorUpdateTemplate(VkDevice _device,
> void radv_update_descriptor_set_with_template(struct radv_device *device,
> struct radv_cmd_buffer *cmd_buffer,
> struct radv_descriptor_set *set,
> - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
> + VkDescriptorUpdateTemplate descriptorUpdateTemplate,
> const void *pData)
> {
> RADV_FROM_HANDLE(radv_descriptor_update_template, templ, descriptorUpdateTemplate);
> @@ -1137,7 +1137,7 @@ void radv_update_descriptor_set_with_template(struct radv_device *device,
>
> void radv_UpdateDescriptorSetWithTemplate(VkDevice _device,
> VkDescriptorSet descriptorSet,
> - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
> + VkDescriptorUpdateTemplate descriptorUpdateTemplate,
> const void *pData)
> {
> RADV_FROM_HANDLE(radv_device, device, _device);
> diff --git a/src/amd/vulkan/radv_device.c b/src/amd/vulkan/radv_device.c
> index a1199c614f7..2619feab86f 100644
> --- a/src/amd/vulkan/radv_device.c
> +++ b/src/amd/vulkan/radv_device.c
> @@ -754,19 +754,19 @@ void radv_GetPhysicalDeviceFeatures(
>
> void radv_GetPhysicalDeviceFeatures2(
> VkPhysicalDevice physicalDevice,
> - VkPhysicalDeviceFeatures2KHR *pFeatures)
> + VkPhysicalDeviceFeatures2 *pFeatures)
> {
> RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
> vk_foreach_struct(ext, pFeatures->pNext) {
> switch (ext->sType) {
> - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: {
> - VkPhysicalDeviceVariablePointerFeaturesKHR *features = (void *)ext;
> + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: {
> + VkPhysicalDeviceVariablePointerFeatures *features = (void *)ext;
> features->variablePointersStorageBuffer = true;
> features->variablePointers = false;
> break;
> }
> - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: {
> - VkPhysicalDeviceMultiviewFeaturesKHR *features = (VkPhysicalDeviceMultiviewFeaturesKHR*)ext;
> + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
> + VkPhysicalDeviceMultiviewFeatures *features = (VkPhysicalDeviceMultiviewFeatures*)ext;
> features->multiview = true;
> features->multiviewGeometryShader = true;
> features->multiviewTessellationShader = true;
> @@ -1008,7 +1008,7 @@ void radv_GetPhysicalDeviceProperties(
>
> void radv_GetPhysicalDeviceProperties2(
> VkPhysicalDevice physicalDevice,
> - VkPhysicalDeviceProperties2KHR *pProperties)
> + VkPhysicalDeviceProperties2 *pProperties)
> {
> RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
> radv_GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
> @@ -1021,23 +1021,23 @@ void radv_GetPhysicalDeviceProperties2(
> properties->maxPushDescriptors = MAX_PUSH_DESCRIPTORS;
> break;
> }
> - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: {
> - VkPhysicalDeviceIDPropertiesKHR *properties = (VkPhysicalDeviceIDPropertiesKHR*)ext;
> + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
> + VkPhysicalDeviceIDProperties *properties = (VkPhysicalDeviceIDProperties*)ext;
> memcpy(properties->driverUUID, pdevice->driver_uuid, VK_UUID_SIZE);
> memcpy(properties->deviceUUID, pdevice->device_uuid, VK_UUID_SIZE);
> properties->deviceLUIDValid = false;
> break;
> }
> - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: {
> - VkPhysicalDeviceMultiviewPropertiesKHR *properties = (VkPhysicalDeviceMultiviewPropertiesKHR*)ext;
> + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
> + VkPhysicalDeviceMultiviewProperties *properties = (VkPhysicalDeviceMultiviewProperties*)ext;
> properties->maxMultiviewViewCount = MAX_VIEWS;
> properties->maxMultiviewInstanceIndex = INT_MAX;
> break;
> }
> - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: {
> - VkPhysicalDevicePointClippingPropertiesKHR *properties =
> - (VkPhysicalDevicePointClippingPropertiesKHR*)ext;
> - properties->pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR;
> + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
> + VkPhysicalDevicePointClippingProperties *properties =
> + (VkPhysicalDevicePointClippingProperties*)ext;
> + properties->pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
> break;
> }
> case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
> @@ -1314,7 +1314,7 @@ void radv_GetPhysicalDeviceQueueFamilyProperties(
> void radv_GetPhysicalDeviceQueueFamilyProperties2(
> VkPhysicalDevice physicalDevice,
> uint32_t* pCount,
> - VkQueueFamilyProperties2KHR *pQueueFamilyProperties)
> + VkQueueFamilyProperties2 *pQueueFamilyProperties)
> {
> RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
> if (!pQueueFamilyProperties) {
> @@ -1341,7 +1341,7 @@ void radv_GetPhysicalDeviceMemoryProperties(
>
> void radv_GetPhysicalDeviceMemoryProperties2(
> VkPhysicalDevice physicalDevice,
> - VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties)
> + VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
> {
> return radv_GetPhysicalDeviceMemoryProperties(physicalDevice,
> &pMemoryProperties->memoryProperties);
> @@ -1349,7 +1349,7 @@ void radv_GetPhysicalDeviceMemoryProperties2(
>
> VkResult radv_GetMemoryHostPointerPropertiesEXT(
> VkDevice _device,
> - VkExternalMemoryHandleTypeFlagBitsKHR handleType,
> + VkExternalMemoryHandleTypeFlagBits handleType,
> const void *pHostPointer,
> VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
> {
> @@ -1370,7 +1370,7 @@ VkResult radv_GetMemoryHostPointerPropertiesEXT(
> return VK_SUCCESS;
> }
> default:
> - return VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR;
> + return VK_ERROR_INVALID_EXTERNAL_HANDLE;
> }
> }
>
> @@ -2970,10 +2970,10 @@ static VkResult radv_alloc_memory(struct radv_device *device,
>
> const VkImportMemoryFdInfoKHR *import_info =
> vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_FD_INFO_KHR);
> - const VkMemoryDedicatedAllocateInfoKHR *dedicate_info =
> - vk_find_struct_const(pAllocateInfo->pNext, MEMORY_DEDICATED_ALLOCATE_INFO_KHR);
> - const VkExportMemoryAllocateInfoKHR *export_info =
> - vk_find_struct_const(pAllocateInfo->pNext, EXPORT_MEMORY_ALLOCATE_INFO_KHR);
> + const VkMemoryDedicatedAllocateInfo *dedicate_info =
> + vk_find_struct_const(pAllocateInfo->pNext, MEMORY_DEDICATED_ALLOCATE_INFO);
> + const VkExportMemoryAllocateInfo *export_info =
> + vk_find_struct_const(pAllocateInfo->pNext, EXPORT_MEMORY_ALLOCATE_INFO);
> const VkImportMemoryHostPointerInfoEXT *host_ptr_info =
> vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_HOST_POINTER_INFO_EXT);
>
> @@ -3000,13 +3000,13 @@ static VkResult radv_alloc_memory(struct radv_device *device,
>
> if (import_info) {
> assert(import_info->handleType ==
> - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR ||
> + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT ||
> import_info->handleType ==
> VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
> mem->bo = device->ws->buffer_from_fd(device->ws, import_info->fd,
> NULL, NULL);
> if (!mem->bo) {
> - result = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR;
> + result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
> goto fail;
> } else {
> close(import_info->fd);
> @@ -3017,7 +3017,7 @@ static VkResult radv_alloc_memory(struct radv_device *device,
> mem->bo = device->ws->buffer_from_ptr(device->ws, host_ptr_info->pHostPointer,
> pAllocateInfo->allocationSize);
> if (!mem->bo) {
> - result = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR;
> + result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
> goto fail;
> } else {
> mem->user_ptr = host_ptr_info->pHostPointer;
> @@ -3174,17 +3174,17 @@ void radv_GetBufferMemoryRequirements(
>
> void radv_GetBufferMemoryRequirements2(
> VkDevice device,
> - const VkBufferMemoryRequirementsInfo2KHR* pInfo,
> - VkMemoryRequirements2KHR* pMemoryRequirements)
> + const VkBufferMemoryRequirementsInfo2 *pInfo,
> + VkMemoryRequirements2 *pMemoryRequirements)
> {
> radv_GetBufferMemoryRequirements(device, pInfo->buffer,
> &pMemoryRequirements->memoryRequirements);
> RADV_FROM_HANDLE(radv_buffer, buffer, pInfo->buffer);
> vk_foreach_struct(ext, pMemoryRequirements->pNext) {
> switch (ext->sType) {
> - case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: {
> - VkMemoryDedicatedRequirementsKHR *req =
> - (VkMemoryDedicatedRequirementsKHR *) ext;
> + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
> + VkMemoryDedicatedRequirements *req =
> + (VkMemoryDedicatedRequirements *) ext;
> req->requiresDedicatedAllocation = buffer->shareable;
> req->prefersDedicatedAllocation = req->requiresDedicatedAllocation;
> break;
> @@ -3211,8 +3211,8 @@ void radv_GetImageMemoryRequirements(
>
> void radv_GetImageMemoryRequirements2(
> VkDevice device,
> - const VkImageMemoryRequirementsInfo2KHR* pInfo,
> - VkMemoryRequirements2KHR* pMemoryRequirements)
> + const VkImageMemoryRequirementsInfo2 *pInfo,
> + VkMemoryRequirements2 *pMemoryRequirements)
> {
> radv_GetImageMemoryRequirements(device, pInfo->image,
> &pMemoryRequirements->memoryRequirements);
> @@ -3221,9 +3221,9 @@ void radv_GetImageMemoryRequirements2(
>
> vk_foreach_struct(ext, pMemoryRequirements->pNext) {
> switch (ext->sType) {
> - case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: {
> - VkMemoryDedicatedRequirementsKHR *req =
> - (VkMemoryDedicatedRequirementsKHR *) ext;
> + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
> + VkMemoryDedicatedRequirements *req =
> + (VkMemoryDedicatedRequirements *) ext;
> req->requiresDedicatedAllocation = image->shareable;
> req->prefersDedicatedAllocation = req->requiresDedicatedAllocation;
> break;
> @@ -3245,9 +3245,9 @@ void radv_GetImageSparseMemoryRequirements(
>
> void radv_GetImageSparseMemoryRequirements2(
> VkDevice device,
> - const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
> + const VkImageSparseMemoryRequirementsInfo2 *pInfo,
> uint32_t* pSparseMemoryRequirementCount,
> - VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements)
> + VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
> {
> stub();
> }
> @@ -3262,7 +3262,7 @@ void radv_GetDeviceMemoryCommitment(
>
> VkResult radv_BindBufferMemory2(VkDevice device,
> uint32_t bindInfoCount,
> - const VkBindBufferMemoryInfoKHR *pBindInfos)
> + const VkBindBufferMemoryInfo *pBindInfos)
> {
> for (uint32_t i = 0; i < bindInfoCount; ++i) {
> RADV_FROM_HANDLE(radv_device_memory, mem, pBindInfos[i].memory);
> @@ -3284,8 +3284,8 @@ VkResult radv_BindBufferMemory(
> VkDeviceMemory memory,
> VkDeviceSize memoryOffset)
> {
> - const VkBindBufferMemoryInfoKHR info = {
> - .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR,
> + const VkBindBufferMemoryInfo info = {
> + .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
> .buffer = buffer,
> .memory = memory,
> .memoryOffset = memoryOffset
> @@ -3296,7 +3296,7 @@ VkResult radv_BindBufferMemory(
>
> VkResult radv_BindImageMemory2(VkDevice device,
> uint32_t bindInfoCount,
> - const VkBindImageMemoryInfoKHR *pBindInfos)
> + const VkBindImageMemoryInfo *pBindInfos)
> {
> for (uint32_t i = 0; i < bindInfoCount; ++i) {
> RADV_FROM_HANDLE(radv_device_memory, mem, pBindInfos[i].memory);
> @@ -3320,8 +3320,8 @@ VkResult radv_BindImageMemory(
> VkDeviceMemory memory,
> VkDeviceSize memoryOffset)
> {
> - const VkBindImageMemoryInfoKHR info = {
> - .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR,
> + const VkBindImageMemoryInfo info = {
> + .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
> .image = image,
> .memory = memory,
> .memoryOffset = memoryOffset
> @@ -3446,9 +3446,9 @@ VkResult radv_CreateFence(
> VkFence* pFence)
> {
> RADV_FROM_HANDLE(radv_device, device, _device);
> - const VkExportFenceCreateInfoKHR *export =
> - vk_find_struct_const(pCreateInfo->pNext, EXPORT_FENCE_CREATE_INFO_KHR);
> - VkExternalFenceHandleTypeFlagsKHR handleTypes =
> + const VkExportFenceCreateInfo *export =
> + vk_find_struct_const(pCreateInfo->pNext, EXPORT_FENCE_CREATE_INFO);
> + VkExternalFenceHandleTypeFlags handleTypes =
> export ? export->handleTypes : 0;
>
> struct radv_fence *fence = vk_alloc2(&device->alloc, pAllocator,
> @@ -3735,9 +3735,9 @@ VkResult radv_CreateSemaphore(
> VkSemaphore* pSemaphore)
> {
> RADV_FROM_HANDLE(radv_device, device, _device);
> - const VkExportSemaphoreCreateInfoKHR *export =
> - vk_find_struct_const(pCreateInfo->pNext, EXPORT_SEMAPHORE_CREATE_INFO_KHR);
> - VkExternalSemaphoreHandleTypeFlagsKHR handleTypes =
> + const VkExportSemaphoreCreateInfo *export =
> + vk_find_struct_const(pCreateInfo->pNext, EXPORT_SEMAPHORE_CREATE_INFO);
> + VkExternalSemaphoreHandleTypeFlags handleTypes =
> export ? export->handleTypes : 0;
>
> struct radv_semaphore *sem = vk_alloc2(&device->alloc, pAllocator,
> @@ -4686,7 +4686,7 @@ VkResult radv_GetMemoryFdKHR(VkDevice _device,
>
> /* At the moment, we support only the below handle types. */
> assert(pGetFdInfo->handleType ==
> - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR ||
> + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT ||
> pGetFdInfo->handleType ==
> VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
>
> @@ -4697,7 +4697,7 @@ VkResult radv_GetMemoryFdKHR(VkDevice _device,
> }
>
> VkResult radv_GetMemoryFdPropertiesKHR(VkDevice _device,
> - VkExternalMemoryHandleTypeFlagBitsKHR handleType,
> + VkExternalMemoryHandleTypeFlagBits handleType,
> int fd,
> VkMemoryFdPropertiesKHR *pMemoryFdProperties)
> {
> @@ -4716,7 +4716,7 @@ VkResult radv_GetMemoryFdPropertiesKHR(VkDevice _device,
> *
> * So opaque handle types fall into the default "unsupported" case.
> */
> - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
> + return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
> }
> }
>
> @@ -4727,7 +4727,7 @@ static VkResult radv_import_opaque_fd(struct radv_device *device,
> uint32_t syncobj_handle = 0;
> int ret = device->ws->import_syncobj(device->ws, fd, &syncobj_handle);
> if (ret != 0)
> - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
> + return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
>
> if (*syncobj)
> device->ws->destroy_syncobj(device->ws, *syncobj);
> @@ -4748,7 +4748,7 @@ static VkResult radv_import_sync_fd(struct radv_device *device,
> if (!syncobj_handle) {
> int ret = device->ws->create_syncobj(device->ws, &syncobj_handle);
> if (ret) {
> - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
> + return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
> }
> }
>
> @@ -4757,7 +4757,7 @@ static VkResult radv_import_sync_fd(struct radv_device *device,
> } else {
> int ret = device->ws->import_syncobj_from_sync_file(device->ws, syncobj_handle, fd);
> if (ret != 0)
> - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
> + return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
> }
>
> *syncobj = syncobj_handle;
> @@ -4774,16 +4774,16 @@ VkResult radv_ImportSemaphoreFdKHR(VkDevice _device,
> RADV_FROM_HANDLE(radv_semaphore, sem, pImportSemaphoreFdInfo->semaphore);
> uint32_t *syncobj_dst = NULL;
>
> - if (pImportSemaphoreFdInfo->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR) {
> + if (pImportSemaphoreFdInfo->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) {
> syncobj_dst = &sem->temp_syncobj;
> } else {
> syncobj_dst = &sem->syncobj;
> }
>
> switch(pImportSemaphoreFdInfo->handleType) {
> - case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
> + case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
> return radv_import_opaque_fd(device, pImportSemaphoreFdInfo->fd, syncobj_dst);
> - case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
> + case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
> return radv_import_sync_fd(device, pImportSemaphoreFdInfo->fd, syncobj_dst);
> default:
> unreachable("Unhandled semaphore handle type");
> @@ -4805,10 +4805,10 @@ VkResult radv_GetSemaphoreFdKHR(VkDevice _device,
> syncobj_handle = sem->syncobj;
>
> switch(pGetFdInfo->handleType) {
> - case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
> + case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
> ret = device->ws->export_syncobj(device->ws, syncobj_handle, pFd);
> break;
> - case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
> + case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
> ret = device->ws->export_syncobj_to_sync_file(device->ws, syncobj_handle, pFd);
> if (!ret) {
> if (sem->temp_syncobj) {
> @@ -4824,30 +4824,30 @@ VkResult radv_GetSemaphoreFdKHR(VkDevice _device,
> }
>
> if (ret)
> - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
> + return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
> return VK_SUCCESS;
> }
>
> void radv_GetPhysicalDeviceExternalSemaphoreProperties(
> VkPhysicalDevice physicalDevice,
> - const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
> - VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties)
> + const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
> + VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
> {
> RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
>
> /* Require has_syncobj_wait_for_submit for the syncobj signal ioctl introduced at virtually the same time */
> if (pdevice->rad_info.has_syncobj_wait_for_submit &&
> - (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR ||
> - pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR)) {
> - pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR;
> - pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR;
> - pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR |
> - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR;
> - } else if (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR) {
> - pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
> - pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
> - pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR |
> - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR;
> + (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT ||
> + pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT)) {
> + pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
> + pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
> + pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
> + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
> + } else if (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
> + pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
> + pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
> + pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
> + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
> } else {
> pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
> pExternalSemaphoreProperties->compatibleHandleTypes = 0;
> @@ -4863,16 +4863,16 @@ VkResult radv_ImportFenceFdKHR(VkDevice _device,
> uint32_t *syncobj_dst = NULL;
>
>
> - if (pImportFenceFdInfo->flags & VK_FENCE_IMPORT_TEMPORARY_BIT_KHR) {
> + if (pImportFenceFdInfo->flags & VK_FENCE_IMPORT_TEMPORARY_BIT) {
> syncobj_dst = &fence->temp_syncobj;
> } else {
> syncobj_dst = &fence->syncobj;
> }
>
> switch(pImportFenceFdInfo->handleType) {
> - case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
> + case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
> return radv_import_opaque_fd(device, pImportFenceFdInfo->fd, syncobj_dst);
> - case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
> + case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
> return radv_import_sync_fd(device, pImportFenceFdInfo->fd, syncobj_dst);
> default:
> unreachable("Unhandled fence handle type");
> @@ -4894,10 +4894,10 @@ VkResult radv_GetFenceFdKHR(VkDevice _device,
> syncobj_handle = fence->syncobj;
>
> switch(pGetFdInfo->handleType) {
> - case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
> + case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
> ret = device->ws->export_syncobj(device->ws, syncobj_handle, pFd);
> break;
> - case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
> + case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
> ret = device->ws->export_syncobj_to_sync_file(device->ws, syncobj_handle, pFd);
> if (!ret) {
> if (fence->temp_syncobj) {
> @@ -4913,24 +4913,24 @@ VkResult radv_GetFenceFdKHR(VkDevice _device,
> }
>
> if (ret)
> - return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR);
> + return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
> return VK_SUCCESS;
> }
>
> void radv_GetPhysicalDeviceExternalFenceProperties(
> VkPhysicalDevice physicalDevice,
> - const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
> - VkExternalFencePropertiesKHR* pExternalFenceProperties)
> + const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
> + VkExternalFenceProperties *pExternalFenceProperties)
> {
> RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);
>
> if (pdevice->rad_info.has_syncobj_wait_for_submit &&
> - (pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR ||
> - pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR)) {
> - pExternalFenceProperties->exportFromImportedHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR;
> - pExternalFenceProperties->compatibleHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR;
> - pExternalFenceProperties->externalFenceFeatures = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR |
> - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR;
> + (pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT ||
> + pExternalFenceInfo->handleType == VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT)) {
> + pExternalFenceProperties->exportFromImportedHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
> + pExternalFenceProperties->compatibleHandleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
> + pExternalFenceProperties->externalFenceFeatures = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT |
> + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
> } else {
> pExternalFenceProperties->exportFromImportedHandleTypes = 0;
> pExternalFenceProperties->compatibleHandleTypes = 0;
> diff --git a/src/amd/vulkan/radv_formats.c b/src/amd/vulkan/radv_formats.c
> index 8510f8a427e..ee408b55334 100644
> --- a/src/amd/vulkan/radv_formats.c
> +++ b/src/amd/vulkan/radv_formats.c
> @@ -639,8 +639,8 @@ radv_physical_device_get_format_properties(struct radv_physical_device *physical
> tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
> tiled |= VK_FORMAT_FEATURE_BLIT_SRC_BIT |
> VK_FORMAT_FEATURE_BLIT_DST_BIT;
> - tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
> - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
> + tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
> + VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
>
> if (radv_is_filter_minmax_format_supported(format))
> tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
> @@ -684,8 +684,8 @@ radv_physical_device_get_format_properties(struct radv_physical_device *physical
> }
> }
> if (tiled && !scaled) {
> - tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
> - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
> + tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
> + VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
> }
>
> /* Tiled formatting does not support NPOT pixel sizes */
> @@ -694,8 +694,8 @@ radv_physical_device_get_format_properties(struct radv_physical_device *physical
> }
>
> if (linear && !scaled) {
> - linear |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
> - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
> + linear |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
> + VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
> }
>
> if (format == VK_FORMAT_R32_UINT || format == VK_FORMAT_R32_SINT) {
> @@ -1026,7 +1026,7 @@ void radv_GetPhysicalDeviceFormatProperties(
> void radv_GetPhysicalDeviceFormatProperties2(
> VkPhysicalDevice physicalDevice,
> VkFormat format,
> - VkFormatProperties2KHR* pFormatProperties)
> + VkFormatProperties2* pFormatProperties)
> {
> RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
>
> @@ -1036,7 +1036,7 @@ void radv_GetPhysicalDeviceFormatProperties2(
> }
>
> static VkResult radv_get_image_format_properties(struct radv_physical_device *physical_device,
> - const VkPhysicalDeviceImageFormatInfo2KHR *info,
> + const VkPhysicalDeviceImageFormatInfo2 *info,
> VkImageFormatProperties *pImageFormatProperties)
>
> {
> @@ -1202,8 +1202,8 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties(
> {
> RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
>
> - const VkPhysicalDeviceImageFormatInfo2KHR info = {
> - .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
> + const VkPhysicalDeviceImageFormatInfo2 info = {
> + .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
> .pNext = NULL,
> .format = format,
> .type = type,
> @@ -1217,20 +1217,20 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties(
> }
>
> static void
> -get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
> - VkExternalMemoryHandleTypeFlagBitsKHR handleType,
> - VkExternalMemoryPropertiesKHR *external_properties)
> +get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
> + VkExternalMemoryHandleTypeFlagBits handleType,
> + VkExternalMemoryProperties *external_properties)
> {
> - VkExternalMemoryFeatureFlagBitsKHR flags = 0;
> - VkExternalMemoryHandleTypeFlagsKHR export_flags = 0;
> - VkExternalMemoryHandleTypeFlagsKHR compat_flags = 0;
> + VkExternalMemoryFeatureFlagBits flags = 0;
> + VkExternalMemoryHandleTypeFlags export_flags = 0;
> + VkExternalMemoryHandleTypeFlags compat_flags = 0;
> switch (handleType) {
> - case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
> + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
> case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
> switch (pImageFormatInfo->type) {
> case VK_IMAGE_TYPE_2D:
> - flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
> - compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR |
> + flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
> + compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
> VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
> break;
> default:
> @@ -1238,14 +1238,14 @@ get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2KHR *
> }
> break;
> case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
> - flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
> + flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
> compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
> break;
> default:
> break;
> }
>
> - *external_properties = (VkExternalMemoryPropertiesKHR) {
> + *external_properties = (VkExternalMemoryProperties) {
> .externalMemoryFeatures = flags,
> .exportFromImportedHandleTypes = export_flags,
> .compatibleHandleTypes = compat_flags,
> @@ -1254,12 +1254,12 @@ get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2KHR *
>
> VkResult radv_GetPhysicalDeviceImageFormatProperties2(
> VkPhysicalDevice physicalDevice,
> - const VkPhysicalDeviceImageFormatInfo2KHR *base_info,
> - VkImageFormatProperties2KHR *base_props)
> + const VkPhysicalDeviceImageFormatInfo2 *base_info,
> + VkImageFormatProperties2 *base_props)
> {
> RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
> - const VkPhysicalDeviceExternalImageFormatInfoKHR *external_info = NULL;
> - VkExternalImageFormatPropertiesKHR *external_props = NULL;
> + const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL;
> + VkExternalImageFormatProperties *external_props = NULL;
> VkResult result;
>
> result = radv_get_image_format_properties(physical_device, base_info,
> @@ -1270,7 +1270,7 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties2(
> /* Extract input structs */
> vk_foreach_struct_const(s, base_info->pNext) {
> switch (s->sType) {
> - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR:
> + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
> external_info = (const void *) s;
> break;
> default:
> @@ -1281,7 +1281,7 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties2(
> /* Extract output structs */
> vk_foreach_struct(s, base_props->pNext) {
> switch (s->sType) {
> - case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR:
> + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
> external_props = (void *) s;
> break;
> default:
> @@ -1297,7 +1297,7 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties2(
> */
> if (external_info && external_info->handleType != 0) {
> switch (external_info->handleType) {
> - case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
> + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
> case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
> case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
> get_external_image_format_properties(base_info, external_info->handleType,
> @@ -1351,9 +1351,9 @@ void radv_GetPhysicalDeviceSparseImageFormatProperties(
>
> void radv_GetPhysicalDeviceSparseImageFormatProperties2(
> VkPhysicalDevice physicalDevice,
> - const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
> + const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
> uint32_t *pPropertyCount,
> - VkSparseImageFormatProperties2KHR* pProperties)
> + VkSparseImageFormatProperties2 *pProperties)
> {
> /* Sparse images are not yet supported. */
> *pPropertyCount = 0;
> @@ -1361,28 +1361,28 @@ void radv_GetPhysicalDeviceSparseImageFormatProperties2(
>
> void radv_GetPhysicalDeviceExternalBufferProperties(
> VkPhysicalDevice physicalDevice,
> - const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo,
> - VkExternalBufferPropertiesKHR *pExternalBufferProperties)
> + const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
> + VkExternalBufferProperties *pExternalBufferProperties)
> {
> - VkExternalMemoryFeatureFlagBitsKHR flags = 0;
> - VkExternalMemoryHandleTypeFlagsKHR export_flags = 0;
> - VkExternalMemoryHandleTypeFlagsKHR compat_flags = 0;
> + VkExternalMemoryFeatureFlagBits flags = 0;
> + VkExternalMemoryHandleTypeFlags export_flags = 0;
> + VkExternalMemoryHandleTypeFlags compat_flags = 0;
> switch(pExternalBufferInfo->handleType) {
> - case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
> + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
> case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
> - flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR |
> - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
> - compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR |
> + flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
> + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
> + compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
> VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
> break;
> case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
> - flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
> + flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
> compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
> break;
> default:
> break;
> }
> - pExternalBufferProperties->externalMemoryProperties = (VkExternalMemoryPropertiesKHR) {
> + pExternalBufferProperties->externalMemoryProperties = (VkExternalMemoryProperties) {
> .externalMemoryFeatures = flags,
> .exportFromImportedHandleTypes = export_flags,
> .compatibleHandleTypes = compat_flags,
> diff --git a/src/amd/vulkan/radv_image.c b/src/amd/vulkan/radv_image.c
> index 69bbcdcf645..e7f5d5249d8 100644
> --- a/src/amd/vulkan/radv_image.c
> +++ b/src/amd/vulkan/radv_image.c
> @@ -73,7 +73,7 @@ radv_use_tc_compat_htile_for_image(struct radv_device *device,
> return false;
>
> if ((pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) ||
> - (pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR))
> + (pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT))
> return false;
>
> if (pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR)
> @@ -143,7 +143,7 @@ radv_use_dcc_for_image(struct radv_device *device,
>
> /* TODO: Enable DCC for storage images. */
> if ((pCreateInfo->usage & VK_IMAGE_USAGE_STORAGE_BIT) ||
> - (pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR))
> + (pCreateInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT))
> return false;
>
> if (pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR)
> @@ -984,7 +984,7 @@ radv_image_create(VkDevice _device,
> image->exclusive = pCreateInfo->sharingMode == VK_SHARING_MODE_EXCLUSIVE;
> if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) {
> for (uint32_t i = 0; i < pCreateInfo->queueFamilyIndexCount; ++i)
> - if (pCreateInfo->pQueueFamilyIndices[i] == VK_QUEUE_FAMILY_EXTERNAL_KHR)
> + if (pCreateInfo->pQueueFamilyIndices[i] == VK_QUEUE_FAMILY_EXTERNAL)
> image->queue_family_mask |= (1u << RADV_MAX_QUEUE_FAMILIES) - 1u;
> else
> image->queue_family_mask |= 1u << pCreateInfo->pQueueFamilyIndices[i];
> @@ -1264,7 +1264,7 @@ unsigned radv_image_queue_family_mask(const struct radv_image *image, uint32_t f
> {
> if (!image->exclusive)
> return image->queue_family_mask;
> - if (family == VK_QUEUE_FAMILY_EXTERNAL_KHR)
> + if (family == VK_QUEUE_FAMILY_EXTERNAL)
> return (1u << RADV_MAX_QUEUE_FAMILIES) - 1u;
> if (family == VK_QUEUE_FAMILY_IGNORED)
> return 1u << queue_family;
> diff --git a/src/amd/vulkan/radv_meta_bufimage.c b/src/amd/vulkan/radv_meta_bufimage.c
> index e0dc7151556..6a46ed952d7 100644
> --- a/src/amd/vulkan/radv_meta_bufimage.c
> +++ b/src/amd/vulkan/radv_meta_bufimage.c
> @@ -1593,7 +1593,7 @@ create_buffer_from_image(struct radv_cmd_buffer *cmd_buffer,
> }, NULL, buffer);
>
> radv_BindBufferMemory2(radv_device_to_handle(device), 1,
> - (VkBindBufferMemoryInfoKHR[]) {
> + (VkBindBufferMemoryInfo[]) {
> {
> .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
> .buffer = *buffer,
> diff --git a/src/amd/vulkan/radv_pass.c b/src/amd/vulkan/radv_pass.c
> index b41ae89deec..3652eb7ce69 100644
> --- a/src/amd/vulkan/radv_pass.c
> +++ b/src/amd/vulkan/radv_pass.c
> @@ -38,7 +38,7 @@ VkResult radv_CreateRenderPass(
> struct radv_render_pass *pass;
> size_t size;
> size_t attachments_offset;
> - VkRenderPassMultiviewCreateInfoKHR *multiview_info = NULL;
> + VkRenderPassMultiviewCreateInfo *multiview_info = NULL;
>
> assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
>
> @@ -59,8 +59,8 @@ VkResult radv_CreateRenderPass(
>
> vk_foreach_struct(ext, pCreateInfo->pNext) {
> switch(ext->sType) {
> - case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR:
> - multiview_info = ( VkRenderPassMultiviewCreateInfoKHR*)ext;
> + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
> + multiview_info = (VkRenderPassMultiviewCreateInfo*)ext;
> break;
> default:
> break;
> diff --git a/src/amd/vulkan/radv_pipeline.c b/src/amd/vulkan/radv_pipeline.c
> index 7bc0bd99943..9d5da43532f 100644
> --- a/src/amd/vulkan/radv_pipeline.c
> +++ b/src/amd/vulkan/radv_pipeline.c
> @@ -1705,11 +1705,11 @@ calculate_tess_state(struct radv_pipeline *pipeline,
> }
>
> bool ccw = tes->info.tes.ccw;
> - const VkPipelineTessellationDomainOriginStateCreateInfoKHR *domain_origin_state =
> + const VkPipelineTessellationDomainOriginStateCreateInfo *domain_origin_state =
> vk_find_struct_const(pCreateInfo->pTessellationState,
> - PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR);
> + PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO);
>
> - if (domain_origin_state && domain_origin_state->domainOrigin != VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR)
> + if (domain_origin_state && domain_origin_state->domainOrigin != VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT)
> ccw = !ccw;
>
> if (tes->info.tes.point_mode)
> diff --git a/src/amd/vulkan/radv_private.h b/src/amd/vulkan/radv_private.h
> index bd489b64a80..6089ee6a607 100644
> --- a/src/amd/vulkan/radv_private.h
> +++ b/src/amd/vulkan/radv_private.h
> @@ -1887,7 +1887,7 @@ void
> radv_update_descriptor_set_with_template(struct radv_device *device,
> struct radv_cmd_buffer *cmd_buffer,
> struct radv_descriptor_set *set,
> - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
> + VkDescriptorUpdateTemplate descriptorUpdateTemplate,
> const void *pData);
>
> void radv_meta_push_descriptor_set(struct radv_cmd_buffer *cmd_buffer,
> @@ -1984,7 +1984,7 @@ RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_buffer_view, VkBufferView)
> RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_pool, VkDescriptorPool)
> RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_set, VkDescriptorSet)
> RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_set_layout, VkDescriptorSetLayout)
> -RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_update_template, VkDescriptorUpdateTemplateKHR)
> +RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_descriptor_update_template, VkDescriptorUpdateTemplate)
> RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_device_memory, VkDeviceMemory)
> RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_fence, VkFence)
> RADV_DEFINE_NONDISP_HANDLE_CASTS(radv_event, VkEvent)
> --
> 2.20.1
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
More information about the mesa-dev
mailing list