From: Rémi Bernon rbernon@codeweavers.com
--- dlls/win32u/vulkan.c | 71 ++++++++++++ dlls/winevulkan/loader_thunks.c | 25 ++++ dlls/winevulkan/loader_thunks.h | 17 +++ dlls/winevulkan/make_vulkan | 12 +- dlls/winevulkan/vulkan_thunks.c | 194 +++++++++++++++++++++++++++++++- include/wine/vulkan.h | 41 +++++++ include/wine/vulkan_driver.h | 8 +- 7 files changed, 358 insertions(+), 10 deletions(-)
diff --git a/dlls/win32u/vulkan.c b/dlls/win32u/vulkan.c index 6baed63fecd..31768d5483e 100644 --- a/dlls/win32u/vulkan.c +++ b/dlls/win32u/vulkan.c @@ -1191,6 +1191,71 @@ static void win32u_vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDev instance->p_vkGetPhysicalDeviceExternalSemaphoreProperties( physical_device->host.physical_device, semaphore_info, semaphore_properties ); }
+static VkResult win32u_vkCreateFence( VkDevice client_device, const VkFenceCreateInfo *client_create_info, const VkAllocationCallbacks *allocator, VkFence *ret ) +{ + VkFenceCreateInfo *create_info = (VkFenceCreateInfo *)client_create_info; /* cast away const, chain has been copied in the thunks */ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + VkBaseOutStructure **next, *prev = (VkBaseOutStructure *)create_info; + + TRACE( "device %p, create_info %p, allocator %p, ret %p\n", device, create_info, allocator, ret ); + + for (next = &prev->pNext; *next; prev = *next, next = &(*next)->pNext) + { + switch ((*next)->sType) + { + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + FIXME( "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO not implemented.\n" ); + *next = (*next)->pNext; next = &prev; + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + FIXME( "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR not implemented.\n" ); + *next = (*next)->pNext; next = &prev; + break; + default: FIXME( "Unhandled sType %u.\n", (*next)->sType ); break; + } + } + + return device->p_vkCreateFence( device->host.device, create_info, NULL /* allocator */, ret ); +} + +static void win32u_vkDestroyFence( VkDevice client_device, VkFence fence, const VkAllocationCallbacks *allocator ) +{ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + + TRACE( "device %p, fence %s, allocator %p\n", device, wine_dbgstr_longlong(fence), allocator ); + + return device->p_vkDestroyFence( device->host.device, fence, allocator ); +} + +static VkResult win32u_vkGetFenceWin32HandleKHR( VkDevice client_device, const VkFenceGetWin32HandleInfoKHR *handle_info, HANDLE *handle ) +{ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + + FIXME( "device %p, handle_info %p, handle %p stub!\n", device, handle_info, handle ); + + return VK_ERROR_INCOMPATIBLE_DRIVER; +} + +static VkResult win32u_vkImportFenceWin32HandleKHR( VkDevice client_device, const VkImportFenceWin32HandleInfoKHR *handle_info ) +{ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + + FIXME( "device %p, handle_info %p stub!\n", device, handle_info ); + + return VK_ERROR_INCOMPATIBLE_DRIVER; +} + +static void win32u_vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice client_physical_device, const VkPhysicalDeviceExternalFenceInfo *fence_info, + VkExternalFenceProperties *fence_properties ) +{ + struct vulkan_physical_device *physical_device = vulkan_physical_device_from_handle( client_physical_device ); + struct vulkan_instance *instance = physical_device->instance; + + TRACE( "physical_device %p, fence_info %p, fence_properties %p\n", physical_device, fence_info, fence_properties ); + + instance->p_vkGetPhysicalDeviceExternalFenceProperties( physical_device->host.physical_device, fence_info, fence_properties ); +} + static const char *win32u_get_host_surface_extension(void) { return driver_funcs->p_get_host_surface_extension(); @@ -1202,10 +1267,12 @@ static struct vulkan_funcs vulkan_funcs = .p_vkAcquireNextImageKHR = win32u_vkAcquireNextImageKHR, .p_vkAllocateMemory = win32u_vkAllocateMemory, .p_vkCreateBuffer = win32u_vkCreateBuffer, + .p_vkCreateFence = win32u_vkCreateFence, .p_vkCreateImage = win32u_vkCreateImage, .p_vkCreateSemaphore = win32u_vkCreateSemaphore, .p_vkCreateSwapchainKHR = win32u_vkCreateSwapchainKHR, .p_vkCreateWin32SurfaceKHR = win32u_vkCreateWin32SurfaceKHR, + .p_vkDestroyFence = win32u_vkDestroyFence, .p_vkDestroySemaphore = win32u_vkDestroySemaphore, .p_vkDestroySurfaceKHR = win32u_vkDestroySurfaceKHR, .p_vkDestroySwapchainKHR = win32u_vkDestroySwapchainKHR, @@ -1213,10 +1280,13 @@ static struct vulkan_funcs vulkan_funcs = .p_vkGetDeviceBufferMemoryRequirements = win32u_vkGetDeviceBufferMemoryRequirements, .p_vkGetDeviceBufferMemoryRequirementsKHR = win32u_vkGetDeviceBufferMemoryRequirements, .p_vkGetDeviceImageMemoryRequirements = win32u_vkGetDeviceImageMemoryRequirements, + .p_vkGetFenceWin32HandleKHR = win32u_vkGetFenceWin32HandleKHR, .p_vkGetMemoryWin32HandleKHR = win32u_vkGetMemoryWin32HandleKHR, .p_vkGetMemoryWin32HandlePropertiesKHR = win32u_vkGetMemoryWin32HandlePropertiesKHR, .p_vkGetPhysicalDeviceExternalBufferProperties = win32u_vkGetPhysicalDeviceExternalBufferProperties, .p_vkGetPhysicalDeviceExternalBufferPropertiesKHR = win32u_vkGetPhysicalDeviceExternalBufferProperties, + .p_vkGetPhysicalDeviceExternalFenceProperties = win32u_vkGetPhysicalDeviceExternalFenceProperties, + .p_vkGetPhysicalDeviceExternalFencePropertiesKHR = win32u_vkGetPhysicalDeviceExternalFenceProperties, .p_vkGetPhysicalDeviceExternalSemaphoreProperties = win32u_vkGetPhysicalDeviceExternalSemaphoreProperties, .p_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = win32u_vkGetPhysicalDeviceExternalSemaphoreProperties, .p_vkGetPhysicalDeviceImageFormatProperties2 = win32u_vkGetPhysicalDeviceImageFormatProperties2, @@ -1228,6 +1298,7 @@ static struct vulkan_funcs vulkan_funcs = .p_vkGetPhysicalDeviceSurfaceFormatsKHR = win32u_vkGetPhysicalDeviceSurfaceFormatsKHR, .p_vkGetPhysicalDeviceWin32PresentationSupportKHR = win32u_vkGetPhysicalDeviceWin32PresentationSupportKHR, .p_vkGetSemaphoreWin32HandleKHR = win32u_vkGetSemaphoreWin32HandleKHR, + .p_vkImportFenceWin32HandleKHR = win32u_vkImportFenceWin32HandleKHR, .p_vkImportSemaphoreWin32HandleKHR = win32u_vkImportSemaphoreWin32HandleKHR, .p_vkMapMemory = win32u_vkMapMemory, .p_vkMapMemory2KHR = win32u_vkMapMemory2KHR, diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 0d9dabadb1e..17783925979 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -4999,6 +4999,18 @@ VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence) return params.result; }
+VkResult WINAPI vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) +{ + struct vkGetFenceWin32HandleKHR_params params; + NTSTATUS status; + params.device = device; + params.pGetWin32HandleInfo = pGetWin32HandleInfo; + params.pHandle = pHandle; + status = UNIX_CALL(vkGetFenceWin32HandleKHR, ¶ms); + assert(!status && "vkGetFenceWin32HandleKHR"); + return params.result; +} + VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties) { struct vkGetFramebufferTilePropertiesQCOM_params params; @@ -6342,6 +6354,17 @@ VkResult WINAPI vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoS return params.result; }
+VkResult WINAPI vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) +{ + struct vkImportFenceWin32HandleKHR_params params; + NTSTATUS status; + params.device = device; + params.pImportFenceWin32HandleInfo = pImportFenceWin32HandleInfo; + status = UNIX_CALL(vkImportFenceWin32HandleKHR, ¶ms); + assert(!status && "vkImportFenceWin32HandleKHR"); + return params.result; +} + VkResult WINAPI vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) { struct vkImportSemaphoreWin32HandleKHR_params params; @@ -7572,6 +7595,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetEncodedVideoSessionParametersKHR", vkGetEncodedVideoSessionParametersKHR}, {"vkGetEventStatus", vkGetEventStatus}, {"vkGetFenceStatus", vkGetFenceStatus}, + {"vkGetFenceWin32HandleKHR", vkGetFenceWin32HandleKHR}, {"vkGetFramebufferTilePropertiesQCOM", vkGetFramebufferTilePropertiesQCOM}, {"vkGetGeneratedCommandsMemoryRequirementsEXT", vkGetGeneratedCommandsMemoryRequirementsEXT}, {"vkGetGeneratedCommandsMemoryRequirementsNV", vkGetGeneratedCommandsMemoryRequirementsNV}, @@ -7632,6 +7656,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetTensorViewOpaqueCaptureDescriptorDataARM", vkGetTensorViewOpaqueCaptureDescriptorDataARM}, {"vkGetValidationCacheDataEXT", vkGetValidationCacheDataEXT}, {"vkGetVideoSessionMemoryRequirementsKHR", vkGetVideoSessionMemoryRequirementsKHR}, + {"vkImportFenceWin32HandleKHR", vkImportFenceWin32HandleKHR}, {"vkImportSemaphoreWin32HandleKHR", vkImportSemaphoreWin32HandleKHR}, {"vkInitializePerformanceApiINTEL", vkInitializePerformanceApiINTEL}, {"vkInvalidateMappedMemoryRanges", vkInvalidateMappedMemoryRanges}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index c896017888e..db5b588afba 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -506,6 +506,7 @@ enum unix_call unix_vkGetEncodedVideoSessionParametersKHR, unix_vkGetEventStatus, unix_vkGetFenceStatus, + unix_vkGetFenceWin32HandleKHR, unix_vkGetFramebufferTilePropertiesQCOM, unix_vkGetGeneratedCommandsMemoryRequirementsEXT, unix_vkGetGeneratedCommandsMemoryRequirementsNV, @@ -620,6 +621,7 @@ enum unix_call unix_vkGetTensorViewOpaqueCaptureDescriptorDataARM, unix_vkGetValidationCacheDataEXT, unix_vkGetVideoSessionMemoryRequirementsKHR, + unix_vkImportFenceWin32HandleKHR, unix_vkImportSemaphoreWin32HandleKHR, unix_vkInitializePerformanceApiINTEL, unix_vkInvalidateMappedMemoryRanges, @@ -4392,6 +4394,14 @@ struct vkGetFenceStatus_params VkResult result; };
+struct vkGetFenceWin32HandleKHR_params +{ + VkDevice device; + const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo; + HANDLE *pHandle; + VkResult result; +}; + struct vkGetFramebufferTilePropertiesQCOM_params { VkDevice device; @@ -5299,6 +5309,13 @@ struct vkGetVideoSessionMemoryRequirementsKHR_params VkResult result; };
+struct vkImportFenceWin32HandleKHR_params +{ + VkDevice device; + const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo; + VkResult result; +}; + struct vkImportSemaphoreWin32HandleKHR_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index afe4abd3043..998f68fd8eb 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -96,7 +96,6 @@ UNSUPPORTED_EXTENSIONS = [ "VK_AMD_display_native_hdr", "VK_EXT_full_screen_exclusive", "VK_GOOGLE_display_timing", - "VK_KHR_external_fence_win32", # Relates to external_semaphore and needs type conversions in bitflags. "VK_KHR_maintenance7", # Causes infinity recursion in struct convert code "VK_KHR_shared_presentable_image", # Needs WSI work. @@ -188,14 +187,10 @@ FUNCTION_OVERRIDES = {
# Instance functions "vkCreateDevice" : {"extra_param" : "client_ptr"}, - "vkGetPhysicalDeviceExternalFenceProperties" : {"dispatch" : False},
# Device functions "vkCreateCommandPool" : {"extra_param" : "client_ptr"}, "vkGetDeviceProcAddr" : {"dispatch" : False}, - - # VK_KHR_external_fence_capabilities - "vkGetPhysicalDeviceExternalFencePropertiesKHR" : {"dispatch" : False}, }
# functions for which a user driver entry must be generated @@ -204,10 +199,12 @@ USER_DRIVER_FUNCS = { "vkAcquireNextImageKHR", "vkAllocateMemory", "vkCreateBuffer", + "vkCreateFence", "vkCreateImage", "vkCreateSemaphore", "vkCreateSwapchainKHR", "vkCreateWin32SurfaceKHR", + "vkDestroyFence", "vkDestroySemaphore", "vkDestroySurfaceKHR", "vkDestroySwapchainKHR", @@ -216,11 +213,14 @@ USER_DRIVER_FUNCS = { "vkGetDeviceBufferMemoryRequirementsKHR", "vkGetDeviceImageMemoryRequirements", "vkGetDeviceProcAddr", + "vkGetFenceWin32HandleKHR", "vkGetInstanceProcAddr", "vkGetMemoryWin32HandleKHR", "vkGetMemoryWin32HandlePropertiesKHR", "vkGetPhysicalDeviceExternalBufferProperties", "vkGetPhysicalDeviceExternalBufferPropertiesKHR", + "vkGetPhysicalDeviceExternalFenceProperties", + "vkGetPhysicalDeviceExternalFencePropertiesKHR", "vkGetPhysicalDeviceExternalSemaphoreProperties", "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "vkGetPhysicalDeviceImageFormatProperties2", @@ -232,6 +232,7 @@ USER_DRIVER_FUNCS = { "vkGetPhysicalDeviceSurfaceFormatsKHR", "vkGetPhysicalDeviceWin32PresentationSupportKHR", "vkGetSemaphoreWin32HandleKHR", + "vkImportFenceWin32HandleKHR", "vkImportSemaphoreWin32HandleKHR", "vkMapMemory", "vkMapMemory2KHR", @@ -311,6 +312,7 @@ STRUCT_CHAIN_CONVERSIONS = { "VkPhysicalDeviceImageFormatInfo2": {}, "VkCommandBufferSubmitInfo": {}, "VkSemaphoreCreateInfo": {}, + "VkFenceCreateInfo": {}, "VkSubmitInfo": {}, "VkSubmitInfo2": {},
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 61c85dbd940..b6d5c15e989 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -3104,6 +3104,15 @@ typedef struct VkExportFenceCreateInfo32 } VkExportFenceCreateInfo32; typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
+typedef struct VkExportFenceWin32HandleInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR32; + typedef struct VkExportMemoryAllocateInfo32 { VkStructureType sType; @@ -3218,6 +3227,14 @@ typedef struct VkFenceCreateInfo32 VkFenceCreateFlags flags; } VkFenceCreateInfo32;
+typedef struct VkFenceGetWin32HandleInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkFence DECLSPEC_ALIGN(8) fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetWin32HandleInfoKHR32; + typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32 { VkStructureType sType; @@ -3643,6 +3660,17 @@ typedef struct VkImageViewUsageCreateInfo32 } VkImageViewUsageCreateInfo32; typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
+typedef struct VkImportFenceWin32HandleInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkFence DECLSPEC_ALIGN(8) fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR32; + typedef struct VkImportMemoryHostPointerInfoEXT32 { VkStructureType sType; @@ -22171,6 +22199,54 @@ static void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *i FIXME("Unexpected pNext\n"); }
+#ifdef _WIN64 +static void convert_VkFenceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkFenceCreateInfo *in, VkFenceCreateInfo *out) +{ + const VkBaseInStructure *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + { + VkExportFenceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExportFenceCreateInfo *in_ext = (const VkExportFenceCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->handleTypes = in_ext->handleTypes; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + { + VkExportFenceWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExportFenceWin32HandleInfoKHR *in_ext = (const VkExportFenceWin32HandleInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pAttributes = in_ext->pAttributes; + out_ext->dwAccess = in_ext->dwAccess; + out_ext->name = in_ext->name; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} +#endif /* _WIN64 */ + static void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out) { const VkBaseInStructure32 *in_header; @@ -22197,6 +22273,19 @@ static void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + { + VkExportFenceWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExportFenceWin32HandleInfoKHR32 *in_ext = (const VkExportFenceWin32HandleInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pAttributes = UlongToPtr(in_ext->pAttributes); + out_ext->dwAccess = in_ext->dwAccess; + out_ext->name = in_ext->name; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -28350,6 +28439,18 @@ static void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_host_to_win32( } }
+static void convert_VkFenceGetWin32HandleInfoKHR_win32_to_host(const VkFenceGetWin32HandleInfoKHR32 *in, VkFenceGetWin32HandleInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->fence = in->fence; + out->handleType = in->handleType; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count) { VkTilePropertiesQCOM *out; @@ -38960,6 +39061,21 @@ static void convert_VkVideoSessionMemoryRequirementsKHR_array_host_to_win32(cons } }
+static void convert_VkImportFenceWin32HandleInfoKHR_win32_to_host(const VkImportFenceWin32HandleInfoKHR32 *in, VkImportFenceWin32HandleInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->fence = in->fence; + out->flags = in->flags; + out->handleType = in->handleType; + out->handle = in->handle; + out->name = in->name; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static void convert_VkImportSemaphoreWin32HandleInfoKHR_win32_to_host(const VkImportSemaphoreWin32HandleInfoKHR32 *in, VkImportSemaphoreWin32HandleInfoKHR *out) { if (!in) return; @@ -49272,10 +49388,16 @@ static NTSTATUS thunk32_vkCreateEvent(void *args) static NTSTATUS thunk64_vkCreateFence(void *args) { struct vkCreateFence_params *params = args; + VkFenceCreateInfo pCreateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx;
TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
- params->result = vulkan_device_from_handle(params->device)->p_vkCreateFence(vulkan_device_from_handle(params->device)->host.device, params->pCreateInfo, NULL, params->pFence); + init_conversion_context(ctx); + convert_VkFenceCreateInfo_win64_to_host(ctx, params->pCreateInfo, &pCreateInfo_host); + params->result = vk_funcs->p_vkCreateFence(params->device, &pCreateInfo_host, params->pAllocator, params->pFence); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -49298,7 +49420,7 @@ static NTSTATUS thunk32_vkCreateFence(void *args)
init_conversion_context(ctx); convert_VkFenceCreateInfo_win32_to_host(ctx, (const VkFenceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); - params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkCreateFence(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pCreateInfo_host, NULL, (VkFence *)UlongToPtr(params->pFence)); + params->result = vk_funcs->p_vkCreateFence((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkFence *)UlongToPtr(params->pFence)); free_conversion_context(ctx); return STATUS_SUCCESS; } @@ -51118,7 +51240,7 @@ static NTSTATUS thunk64_vkDestroyFence(void *args)
TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
- vulkan_device_from_handle(params->device)->p_vkDestroyFence(vulkan_device_from_handle(params->device)->host.device, params->fence, NULL); + vk_funcs->p_vkDestroyFence(params->device, params->fence, params->pAllocator); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -51134,7 +51256,7 @@ static NTSTATUS thunk32_vkDestroyFence(void *args)
TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
- vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkDestroyFence(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->fence, NULL); + vk_funcs->p_vkDestroyFence((VkDevice)UlongToPtr(params->device), params->fence, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator)); return STATUS_SUCCESS; }
@@ -54254,6 +54376,36 @@ static NTSTATUS thunk32_vkGetFenceStatus(void *args) return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetFenceWin32HandleKHR(void *args) +{ + struct vkGetFenceWin32HandleKHR_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pGetWin32HandleInfo, params->pHandle); + + params->result = vk_funcs->p_vkGetFenceWin32HandleKHR(params->device, params->pGetWin32HandleInfo, params->pHandle); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetFenceWin32HandleKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pGetWin32HandleInfo; + PTR32 pHandle; + VkResult result; + } *params = args; + VkFenceGetWin32HandleInfoKHR pGetWin32HandleInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pGetWin32HandleInfo, params->pHandle); + + convert_VkFenceGetWin32HandleInfoKHR_win32_to_host((const VkFenceGetWin32HandleInfoKHR32 *)UlongToPtr(params->pGetWin32HandleInfo), &pGetWin32HandleInfo_host); + params->result = vk_funcs->p_vkGetFenceWin32HandleKHR((VkDevice)UlongToPtr(params->device), &pGetWin32HandleInfo_host, (HANDLE *)UlongToPtr(params->pHandle)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args) { @@ -58040,6 +58192,35 @@ static NTSTATUS thunk32_vkGetVideoSessionMemoryRequirementsKHR(void *args) return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkImportFenceWin32HandleKHR(void *args) +{ + struct vkImportFenceWin32HandleKHR_params *params = args; + + TRACE("%p, %p\n", params->device, params->pImportFenceWin32HandleInfo); + + params->result = vk_funcs->p_vkImportFenceWin32HandleKHR(params->device, params->pImportFenceWin32HandleInfo); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkImportFenceWin32HandleKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pImportFenceWin32HandleInfo; + VkResult result; + } *params = args; + VkImportFenceWin32HandleInfoKHR pImportFenceWin32HandleInfo_host; + + TRACE("%#x, %#x\n", params->device, params->pImportFenceWin32HandleInfo); + + convert_VkImportFenceWin32HandleInfoKHR_win32_to_host((const VkImportFenceWin32HandleInfoKHR32 *)UlongToPtr(params->pImportFenceWin32HandleInfo), &pImportFenceWin32HandleInfo_host); + params->result = vk_funcs->p_vkImportFenceWin32HandleKHR((VkDevice)UlongToPtr(params->device), &pImportFenceWin32HandleInfo_host); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkImportSemaphoreWin32HandleKHR(void *args) { @@ -60214,6 +60395,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_dynamic_rendering", "VK_KHR_dynamic_rendering_local_read", "VK_KHR_external_fence", + "VK_KHR_external_fence_win32", "VK_KHR_external_memory", "VK_KHR_external_memory_win32", "VK_KHR_external_semaphore", @@ -60957,6 +61139,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetEncodedVideoSessionParametersKHR, thunk64_vkGetEventStatus, thunk64_vkGetFenceStatus, + thunk64_vkGetFenceWin32HandleKHR, thunk64_vkGetFramebufferTilePropertiesQCOM, thunk64_vkGetGeneratedCommandsMemoryRequirementsEXT, thunk64_vkGetGeneratedCommandsMemoryRequirementsNV, @@ -61071,6 +61254,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetTensorViewOpaqueCaptureDescriptorDataARM, thunk64_vkGetValidationCacheDataEXT, thunk64_vkGetVideoSessionMemoryRequirementsKHR, + thunk64_vkImportFenceWin32HandleKHR, thunk64_vkImportSemaphoreWin32HandleKHR, thunk64_vkInitializePerformanceApiINTEL, thunk64_vkInvalidateMappedMemoryRanges, @@ -61633,6 +61817,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetEncodedVideoSessionParametersKHR, thunk32_vkGetEventStatus, thunk32_vkGetFenceStatus, + thunk32_vkGetFenceWin32HandleKHR, thunk32_vkGetFramebufferTilePropertiesQCOM, thunk32_vkGetGeneratedCommandsMemoryRequirementsEXT, thunk32_vkGetGeneratedCommandsMemoryRequirementsNV, @@ -61747,6 +61932,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetTensorViewOpaqueCaptureDescriptorDataARM, thunk32_vkGetValidationCacheDataEXT, thunk32_vkGetVideoSessionMemoryRequirementsKHR, + thunk32_vkImportFenceWin32HandleKHR, thunk32_vkImportSemaphoreWin32HandleKHR, thunk32_vkInitializePerformanceApiINTEL, thunk32_vkInvalidateMappedMemoryRanges, diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 662318acc92..e4a71a38bb8 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -234,6 +234,8 @@ typedef struct _XDisplay Display; #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 @@ -5497,6 +5499,9 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, @@ -11990,6 +11995,15 @@ typedef struct VkExportFenceCreateInfo } VkExportFenceCreateInfo; typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
+typedef struct VkExportFenceWin32HandleInfoKHR +{ + VkStructureType sType; + const void *pNext; + const SECURITY_ATTRIBUTES *pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + typedef struct VkExportMemoryAllocateInfo { VkStructureType sType; @@ -12112,6 +12126,14 @@ typedef struct VkFenceGetFdInfoKHR VkExternalFenceHandleTypeFlagBits handleType; } VkFenceGetFdInfoKHR;
+typedef struct VkFenceGetWin32HandleInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkFence WINE_VK_ALIGN(8) fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetWin32HandleInfoKHR; + typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { VkStructureType sType; @@ -12604,6 +12626,17 @@ typedef struct VkImportFenceFdInfoKHR int fd; } VkImportFenceFdInfoKHR;
+typedef struct VkImportFenceWin32HandleInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkFence WINE_VK_ALIGN(8) fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + typedef struct VkImportMemoryFdInfoKHR { VkStructureType sType; @@ -19270,6 +19303,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice, VkEvent); typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice, const VkFenceGetFdInfoKHR *, int *); typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice, VkFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice, const VkFenceGetWin32HandleInfoKHR *, HANDLE *); typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice, VkFramebuffer, uint32_t *, VkTilePropertiesQCOM *); typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoEXT *, VkMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoNV *, VkMemoryRequirements2 *); @@ -19394,6 +19428,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)( typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice, VkValidationCacheEXT, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice, VkVideoSessionKHR, uint32_t *, VkVideoSessionMemoryRequirementsKHR *); typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice, const VkImportFenceFdInfoKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice, const VkImportFenceWin32HandleInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice, const VkImportSemaphoreFdInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice, const VkImportSemaphoreWin32HandleInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice, const VkInitializePerformanceApiInfoINTEL *); @@ -19953,6 +19988,7 @@ VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event); VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd); VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence); +VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle); VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties); void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements); @@ -20077,6 +20113,7 @@ VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice devic VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements); VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo); +VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo); VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo); VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo); VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo); @@ -20612,6 +20649,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetEventStatus) \ USE_VK_FUNC(vkGetFenceFdKHR) \ USE_VK_FUNC(vkGetFenceStatus) \ + USE_VK_FUNC(vkGetFenceWin32HandleKHR) \ USE_VK_FUNC(vkGetFramebufferTilePropertiesQCOM) \ USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsEXT) \ USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsNV) \ @@ -20679,6 +20717,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetValidationCacheDataEXT) \ USE_VK_FUNC(vkGetVideoSessionMemoryRequirementsKHR) \ USE_VK_FUNC(vkImportFenceFdKHR) \ + USE_VK_FUNC(vkImportFenceWin32HandleKHR) \ USE_VK_FUNC(vkImportSemaphoreFdKHR) \ USE_VK_FUNC(vkImportSemaphoreWin32HandleKHR) \ USE_VK_FUNC(vkInitializePerformanceApiINTEL) \ @@ -20775,6 +20814,8 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetPhysicalDeviceCooperativeVectorPropertiesNV) \ USE_VK_FUNC(vkGetPhysicalDeviceExternalBufferProperties) \ USE_VK_FUNC(vkGetPhysicalDeviceExternalBufferPropertiesKHR) \ + USE_VK_FUNC(vkGetPhysicalDeviceExternalFenceProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceExternalFencePropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceExternalSemaphoreProperties) \ USE_VK_FUNC(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceExternalTensorPropertiesARM) \ diff --git a/include/wine/vulkan_driver.h b/include/wine/vulkan_driver.h index 9b5b74c4f2e..9b42e895f01 100644 --- a/include/wine/vulkan_driver.h +++ b/include/wine/vulkan_driver.h @@ -47,7 +47,7 @@ struct vulkan_client_object #include "wine/rbtree.h"
/* Wine internal vulkan driver version, needs to be bumped upon vulkan_funcs changes. */ -#define WINE_VULKAN_DRIVER_VERSION 43 +#define WINE_VULKAN_DRIVER_VERSION 44
struct vulkan_object { @@ -191,10 +191,12 @@ struct vulkan_funcs PFN_vkAcquireNextImageKHR p_vkAcquireNextImageKHR; PFN_vkAllocateMemory p_vkAllocateMemory; PFN_vkCreateBuffer p_vkCreateBuffer; + PFN_vkCreateFence p_vkCreateFence; PFN_vkCreateImage p_vkCreateImage; PFN_vkCreateSemaphore p_vkCreateSemaphore; PFN_vkCreateSwapchainKHR p_vkCreateSwapchainKHR; PFN_vkCreateWin32SurfaceKHR p_vkCreateWin32SurfaceKHR; + PFN_vkDestroyFence p_vkDestroyFence; PFN_vkDestroySemaphore p_vkDestroySemaphore; PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR; PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR; @@ -203,11 +205,14 @@ struct vulkan_funcs PFN_vkGetDeviceBufferMemoryRequirementsKHR p_vkGetDeviceBufferMemoryRequirementsKHR; PFN_vkGetDeviceImageMemoryRequirements p_vkGetDeviceImageMemoryRequirements; PFN_vkGetDeviceProcAddr p_vkGetDeviceProcAddr; + PFN_vkGetFenceWin32HandleKHR p_vkGetFenceWin32HandleKHR; PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr; PFN_vkGetMemoryWin32HandleKHR p_vkGetMemoryWin32HandleKHR; PFN_vkGetMemoryWin32HandlePropertiesKHR p_vkGetMemoryWin32HandlePropertiesKHR; PFN_vkGetPhysicalDeviceExternalBufferProperties p_vkGetPhysicalDeviceExternalBufferProperties; PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR p_vkGetPhysicalDeviceExternalBufferPropertiesKHR; + PFN_vkGetPhysicalDeviceExternalFenceProperties p_vkGetPhysicalDeviceExternalFenceProperties; + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR p_vkGetPhysicalDeviceExternalFencePropertiesKHR; PFN_vkGetPhysicalDeviceExternalSemaphoreProperties p_vkGetPhysicalDeviceExternalSemaphoreProperties; PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR p_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; PFN_vkGetPhysicalDeviceImageFormatProperties2 p_vkGetPhysicalDeviceImageFormatProperties2; @@ -219,6 +224,7 @@ struct vulkan_funcs PFN_vkGetPhysicalDeviceSurfaceFormatsKHR p_vkGetPhysicalDeviceSurfaceFormatsKHR; PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p_vkGetPhysicalDeviceWin32PresentationSupportKHR; PFN_vkGetSemaphoreWin32HandleKHR p_vkGetSemaphoreWin32HandleKHR; + PFN_vkImportFenceWin32HandleKHR p_vkImportFenceWin32HandleKHR; PFN_vkImportSemaphoreWin32HandleKHR p_vkImportSemaphoreWin32HandleKHR; PFN_vkMapMemory p_vkMapMemory; PFN_vkMapMemory2KHR p_vkMapMemory2KHR;