[PATCH 1/4] winevulkan: Implement VK_EXT_external_memory_win32.
Georg Lehmann
dadschoorse at gmail.com
Mon May 3 16:44:20 CDT 2021
On 03.05.21 18:46, Derek Lesho wrote:
> Signed-off-by: Derek Lesho <dlesho at codeweavers.com>
> ---
> This commit had to be squashed in with the tests, as data structures for the extension are missing from
> the headers when the extension is blacklisted by make_vulkan.
> ---
> dlls/vulkan-1/tests/vulkan.c | 242 +++++++++++++++++--
> dlls/winevulkan/loader_thunks.c | 12 +
> dlls/winevulkan/loader_thunks.h | 2 +
> dlls/winevulkan/make_vulkan | 63 ++++-
> dlls/winevulkan/vulkan.c | 385 +++++++++++++++++++++++++++++--
> dlls/winevulkan/vulkan_private.h | 22 ++
> 6 files changed, 679 insertions(+), 47 deletions(-)
>
Hi,
I would prefer if you could split this up in to multiple patches, e.g.
the host only functions and struct conversion changes in make_vulkan
could each be in their own commits.
> diff --git a/dlls/vulkan-1/tests/vulkan.c b/dlls/vulkan-1/tests/vulkan.c
> index 9061b2b6db8..c1350da70ee 100644
> --- a/dlls/vulkan-1/tests/vulkan.c
> +++ b/dlls/vulkan-1/tests/vulkan.c
> @@ -144,7 +144,7 @@ static void test_instance_version(void)
> VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version), VK_VERSION_PATCH(version));
> }
>
> -static void enumerate_physical_device(VkPhysicalDevice vk_physical_device)
> +static void enumerate_physical_device(VkInstance vk_instance, VkPhysicalDevice vk_physical_device)
> {
> VkPhysicalDeviceProperties properties;
>
> @@ -224,7 +224,7 @@ static void test_enumerate_physical_device2(void)
> vkDestroyInstance(vk_instance, NULL);
> }
>
> -static void enumerate_device_queues(VkPhysicalDevice vk_physical_device)
> +static void enumerate_device_queues(VkInstance vk_instance, VkPhysicalDevice vk_physical_device)
> {
> VkPhysicalDeviceProperties device_properties;
> VkQueueFamilyProperties *properties;
> @@ -283,7 +283,7 @@ static void test_physical_device_groups(void)
> trace("Group[%u] count %u, subset allocation %#x\n",
> i, properties[i].physicalDeviceCount, properties[i].subsetAllocation);
> for (j = 0; j < properties[i].physicalDeviceCount; ++j)
> - enumerate_physical_device(properties[i].physicalDevices[j]);
> + enumerate_physical_device(vk_instance, properties[i].physicalDevices[j]);
> }
>
> if ((vr = create_device(properties->physicalDevices[0], 0, NULL, NULL, &vk_device)) < 0)
> @@ -307,7 +307,7 @@ static void test_physical_device_groups(void)
> vkDestroyInstance(vk_instance, NULL);
> }
>
> -static void test_destroy_command_pool(VkPhysicalDevice vk_physical_device)
> +static void test_destroy_command_pool(VkInstance vk_instance, VkPhysicalDevice vk_physical_device)
> {
> VkCommandBufferAllocateInfo allocate_info;
> VkCommandPoolCreateInfo pool_info;
> @@ -366,7 +366,7 @@ static void test_unsupported_instance_extensions(void)
> }
> }
>
> -static void test_unsupported_device_extensions(VkPhysicalDevice vk_physical_device)
> +static void test_unsupported_device_extensions(VkInstance vk_instance, VkPhysicalDevice vk_physical_device)
> {
> VkDevice vk_device;
> unsigned int i;
> @@ -387,7 +387,7 @@ static void test_unsupported_device_extensions(VkPhysicalDevice vk_physical_devi
> }
> }
>
> -static void test_private_data(VkPhysicalDevice vk_physical_device)
> +static void test_private_data(VkInstance vk_instance, VkPhysicalDevice vk_physical_device)
> {
> PFN_vkDestroyPrivateDataSlotEXT pfn_vkDestroyPrivateDataSlotEXT;
> PFN_vkCreatePrivateDataSlotEXT pfn_vkCreatePrivateDataSlotEXT;
> @@ -437,7 +437,218 @@ static void test_private_data(VkPhysicalDevice vk_physical_device)
> vkDestroyDevice(vk_device, NULL);
> }
>
> -static void for_each_device(void (*test_func)(VkPhysicalDevice))
> +uint32_t find_memory_type(VkPhysicalDevice vk_physical_device, VkMemoryPropertyFlagBits flags)
> +{
> + VkPhysicalDeviceMemoryProperties properties = {0};
> + unsigned int i;
> +
> + vkGetPhysicalDeviceMemoryProperties(vk_physical_device, &properties);
> +
> + for(i = 0; i < properties.memoryTypeCount; i++)
> + {
> + if (properties.memoryTypes[i].propertyFlags & flags)
> + return i;
> + }
> + return -1;
> +}
> +
> +static void test_external_memory(VkInstance vk_instance, VkPhysicalDevice vk_physical_device)
> +{
> + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR pfn_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
> + PFN_vkGetMemoryWin32HandleKHR pfn_vkGetMemoryWin32HandleKHR;
> + VkPhysicalDeviceExternalBufferInfoKHR external_buffer_info;
> + VkExternalBufferPropertiesKHR external_buffer_properties;
> + VkMemoryDedicatedAllocateInfoKHR dedicated_alloc_info;
> + VkExportMemoryWin32HandleInfoKHR export_handle_info;
> + VkImportMemoryWin32HandleInfoKHR import_handle_info;
> + VkExportMemoryAllocateInfoKHR export_memory_info;
> + VkMemoryGetWin32HandleInfoKHR get_handle_info;
> + VkBufferCreateInfo buffer_create_info;
> + VkMemoryAllocateInfo alloc_info;
> + uint32_t queue_family_index;
> + HANDLE nt_handle, kmt_handle;
> + VkDeviceMemory vk_memory, vk_memory_import;
> + VkBuffer vk_buffer;
> + VkDevice vk_device;
> + VkResult vr;
> +
> + static const char *extensions[] =
> + {
> + "VK_KHR_dedicated_allocation",
> + "VK_KHR_external_memory",
> + "VK_KHR_external_memory_win32",
> + };
> +
> + pfn_vkGetPhysicalDeviceExternalBufferPropertiesKHR =
> + (void*) vkGetInstanceProcAddr(vk_instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
> +
> + if ((vr = create_device(vk_physical_device, ARRAY_SIZE(extensions), extensions, NULL, &vk_device)))
> + {
> + skip("Failed to create device with external memory extensions, VkResult %d.\n", vr);
> + return;
> + }
> +
> + pfn_vkGetMemoryWin32HandleKHR = (void *) vkGetDeviceProcAddr(vk_device, "vkGetMemoryWin32HandleKHR");
> +
> + find_queue_family(vk_physical_device, VK_QUEUE_GRAPHICS_BIT, &queue_family_index);
> +
> + /* Most implementations only support exporting dedicated allocations */
> +
> + buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
> + buffer_create_info.pNext = NULL;
> + buffer_create_info.flags = 0;
> + buffer_create_info.size = 1;
> + buffer_create_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
> + buffer_create_info.sharingMode = VK_SHARING_MODE_CONCURRENT;
> + buffer_create_info.queueFamilyIndexCount = 1;
> + buffer_create_info.pQueueFamilyIndices = &queue_family_index;
> + if ((vr = vkCreateBuffer(vk_device, &buffer_create_info, NULL, &vk_buffer)))
> + {
> + skip("Failed to create generic buffer, VkResult %d.\n", vr);
> + vkDestroyDevice(vk_device, NULL);
> + return;
> + }
> +
> + dedicated_alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR;
> + dedicated_alloc_info.pNext = NULL;
> + dedicated_alloc_info.image = VK_NULL_HANDLE;
> + dedicated_alloc_info.buffer = vk_buffer;
> +
> + external_buffer_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR;
> + external_buffer_info.pNext = NULL;
> + external_buffer_info.flags = 0;
> + external_buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
> + external_buffer_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR;
> +
> + memset(&external_buffer_properties, 0, sizeof(external_buffer_properties));
> + external_buffer_properties.sType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR;
> +
> + pfn_vkGetPhysicalDeviceExternalBufferPropertiesKHR(vk_physical_device, &external_buffer_info, &external_buffer_properties);
> +
> + if (!(external_buffer_properties.externalMemoryProperties.externalMemoryFeatures &
> + (VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)))
> + skip("With desired parameters, buffers are not exportable to and importable from an NT handle.\n");
> + else
> + {
> + ok(external_buffer_properties.externalMemoryProperties.compatibleHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
> + "Unexpected compatibleHandleTypes %#x.\n", external_buffer_properties.externalMemoryProperties.compatibleHandleTypes);
> +
> + export_memory_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
> + export_memory_info.pNext = &dedicated_alloc_info;
> + export_memory_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR;
> +
> + export_handle_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
> + export_handle_info.pNext = &export_memory_info;
> + export_handle_info.name = L"wine_test_buffer_export_name";
> + export_handle_info.dwAccess = GENERIC_ALL;
> + export_handle_info.pAttributes = NULL;
> +
> + alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
> + alloc_info.pNext = &export_handle_info;
> + alloc_info.allocationSize = 1;
> + alloc_info.memoryTypeIndex = find_memory_type(vk_physical_device, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
> +
> + ok(alloc_info.memoryTypeIndex != -1, "Device local memory type index was not found.\n");
> +
> + vr = vkAllocateMemory(vk_device, &alloc_info, NULL, &vk_memory);
> + ok(vr == VK_SUCCESS, "vkAllocateMemory failed, VkResult %d.\n", vr);
> +
> + get_handle_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR;
> + get_handle_info.pNext = NULL;
> + get_handle_info.memory = vk_memory;
> + get_handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR;
> +
> + vr = pfn_vkGetMemoryWin32HandleKHR(vk_device, &get_handle_info, &nt_handle);
> + ok(vr == VK_SUCCESS, "vkGetMemoryWin32HandleKHR failed, VkResult %d.\n", vr);
> +
> + import_handle_info.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
> + import_handle_info.pNext = &dedicated_alloc_info;
> + import_handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR;
> + import_handle_info.handle = nt_handle;
> + import_handle_info.name = NULL;
> +
> + alloc_info.pNext = &import_handle_info;
> +
> + vr = vkAllocateMemory(vk_device, &alloc_info, NULL, &vk_memory_import);
> + ok(vr == VK_SUCCESS, "vkAllocateMemory failed, VkResult %d.\n", vr);
> + ok(vk_memory_import != vk_memory, "Expected new memory object.\n");
> +
> + vkFreeMemory(vk_device, vk_memory_import, NULL);
> +
> + import_handle_info.handle = NULL;
> + import_handle_info.name = L"wine_test_buffer_export_name";
> +
> + vr = vkAllocateMemory(vk_device, &alloc_info, NULL, &vk_memory_import);
> + todo_wine
> + ok(vr == VK_SUCCESS, "vkAllocateMemory failed, VkResult %d.\n", vr);
> + if (vr == VK_SUCCESS)
> + {
> + ok(vk_memory_import != vk_memory, "Expected new memory object.\n");
> + vkFreeMemory(vk_device, vk_memory_import, NULL);
> + }
> + vkFreeMemory(vk_device, vk_memory, NULL);
> + CloseHandle(nt_handle);
> + }
> +
> + external_buffer_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR;
> +
> + memset(&external_buffer_properties, 0, sizeof(external_buffer_properties));
> + external_buffer_properties.sType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR;
> +
> + pfn_vkGetPhysicalDeviceExternalBufferPropertiesKHR(vk_physical_device, &external_buffer_info, &external_buffer_properties);
> +
> + if (!(external_buffer_properties.externalMemoryProperties.externalMemoryFeatures &
> + (VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)))
> + skip("With desired parameters, buffers are not exportable to and importable from a KMT handle.\n");
> + else
> + {
> + ok(external_buffer_properties.externalMemoryProperties.compatibleHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
> + "Unexpected compatibleHandleTypes %#x.\n", external_buffer_properties.externalMemoryProperties.compatibleHandleTypes);
> +
> + export_memory_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
> + export_memory_info.pNext = &dedicated_alloc_info;
> + export_memory_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR;
> +
> + alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
> + alloc_info.pNext = &export_memory_info;
> + alloc_info.allocationSize = 1;
> + alloc_info.memoryTypeIndex = find_memory_type(vk_physical_device, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
> +
> + ok(alloc_info.memoryTypeIndex != -1, "Device local memory type index was not found.\n");
> +
> + vr = vkAllocateMemory(vk_device, &alloc_info, NULL, &vk_memory);
> + ok(vr == VK_SUCCESS, "vkAllocateMemory failed, VkResult %d.\n", vr);
> +
> + get_handle_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR;
> + get_handle_info.pNext = NULL;
> + get_handle_info.memory = vk_memory;
> + get_handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR;
> +
> + vr = pfn_vkGetMemoryWin32HandleKHR(vk_device, &get_handle_info, &kmt_handle);
> + ok(vr == VK_SUCCESS, "vkGetMemoryWin32HandleKHR failed, VkResult %d.\n", vr);
> +
> + import_handle_info.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
> + import_handle_info.pNext = &dedicated_alloc_info;
> + import_handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR;
> + import_handle_info.handle = kmt_handle;
> + import_handle_info.name = NULL;
> +
> + alloc_info.pNext = &import_handle_info;
> +
> + vr = vkAllocateMemory(vk_device, &alloc_info, NULL, &vk_memory_import);
> + ok(vr == VK_SUCCESS, "vkAllocateMemory failed, VkResult %d.\n", vr);
> + ok(vk_memory_import != vk_memory, "Expected new memory object.\n");
> +
> + vkFreeMemory(vk_device, vk_memory_import, NULL);
> + vkFreeMemory(vk_device, vk_memory, NULL);
> + }
> +
> + vkDestroyBuffer(vk_device, vk_buffer, NULL);
> + vkDestroyDevice(vk_device, NULL);
> +}
> +
> +static void for_each_device(void (*test_func)(VkInstance,VkPhysicalDevice), uint32_t extension_count,
> + const char * const *enabled_extensions)
> {
> VkPhysicalDevice *vk_physical_devices;
> VkInstance vk_instance;
> @@ -445,7 +656,7 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice))
> uint32_t count;
> VkResult vr;
>
> - if ((vr = create_instance_skip(0, NULL, &vk_instance)) < 0)
> + if ((vr = create_instance_skip(extension_count, enabled_extensions, &vk_instance)) < 0)
> return;
> ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
>
> @@ -463,7 +674,7 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice))
> ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
>
> for (i = 0; i < count; ++i)
> - test_func(vk_physical_devices[i]);
> + test_func(vk_instance, vk_physical_devices[i]);
>
> heap_free(vk_physical_devices);
>
> @@ -472,13 +683,16 @@ static void for_each_device(void (*test_func)(VkPhysicalDevice))
>
> START_TEST(vulkan)
> {
> + static const char *external_memory_capabilities = "VK_KHR_external_memory_capabilities";
> +
> test_instance_version();
> - for_each_device(enumerate_physical_device);
> + for_each_device(enumerate_physical_device, 0, NULL);
> test_enumerate_physical_device2();
> - for_each_device(enumerate_device_queues);
> + for_each_device(enumerate_device_queues, 0, NULL);
> test_physical_device_groups();
> - for_each_device(test_destroy_command_pool);
> + for_each_device(test_destroy_command_pool, 0, NULL);
> test_unsupported_instance_extensions();
> - for_each_device(test_unsupported_device_extensions);
> - for_each_device(test_private_data);
> + for_each_device(test_unsupported_device_extensions, 0, NULL);
> + for_each_device(test_private_data, 0, NULL);
> + for_each_device(test_external_memory, 1, &external_memory_capabilities);
> }
> diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
> index 69fcd44160e..471999a3821 100644
> --- a/dlls/winevulkan/loader_thunks.c
> +++ b/dlls/winevulkan/loader_thunks.c
> @@ -1448,6 +1448,16 @@ VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalM
> return unix_funcs->p_vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
> }
>
> +VkResult WINAPI vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
> +{
> + return unix_funcs->p_vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
> +}
> +
> +VkResult WINAPI vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
> +{
> + return unix_funcs->p_vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
> +}
> +
> VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
> {
> return unix_funcs->p_vkGetPerformanceParameterINTEL(device, parameter, pValue);
> @@ -2223,6 +2233,8 @@ static const struct vulkan_func vk_device_dispatch_table[] =
> {"vkGetImageSparseMemoryRequirements2KHR", &vkGetImageSparseMemoryRequirements2KHR},
> {"vkGetImageSubresourceLayout", &vkGetImageSubresourceLayout},
> {"vkGetMemoryHostPointerPropertiesEXT", &vkGetMemoryHostPointerPropertiesEXT},
> + {"vkGetMemoryWin32HandleKHR", &vkGetMemoryWin32HandleKHR},
> + {"vkGetMemoryWin32HandlePropertiesKHR", &vkGetMemoryWin32HandlePropertiesKHR},
> {"vkGetPerformanceParameterINTEL", &vkGetPerformanceParameterINTEL},
> {"vkGetPipelineCacheData", &vkGetPipelineCacheData},
> {"vkGetPipelineExecutableInternalRepresentationsKHR", &vkGetPipelineExecutableInternalRepresentationsKHR},
> diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h
> index e7257cef508..031b7f5652b 100644
> --- a/dlls/winevulkan/loader_thunks.h
> +++ b/dlls/winevulkan/loader_thunks.h
> @@ -304,6 +304,8 @@ struct unix_funcs
> void (WINAPI *p_vkGetImageSparseMemoryRequirements2KHR)(VkDevice, const VkImageSparseMemoryRequirementsInfo2 *, uint32_t *, VkSparseImageMemoryRequirements2 *);
> void (WINAPI *p_vkGetImageSubresourceLayout)(VkDevice, VkImage, const VkImageSubresource *, VkSubresourceLayout *);
> VkResult (WINAPI *p_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *);
> + VkResult (WINAPI *p_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMemoryGetWin32HandleInfoKHR *, HANDLE *);
> + VkResult (WINAPI *p_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, HANDLE, VkMemoryWin32HandlePropertiesKHR *);
> VkResult (WINAPI *p_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *);
> VkResult (WINAPI *p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *);
> VkResult (WINAPI *p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *);
> diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
> index b1877acda17..0a0e3bac299 100755
> --- a/dlls/winevulkan/make_vulkan
> +++ b/dlls/winevulkan/make_vulkan
> @@ -99,7 +99,6 @@ UNSUPPORTED_EXTENSIONS = [
> "VK_EXT_pipeline_creation_feedback",
> "VK_GOOGLE_display_timing",
> "VK_KHR_external_fence_win32",
> - "VK_KHR_external_memory_win32",
> "VK_KHR_external_semaphore_win32",
> # Relates to external_semaphore and needs type conversions in bitflags.
> "VK_KHR_shared_presentable_image", # Needs WSI work.
> @@ -109,7 +108,6 @@ UNSUPPORTED_EXTENSIONS = [
> "VK_EXT_external_memory_dma_buf",
> "VK_EXT_image_drm_format_modifier",
> "VK_KHR_external_fence_fd",
> - "VK_KHR_external_memory_fd",
> "VK_KHR_external_semaphore_fd",
>
> # Extensions which require callback handling
> @@ -154,6 +152,8 @@ class ThunkType(Enum):
> # - PRIVATE thunks can be used in custom implementations for
> # struct conversion.
> # - loader_thunk sets whether to create a thunk for unix_funcs.
> +# - host_only sets whether to preclude the function from the
> +# win32-facing dispatch table.
> FUNCTION_OVERRIDES = {
> # Global functions
> "vkCreateInstance" : {"dispatch" : False, "driver" : True, "thunk" : ThunkType.NONE, "loader_thunk" : ThunkType.PRIVATE},
> @@ -169,7 +169,7 @@ FUNCTION_OVERRIDES = {
> "vkEnumerateDeviceLayerProperties": {"dispatch": True, "driver": False, "thunk": ThunkType.NONE},
> "vkEnumeratePhysicalDeviceGroups" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkEnumeratePhysicalDevices" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> - "vkGetPhysicalDeviceExternalBufferProperties" : {"dispatch" : False, "driver" : False, "thunk" : ThunkType.NONE},
> + "vkGetPhysicalDeviceExternalBufferProperties" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.PRIVATE},
> "vkGetPhysicalDeviceExternalFenceProperties" : {"dispatch" : False, "driver" : False, "thunk" : ThunkType.NONE},
> "vkGetPhysicalDeviceExternalSemaphoreProperties" : {"dispatch" : False, "driver" : False, "thunk" : ThunkType.NONE},
> "vkGetPhysicalDeviceImageFormatProperties2" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.PRIVATE},
> @@ -178,11 +178,13 @@ FUNCTION_OVERRIDES = {
>
> # Device functions
> "vkAllocateCommandBuffers" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> + "vkAllocateMemory" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkCmdExecuteCommands" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkCreateCommandPool" : {"dispatch": True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkDestroyCommandPool" : {"dispatch": True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkDestroyDevice" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkFreeCommandBuffers" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> + "vkFreeMemory" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkGetDeviceProcAddr" : {"dispatch" : False, "driver" : True, "thunk" : ThunkType.NONE, "loader_thunk" : ThunkType.NONE},
> "vkGetDeviceQueue" : {"dispatch": True, "driver" : False, "thunk" : ThunkType.NONE},
> "vkGetDeviceQueue2" : {"dispatch": True, "driver" : False, "thunk" : ThunkType.NONE},
> @@ -213,7 +215,7 @@ FUNCTION_OVERRIDES = {
> "vkGetPhysicalDeviceExternalFencePropertiesKHR" : {"dispatch" : False, "driver" : False, "thunk" : ThunkType.NONE},
>
> # VK_KHR_external_memory_capabilities
> - "vkGetPhysicalDeviceExternalBufferPropertiesKHR" : {"dispatch" : False, "driver" : False, "thunk" : ThunkType.NONE},
> + "vkGetPhysicalDeviceExternalBufferPropertiesKHR" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.PRIVATE},
> "vkGetPhysicalDeviceImageFormatProperties2KHR" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.PRIVATE},
>
> # VK_KHR_external_semaphore_capabilities
> @@ -249,12 +251,22 @@ FUNCTION_OVERRIDES = {
> # VK_EXT_debug_marker
> "vkDebugMarkerSetObjectNameEXT" : {"dispatch": True, "driver" : False, "thunk" : ThunkType.PRIVATE},
> "vkDebugMarkerSetObjectTagEXT" : {"dispatch": True, "driver" : False, "thunk" : ThunkType.PRIVATE},
> +
> + # VK_KHR_external_memory_win32
> + "vkGetMemoryWin32HandleKHR" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> + "vkGetMemoryWin32HandlePropertiesKHR" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE},
> +
> + # VK_KHR_external_memory_fd
> + "vkGetMemoryFdKHR" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE, "host_only" : True},
> + "vkGetMemoryFdPropertiesKHR" : {"dispatch" : True, "driver" : False, "thunk" : ThunkType.NONE, "host_only" : True},
Would it make sense to added a new value to ThunkType instead, e.g.
ThunkType.NOT_EXPOSED?
> }
>
> -STRUCT_CHAIN_CONVERSIONS = [
> - "VkDeviceCreateInfo",
> - "VkInstanceCreateInfo",
> -]
> +STRUCT_CHAIN_CONVERSIONS = {
> + "VkDeviceCreateInfo": ["VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"],
> + "VkInstanceCreateInfo": ["VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"],
> + "VkPhysicalDeviceImageFormatInfo2": [],
> + "VkMemoryAllocateInfo": ["VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR", "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"],
> +}
>
>
> class Direction(Enum):
> @@ -532,6 +544,7 @@ class VkFunction(object):
> self.driver = func_info["driver"] if func_info else False
> self.thunk_type = func_info["thunk"] if func_info else ThunkType.PUBLIC
> self.loader_thunk_type = func_info["loader_thunk"] if func_info and "loader_thunk" in func_info else ThunkType.PUBLIC
> + self.host_only = func_info["host_only"] if func_info and "host_only" in func_info else False
>
> # Required is set while parsing which APIs and types are required
> # and is used by the code generation.
> @@ -651,6 +664,9 @@ class VkFunction(object):
> def needs_private_thunk(self):
> return self.thunk_type == ThunkType.PRIVATE
>
> + def needs_win_exclusion(self):
> + return self.host_only
> +
> def pfn(self, prefix="p", call_conv=None, conv=False):
> """ Create function pointer. """
>
> @@ -1028,6 +1044,8 @@ class VkHandle(object):
> return "wine_debug_report_callback_from_handle({0})->debug_callback".format(name)
> if self.name == "VkSurfaceKHR":
> return "wine_surface_from_handle({0})->surface".format(name)
> + if self.name == "VkDeviceMemory":
> + return "wine_dev_mem_from_handle({0})->dev_mem".format(name)
>
> native_handle_name = None
>
> @@ -2115,9 +2133,10 @@ class FreeFunction(object):
>
>
> class StructChainConversionFunction(object):
> - def __init__(self, direction, struct):
> + def __init__(self, direction, struct, ignores):
> self.direction = direction
> self.struct = struct
> + self.ignores = ignores
> self.type = struct.name
>
> self.name = "convert_{0}_struct_chain".format(self.type)
> @@ -2143,8 +2162,8 @@ class StructChainConversionFunction(object):
> body += " {\n"
>
> # Ignore to not confuse host loader.
This comment is now misplaced.
> - body += " case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:\n"
> - body += " case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:\n"
> + for i in self.ignores:
> + body += " case {0}:\n".format(i)
> body += " break;\n\n"
>
> for e in self.struct.struct_extensions:
> @@ -2153,6 +2172,9 @@ class StructChainConversionFunction(object):
>
> stype = next(x for x in e.members if x.name == "sType")
>
> + if stype.values in self.ignores:
> + continue
> +
> body += " case {0}:\n".format(stype.values)
> body += " {\n"
>
> @@ -2250,7 +2272,7 @@ class VkGenerator(object):
>
> for struct in self.registry.structs:
> if struct.name in STRUCT_CHAIN_CONVERSIONS:
> - self.struct_chain_conversions.append(StructChainConversionFunction(Direction.INPUT, struct))
> + self.struct_chain_conversions.append(StructChainConversionFunction(Direction.INPUT, struct, STRUCT_CHAIN_CONVERSIONS[struct.name]))
> self.struct_chain_conversions.append(FreeStructChainFunction(struct))
>
> def _generate_copyright(self, f, spec_file=False):
> @@ -2292,6 +2314,9 @@ class VkGenerator(object):
> if not vk_func.is_required():
> continue
>
> + if vk_func.needs_win_exclusion():
> + continue
> +
> if vk_func.is_global_func():
> continue
>
> @@ -2382,6 +2407,8 @@ class VkGenerator(object):
> for vk_func in self.registry.funcs.values():
> if not vk_func.is_required():
> continue
> + if vk_func.needs_win_exclusion():
> + continue
> if vk_func.loader_thunk_type == ThunkType.NONE:
> continue
>
> @@ -2403,6 +2430,8 @@ class VkGenerator(object):
> continue
> if vk_func.needs_thunk() and not vk_func.needs_private_thunk():
> continue
> + if vk_func.needs_win_exclusion():
> + continue
>
> if vk_func.is_core_func():
> f.write("{0};\n".format(vk_func.prototype("WINAPI", prefix=prefix)))
> @@ -2510,6 +2539,8 @@ class VkGenerator(object):
> for vk_func in self.registry.funcs.values():
> if not vk_func.is_required():
> continue
> + if vk_func.needs_win_exclusion():
> + continue
> if vk_func.loader_thunk_type != ThunkType.PUBLIC:
> continue
>
> @@ -2519,6 +2550,8 @@ class VkGenerator(object):
> for vk_func in self.registry.device_funcs:
> if not vk_func.is_required():
> continue
> + if vk_func.needs_win_exclusion():
> + continue
>
> f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name))
> f.write("};\n\n")
> @@ -2527,6 +2560,8 @@ class VkGenerator(object):
> for vk_func in self.registry.phys_dev_funcs:
> if not vk_func.is_required():
> continue
> + if vk_func.needs_win_exclusion():
> + continue
>
> f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name))
> f.write("};\n\n")
> @@ -2535,6 +2570,8 @@ class VkGenerator(object):
> for vk_func in self.registry.instance_funcs:
> if not vk_func.is_required():
> continue
> + if vk_func.needs_win_exclusion():
> + continue
>
> f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name))
> f.write("};\n\n")
> @@ -2592,6 +2629,8 @@ class VkGenerator(object):
> for vk_func in self.registry.funcs.values():
> if not vk_func.is_required():
> continue
> + if vk_func.needs_win_exclusion():
> + continue
> if vk_func.loader_thunk_type == ThunkType.NONE:
> continue
>
> diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c
> index 45eda78e997..e95860cb3fa 100644
> --- a/dlls/winevulkan/vulkan.c
> +++ b/dlls/winevulkan/vulkan.c
> @@ -25,6 +25,7 @@
> #include <time.h>
> #include <stdarg.h>
> #include <stdlib.h>
> +#include <unistd.h>
>
> #include "ntstatus.h"
> #define WIN32_NO_STATUS
> @@ -34,6 +35,8 @@
> #include "winuser.h"
> #include "winternl.h"
>
> +#include "wine/server.h"
> +
> #include "vulkan_private.h"
>
> WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
> @@ -265,6 +268,14 @@ static struct VkPhysicalDevice_T *wine_vk_physical_device_alloc(struct VkInstanc
> {
> if (wine_vk_device_extension_supported(host_properties[i].extensionName))
> {
> + if (!strcmp(host_properties[i].extensionName, "VK_KHR_external_memory_fd"))
> + {
> + TRACE("Substituting VK_KHR_external_memory_fd for VK_KHR_external_memory_win32\n");
> +
> + snprintf(host_properties[i].extensionName, sizeof(host_properties[i].extensionName),
> + VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
> + host_properties[i].specVersion = VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION;
> + }
> TRACE("Enabling extension '%s' for physical device %p\n", host_properties[i].extensionName, object);
> num_properties++;
> }
> @@ -368,12 +379,16 @@ static void wine_vk_device_free_create_info(VkDeviceCreateInfo *create_info)
> }
>
> free_VkDeviceCreateInfo_struct_chain(create_info);
> +
> + if (create_info->enabledExtensionCount)
> + free((void *)create_info->ppEnabledExtensionNames);
> }
>
> static VkResult wine_vk_device_convert_create_info(const VkDeviceCreateInfo *src,
> VkDeviceCreateInfo *dst)
> {
> VkDeviceGroupDeviceCreateInfo *group_info;
> + const char **enabled_extensions;
> unsigned int i;
> VkResult res;
>
> @@ -406,6 +421,39 @@ static VkResult wine_vk_device_convert_create_info(const VkDeviceCreateInfo *src
> dst->enabledLayerCount = 0;
> dst->ppEnabledLayerNames = NULL;
>
> + if (src->enabledExtensionCount > 0)
> + {
> + enabled_extensions = calloc(src->enabledExtensionCount, sizeof(*src->ppEnabledExtensionNames));
> + if (!enabled_extensions)
> + {
> + if ((group_info = wine_vk_find_struct(dst, DEVICE_GROUP_DEVICE_CREATE_INFO)))
> + free((void *)group_info->pPhysicalDevices);
> + free_VkDeviceCreateInfo_struct_chain(dst);
> + return VK_ERROR_OUT_OF_HOST_MEMORY;
> + }
> +
> + for (i = 0; i < src->enabledExtensionCount; i++)
> + {
> + if (!strcmp(src->ppEnabledExtensionNames[i], "VK_KHR_external_memory_fd"))
> + {
> + if ((group_info = wine_vk_find_struct(dst, DEVICE_GROUP_DEVICE_CREATE_INFO)))
> + free((void *)group_info->pPhysicalDevices);
> + free_VkDeviceCreateInfo_struct_chain(dst);
> + free(enabled_extensions);
> + return VK_ERROR_EXTENSION_NOT_PRESENT;
> + }
Why do you check this? It shouldn't be exposed to the app in any way.
> + else if (!strcmp(src->ppEnabledExtensionNames[i], "VK_KHR_external_memory_win32"))
> + {
> + enabled_extensions[i] = "VK_KHR_external_memory_fd";
> + }
> + else
> + {
> + enabled_extensions[i] = src->ppEnabledExtensionNames[i];
> + }
> + }
> + dst->ppEnabledExtensionNames = enabled_extensions;
> + }
> +
> TRACE("Enabled %u extensions.\n", dst->enabledExtensionCount);
> for (i = 0; i < dst->enabledExtensionCount; i++)
> {
> @@ -1300,57 +1348,106 @@ void WINAPI wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice
> void WINAPI wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice phys_dev,
> const VkPhysicalDeviceExternalBufferInfo *buffer_info, VkExternalBufferProperties *properties)
> {
> + VkPhysicalDeviceExternalBufferInfo buffer_info_dup = *buffer_info;
> +
> TRACE("%p, %p, %p\n", phys_dev, buffer_info, properties);
> - memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
> +
> + if (buffer_info_dup.handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT)
> + buffer_info_dup.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> +
> + thunk_vkGetPhysicalDeviceExternalBufferProperties(phys_dev, &buffer_info_dup, properties);
> +
> + if (properties->externalMemoryProperties.exportFromImportedHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
> + properties->externalMemoryProperties.exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
> + if (properties->externalMemoryProperties.compatibleHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
> + properties->externalMemoryProperties.compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
> }
>
> void WINAPI wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice phys_dev,
> const VkPhysicalDeviceExternalBufferInfo *buffer_info, VkExternalBufferProperties *properties)
> {
> + VkPhysicalDeviceExternalBufferInfo buffer_info_dup = *buffer_info;
> +
> TRACE("%p, %p, %p\n", phys_dev, buffer_info, properties);
> - memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
> +
> + if (buffer_info_dup.handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT)
> + buffer_info_dup.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> +
> + thunk_vkGetPhysicalDeviceExternalBufferPropertiesKHR(phys_dev, &buffer_info_dup, properties);
> +
> + if (properties->externalMemoryProperties.exportFromImportedHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
> + properties->externalMemoryProperties.exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
> + if (properties->externalMemoryProperties.compatibleHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
> + properties->externalMemoryProperties.compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
> }
>
> -VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice phys_dev,
> +static VkResult wine_vk_get_physical_device_image_format_properties_2(VkPhysicalDevice phys_dev,
> + VkResult (*p_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice, const VkPhysicalDeviceImageFormatInfo2 *, VkImageFormatProperties2 *),
vkGetPhysicalDeviceImageFormatProperties2KHR and
vkGetPhysicalDeviceImageFormatProperties2 are equivalent, you should
just always use thunk_vkGetPhysicalDeviceImageFormatProperties2.
> const VkPhysicalDeviceImageFormatInfo2 *format_info, VkImageFormatProperties2 *properties)
> {
> + VkPhysicalDeviceExternalImageFormatInfo *external_image_info_host = NULL;
> + const VkPhysicalDeviceExternalImageFormatInfo *external_image_info;
> + VkPhysicalDeviceImageFormatInfo2 format_info_host = *format_info;
> VkExternalImageFormatProperties *external_image_properties;
> VkResult res;
>
> - TRACE("%p, %p, %p\n", phys_dev, format_info, properties);
> + if ((external_image_info = wine_vk_find_struct(format_info, PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO)))
> + {
> + if (external_image_info->handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT)
> + {
> + if ((res = convert_VkPhysicalDeviceImageFormatInfo2_struct_chain(format_info->pNext, &format_info_host)) < 0)
> + {
> + WARN("Failed to convert VkPhysicalDeviceImageFormatInfo2 pNext chain, res=%d.\n", res);
> + return res;
> + }
> +
> + external_image_info_host = wine_vk_find_struct(&format_info_host, PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
> + external_image_info_host->handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> + }
> + if (external_image_info->handleType &~ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT)
> + {
> + WARN("Unsupported handle type %#x.\n", external_image_info->handleType);
> + return VK_ERROR_FORMAT_NOT_SUPPORTED;
> + }
> + }
> +
> + res = p_vkGetPhysicalDeviceImageFormatProperties2(phys_dev, &format_info_host, properties);
>
> - res = thunk_vkGetPhysicalDeviceImageFormatProperties2(phys_dev, format_info, properties);
> + if (external_image_info_host)
> + free_VkPhysicalDeviceImageFormatInfo2_struct_chain(&format_info_host);
>
> if ((external_image_properties = wine_vk_find_struct(properties, EXTERNAL_IMAGE_FORMAT_PROPERTIES)))
> {
> VkExternalMemoryProperties *p = &external_image_properties->externalMemoryProperties;
> - p->externalMemoryFeatures = 0;
> - p->exportFromImportedHandleTypes = 0;
> - p->compatibleHandleTypes = 0;
> + if (p->exportFromImportedHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
> + {
> + p->exportFromImportedHandleTypes &= ~VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> + p->exportFromImportedHandleTypes |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
> + }
> + if (p->compatibleHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
> + {
> + p->compatibleHandleTypes &= ~VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> + p->compatibleHandleTypes |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
> + } > }
>
> return res;
> }
>
> -VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phys_dev,
> +VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice phys_dev,
> const VkPhysicalDeviceImageFormatInfo2 *format_info, VkImageFormatProperties2 *properties)
> {
> - VkExternalImageFormatProperties *external_image_properties;
> - VkResult res;
> -
> TRACE("%p, %p, %p\n", phys_dev, format_info, properties);
>
> - res = thunk_vkGetPhysicalDeviceImageFormatProperties2KHR(phys_dev, format_info, properties);
> + return wine_vk_get_physical_device_image_format_properties_2(phys_dev, thunk_vkGetPhysicalDeviceImageFormatProperties2, format_info, properties);
> +}
>
> - if ((external_image_properties = wine_vk_find_struct(properties, EXTERNAL_IMAGE_FORMAT_PROPERTIES)))
> - {
> - VkExternalMemoryProperties *p = &external_image_properties->externalMemoryProperties;
> - p->externalMemoryFeatures = 0;
> - p->exportFromImportedHandleTypes = 0;
> - p->compatibleHandleTypes = 0;
> - }
> +VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phys_dev,
> + const VkPhysicalDeviceImageFormatInfo2 *format_info, VkImageFormatProperties2 *properties)
> +{
> + TRACE("%p, %p, %p\n", phys_dev, format_info, properties);
>
> - return res;
> + return wine_vk_get_physical_device_image_format_properties_2(phys_dev, thunk_vkGetPhysicalDeviceImageFormatProperties2KHR, format_info, properties);
> }
>
> /* From ntdll/unix/sync.c */
> @@ -1860,3 +1957,249 @@ VkResult WINAPI wine_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebu
>
> return thunk_vkDebugMarkerSetObjectNameEXT(device, &wine_name_info);
> }
> +
> +static HANDLE create_video_resource(int fd, LPCWSTR name)
> +{
> + HANDLE ret = INVALID_HANDLE_VALUE;
> +
> + if (name)
> + FIXME("Naming video resources not supported.\n");
> +
> + wine_server_fd_to_handle(fd, GENERIC_ALL, 0, &ret);
> +
> + return ret;
> +}
> +
> +VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *allocate_info,
> + const VkAllocationCallbacks *allocator, VkDeviceMemory *memory_out)
> +{
> + const VkImportMemoryWin32HandleInfoKHR *handle_import_info = NULL;
> + const VkExportMemoryWin32HandleInfoKHR *handle_export_info = NULL;
> + VkMemoryAllocateInfo allocate_info_dup = *allocate_info;
> + VkExportMemoryAllocateInfo *export_info = NULL;
> + VkImportMemoryFdInfoKHR fd_import_info;
> + const VkBaseOutStructure *header;
> + struct wine_dev_mem *object;
> + VkResult res;
> + int fd;
> +
> +#if defined(USE_STRUCT_CONVERSION)
> + VkMemoryAllocateInfo_host allocate_info_host;
> + VkMemoryGetFdInfoKHR_host get_fd_info;
> +#else
> + VkMemoryAllocateInfo allocate_info_host;
> + VkMemoryGetFdInfoKHR get_fd_info;
> +#endif
> +
> + TRACE("%p %p %p %p\n", device, allocate_info, allocator, memory_out);
> +
> + if (allocator)
> + FIXME("Support for allocation callbacks not implemented yet\n");
> +
> + if ((res = convert_VkMemoryAllocateInfo_struct_chain(allocate_info->pNext, &allocate_info_dup)) < 0)
> + {
> + WARN("Failed to convert VkMemoryAllocateInfo pNext chain, res=%d.\n", res);
> + return res;
> + }
> +
> + if (!(object = calloc(1, sizeof(*object))))
> + {
> + free_VkMemoryAllocateInfo_struct_chain(&allocate_info_dup);
> + return VK_ERROR_OUT_OF_HOST_MEMORY;
> + }
> +
> + object->dev_mem = VK_NULL_HANDLE;
> + object->handle = INVALID_HANDLE_VALUE;
> + fd_import_info.fd = -1;
> + fd_import_info.pNext = NULL;
> +
> + /* find and process handle import/export info and grab it */
> + for (header = allocate_info->pNext; header; header = header->pNext)
> + {
> + switch (header->sType)
> + {
> + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
> + handle_import_info = (const VkImportMemoryWin32HandleInfoKHR *)header;
> + break;
> + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
> + handle_export_info = (const VkExportMemoryWin32HandleInfoKHR *)header;
> + if (handle_export_info->pAttributes && handle_export_info->pAttributes->lpSecurityDescriptor)
> + FIXME("Support for custom security descriptor not implemented.\n");
> + break;
> + default:
> + break;
> + }
> + }
IMO you should just wine_vk_find_struct twice here.
> +
> + for (header = allocate_info_dup.pNext; header; header = header->pNext)
> + {
> + if (header->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO)
> + {
> + export_info = (VkExportMemoryAllocateInfo *)header;
> + object->handle_types = export_info->handleTypes;
> + if (object->handle_types &~ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT)
> + {
> + res = VK_ERROR_OUT_OF_HOST_MEMORY;
Why VK_ERROR_OUT_OF_HOST_MEMORY?
> + goto done;
> + }
> + if (object->handle_types)
> + export_info->handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> + break;
> + }
> + }
> +
> + /* Important to note is that Vulkan does consume imported FDs, but it doesn't consume imported HANDLEs */
> + if (handle_import_info)
> + {
> + fd_import_info.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR;
> + fd_import_info.pNext = allocate_info_dup.pNext;
> + fd_import_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> +
> + switch (handle_import_info->handleType)
> + {
> + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
> + if (handle_import_info->handle)
> + NtDuplicateObject( NtCurrentProcess(), handle_import_info->handle, NtCurrentProcess(), &object->handle, 0, 0, DUPLICATE_SAME_ACCESS );
> + else if (handle_import_info->name)
> + FIXME("Importing device memory by resource name not supported.\n");
> + break;
> + default:
> + WARN("Invalid handle type %08x passed in.\n", handle_import_info->handleType);
> + res = VK_ERROR_INVALID_EXTERNAL_HANDLE;
> + goto done;
> + }
> +
> + if (object->handle != INVALID_HANDLE_VALUE)
> + wine_server_handle_to_fd(object->handle, FILE_READ_DATA, &fd_import_info.fd, NULL);
> +
> + if (fd_import_info.fd == -1)
> + {
> + TRACE("Couldn't access resource handle or name. type=%08x handle=%p name=%s\n", handle_import_info->handleType, handle_import_info->handle,
> + handle_import_info->name ? debugstr_w(handle_import_info->name) : "");
> + res = VK_ERROR_INVALID_EXTERNAL_HANDLE;
> + goto done;
> + }
> + }
> +
> + allocate_info_host.sType = allocate_info_dup.sType;
> + allocate_info_host.pNext = fd_import_info.fd == -1 ? allocate_info_dup.pNext : &fd_import_info;
> + allocate_info_host.allocationSize = allocate_info_dup.allocationSize;
> + allocate_info_host.memoryTypeIndex = allocate_info_dup.memoryTypeIndex;
> +
> + if ((res = device->funcs.p_vkAllocateMemory(device->device, &allocate_info_host, NULL, &object->dev_mem)) == VK_SUCCESS)
> + {
> + if (object->handle == INVALID_HANDLE_VALUE && export_info && export_info->handleTypes)
> + {
> + get_fd_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
> + get_fd_info.pNext = NULL;
> + get_fd_info.memory = object->dev_mem;
> + get_fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
> +
> + if (device->funcs.p_vkGetMemoryFdKHR(device->device, &get_fd_info, &fd) == VK_SUCCESS)
> + {
> + object->handle = create_video_resource(fd, handle_export_info ? handle_export_info->name : NULL);
> + object->access = handle_export_info ? handle_export_info->dwAccess : GENERIC_ALL;
> + if (handle_export_info && handle_export_info->pAttributes)
> + object->inherit = handle_export_info->pAttributes->bInheritHandle;
> + else
> + object->inherit = FALSE;
> + close(fd);
> + }
> +
> + if (object->handle == INVALID_HANDLE_VALUE)
> + {
> + res = VK_ERROR_OUT_OF_HOST_MEMORY;
> + goto done;
> + }
> + }
> +
> + *memory_out = wine_dev_mem_to_handle(object);
You should call WINE_VK_ADD_NON_DISPATCHABLE_MAPPING here, and
WINE_VK_REMOVE_HANDLE_MAPPING in vkFreeMemory.
> + }
> +
> + done:
> +
> + if (res != VK_SUCCESS)
> + {
> + if (object->dev_mem != VK_NULL_HANDLE)
> + device->funcs.p_vkFreeMemory(device->device, object->dev_mem, NULL);
No need to check for VK_NULL_HANDLE here, vkFreeMemory already does that.
> + if (fd_import_info.fd != -1)
> + close(fd_import_info.fd);
> + if (object->handle != INVALID_HANDLE_VALUE)
> + NtClose(object->handle);
> + free(object);
> + }
> +
> + free_VkMemoryAllocateInfo_struct_chain(&allocate_info_dup);
> +
> + return res;
> +}
> +
> +VkResult WINAPI wine_vkGetMemoryWin32HandleKHR(VkDevice device,
> + const VkMemoryGetWin32HandleInfoKHR *handle_info, HANDLE *handle)
> +{
> + struct wine_dev_mem *dev_mem = wine_dev_mem_from_handle(handle_info->memory);
> + const VkBaseInStructure *chain;
> +
> + TRACE("%p, %p %p\n", device, handle_info, handle);
> +
> + if (!(dev_mem->handle_types & handle_info->handleType))
> + return VK_ERROR_OUT_OF_HOST_MEMORY;
> +
> + if ((chain = handle_info->pNext))
> + FIXME("Ignoring a linked structure of type %u.\n", chain->sType);
> +
> + switch(handle_info->handleType)
> + {
> + case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
> + return !NtDuplicateObject( NtCurrentProcess(), dev_mem->handle, NtCurrentProcess(), handle, dev_mem->access, dev_mem->inherit ? OBJ_INHERIT : 0, 0) ?
> + VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
> + default:
> + return VK_ERROR_UNKNOWN;
> + }
> +}
> +
> +void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory handle, const VkAllocationCallbacks *allocator)
> +{
> + struct wine_dev_mem *dev_mem = wine_dev_mem_from_handle(handle);
> +
> + TRACE("%p 0x%s, %p\n", device, wine_dbgstr_longlong(handle), allocator);
> +
> + if (allocator)
> + FIXME("Support for allocation callbacks not implemented yet\n");
> +
> + device->funcs.p_vkFreeMemory(device->device, dev_mem->dev_mem, NULL);
> + if (dev_mem->handle != INVALID_HANDLE_VALUE)
> + NtClose(dev_mem->handle);
> + free(dev_mem);
> +}
> +
> +VkResult WINAPI wine_vkGetMemoryWin32HandlePropertiesKHR(VkDevice device,
> + VkExternalMemoryHandleTypeFlagBits type, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *properties)
> +{
> + VkMemoryFdPropertiesKHR fd_props;
> + VkResult res;
> + int fd = -1;
> +
> + TRACE("%p %u %p %p\n", device, type, handle, properties);
> +
> + if (type == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT)
VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666
handleType must not be one of the handle types defined as opaque
> + {
> + wine_server_handle_to_fd(handle, FILE_READ_DATA, &fd, NULL);
> + }
> +
> + if (fd == -1)
> + return VK_ERROR_INVALID_EXTERNAL_HANDLE;
> +
> + res = device->funcs.p_vkGetMemoryFdPropertiesKHR(device->device, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, fd, &fd_props);
VUID-vkGetMemoryFdPropertiesKHR-handleType-00674
handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR
And you have to init the sType and pNext of fd_props.
> +
> + close(fd);
> +
> + if (res != VK_SUCCESS)
> + return res;
> +
> + properties->sType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR;
> + properties->pNext = NULL;
You shouldn't touch those two, the application will set them.
> + properties->memoryTypeBits = fd_props.memoryTypeBits;
> +
> + return res;
> +}
> diff --git a/dlls/winevulkan/vulkan_private.h b/dlls/winevulkan/vulkan_private.h
> index 83dc90ca15e..468ab890dab 100644
> --- a/dlls/winevulkan/vulkan_private.h
> +++ b/dlls/winevulkan/vulkan_private.h
> @@ -204,6 +204,28 @@ static inline VkSurfaceKHR wine_surface_to_handle(struct wine_surface *surface)
> return (VkSurfaceKHR)(uintptr_t)surface;
> }
>
> +struct wine_dev_mem
> +{
> + VkDeviceMemory dev_mem;
> +
> + VkExternalMemoryHandleTypeFlagBits handle_types;
> +
> + BOOL inherit;
> + DWORD access;
> +
> + HANDLE handle;
> +};
> +
Wrapping VkDeviceMemory is problematic, because generated thunks won't
unwrap handles in struct parameters. With this code functions using
these structs will be broken:
VkBindAccelerationStructureMemoryInfoNV, VkBindBufferMemoryInfo,
VkBindImageMemoryInfo, VkDeviceMemoryOpaqueCaptureAddressInfo,
VkMappedMemoryRange, VkSparseImageMemoryBind, VkSparseMemoryBind
So you either have to either:
1. Manually implement all those functions.
2. Handle it in make_vulkan.
3. Find another way to store data per VkDeviceMemory object, e.g with
VK_EXT_private_data.
I'm against the first option because it's a lot of manually written
functions and future spec updates might add new problematic functions.
The provisional video extensions add VkVideoBindMemoryKHR for example.
The best option would be the second, if you can make it work, because we
currently have some code in vulkan.c that should be generated but has
the same problem.
Thanks,
Georg Lehmann
> +static inline struct wine_dev_mem *wine_dev_mem_from_handle(VkDeviceMemory handle)
> +{
> + return (struct wine_dev_mem *)(uintptr_t)handle;
> +}
> +
> +static inline VkDeviceMemory wine_dev_mem_to_handle(struct wine_dev_mem *dev_mem)
> +{
> + return (VkDeviceMemory)(uintptr_t)dev_mem;
> +}
> +
> BOOL wine_vk_device_extension_supported(const char *name) DECLSPEC_HIDDEN;
> BOOL wine_vk_instance_extension_supported(const char *name) DECLSPEC_HIDDEN;
>
>
More information about the wine-devel
mailing list