radv: get rid of bunch of KHR suffixes

Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl>
Acked-by: Eric Engestrom <eric.engestrom@intel.com>
Signed-off-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>

diff --git a/src/amd/vulkan/radv_android.c b/src/amd/vulkan/radv_android.c
index 1a4425f26a56324edb3d2a978d9f82e97590268b..9613eabbe87d1984d2dea761bd8adfcb43de5c4b 100644 (file)
--- 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 d1b8b3dee6a40928190957f634f407f5963bbc10..4382062c411ffcfb96c87920fd334c9d04cffdff 100644 (file)
--- 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 351cc1613eda5b4740817af137db181d6bfe91e8..526bb77a553021d781e7836db211cdff743298f7 100644 (file)
--- 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 a1199c614f79dd70dac291269e0c8feba8036fcb..2619feab86fbb03e6fb02d7cfd2b2f2071b20685 100644 (file)
--- 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 8510f8a427ed08b94b412a8abe13a805451dbbf4..ee408b55334cc4e5e3a15658a7b37d5fe814dd87 100644 (file)
--- 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 69bbcdcf645fb3112d7d4fee5aeb82c1586ad614..e7f5d5249d8e02741f6f67d8277103be772fcb49 100644 (file)
--- 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 e0dc7151556b48c6564564c781fa71f130df4dbd..6a46ed952d783be9547f2ea27fc5792e2f6201da 100644 (file)
--- 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 b41ae89deec6cab8dd6f03f8f0165756354b3256..3652eb7ce6963463bc1e84db619b58a7a495db14 100644 (file)
--- 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 7bc0bd999431ca8214d6b81adcff6a275ea11fc2..9d5da43532f6efddc0258fb81d768d3f204277ca 100644 (file)
--- 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 bd489b64a80b9bc23a9d7c425a034f460e59303b..6089ee6a60746c88e3c3a160cd7309fe12ff029e 100644 (file)
--- 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)