dlls/winevulkan/vulkan.c

   1 /* Wine Vulkan ICD implementation
   2  *
   3  * Copyright 2017 Roderick Colenbrander
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #if 0
  21 #pragma makedep unix
  22 #endif
  23
  24 #include "config.h"
  25 #include <time.h>
  26
  27 #include "vulkan_private.h"
  28 #include "wine/vulkan_driver.h"
  29 #include "ntuser.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  32
  33
  34 static BOOL is_wow64(void)
  35 {
  36     return sizeof(void *) == sizeof(UINT64) && NtCurrentTeb()->WowTebOffset;
  37 }
  38
  39 static BOOL use_external_memory(void)
  40 {
  41     return is_wow64();
  42 }
  43
  44 static ULONG_PTR zero_bits = 0;
  45
  46 #define wine_vk_count_struct(s, t) wine_vk_count_struct_((void *)s, VK_STRUCTURE_TYPE_##t)
  47 static uint32_t wine_vk_count_struct_(void *s, VkStructureType t)
  48 {
  49     const VkBaseInStructure *header;
  50     uint32_t result = 0;
  51
  52     for (header = s; header; header = header->pNext)
  53     {
  54         if (header->sType == t)
  55             result++;
  56     }
  57
  58     return result;
  59 }
  60
  61 static const struct vulkan_funcs *vk_funcs;
  62
  63 #define WINE_VK_ADD_DISPATCHABLE_MAPPING(instance, client_handle, native_handle, object) \
  64     wine_vk_add_handle_mapping((instance), (uintptr_t)(client_handle), (uintptr_t)(native_handle), &(object)->mapping)
  65 #define WINE_VK_ADD_NON_DISPATCHABLE_MAPPING(instance, client_handle, native_handle, object) \
  66     wine_vk_add_handle_mapping((instance), (uintptr_t)(client_handle), (native_handle), &(object)->mapping)
  67 static void  wine_vk_add_handle_mapping(struct wine_instance *instance, uint64_t wrapped_handle,
  68         uint64_t native_handle, struct wine_vk_mapping *mapping)
  69 {
  70     if (instance->enable_wrapper_list)
  71     {
  72         mapping->native_handle = native_handle;
  73         mapping->wine_wrapped_handle = wrapped_handle;
  74         pthread_rwlock_wrlock(&instance->wrapper_lock);
  75         list_add_tail(&instance->wrappers, &mapping->link);
  76         pthread_rwlock_unlock(&instance->wrapper_lock);
  77     }
  78 }
  79
  80 #define WINE_VK_REMOVE_HANDLE_MAPPING(instance, object) \
  81     wine_vk_remove_handle_mapping((instance), &(object)->mapping)
  82 static void wine_vk_remove_handle_mapping(struct wine_instance *instance, struct wine_vk_mapping *mapping)
  83 {
  84     if (instance->enable_wrapper_list)
  85     {
  86         pthread_rwlock_wrlock(&instance->wrapper_lock);
  87         list_remove(&mapping->link);
  88         pthread_rwlock_unlock(&instance->wrapper_lock);
  89     }
  90 }
  91
  92 static uint64_t wine_vk_get_wrapper(struct wine_instance *instance, uint64_t native_handle)
  93 {
  94     struct wine_vk_mapping *mapping;
  95     uint64_t result = 0;
  96
  97     pthread_rwlock_rdlock(&instance->wrapper_lock);
  98     LIST_FOR_EACH_ENTRY(mapping, &instance->wrappers, struct wine_vk_mapping, link)
  99     {
 100         if (mapping->native_handle == native_handle)
 101         {
 102             result = mapping->wine_wrapped_handle;
 103             break;
 104         }
 105     }
 106     pthread_rwlock_unlock(&instance->wrapper_lock);
 107     return result;
 108 }
 109
 110 static VkBool32 debug_utils_callback_conversion(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
 111     VkDebugUtilsMessageTypeFlagsEXT message_types,
 112     const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
 113     void *user_data)
 114 {
 115     struct wine_vk_debug_utils_params params;
 116     VkDebugUtilsObjectNameInfoEXT *object_name_infos;
 117     struct wine_debug_utils_messenger *object;
 118     void *ret_ptr;
 119     ULONG ret_len;
 120     VkBool32 result;
 121     unsigned int i;
 122
 123     TRACE("%i, %u, %p, %p\n", severity, message_types, callback_data, user_data);
 124
 125     object = user_data;
 126
 127     if (!object->instance->instance)
 128     {
 129         /* instance wasn't yet created, this is a message from the native loader */
 130         return VK_FALSE;
 131     }
 132
 133     /* FIXME: we should pack all referenced structs instead of passing pointers */
 134     params.user_callback = object->user_callback;
 135     params.user_data = object->user_data;
 136     params.severity = severity;
 137     params.message_types = message_types;
 138     params.data = *((VkDebugUtilsMessengerCallbackDataEXT *) callback_data);
 139
 140     object_name_infos = calloc(params.data.objectCount, sizeof(*object_name_infos));
 141
 142     for (i = 0; i < params.data.objectCount; i++)
 143     {
 144         object_name_infos[i].sType = callback_data->pObjects[i].sType;
 145         object_name_infos[i].pNext = callback_data->pObjects[i].pNext;
 146         object_name_infos[i].objectType = callback_data->pObjects[i].objectType;
 147         object_name_infos[i].pObjectName = callback_data->pObjects[i].pObjectName;
 148
 149         if (wine_vk_is_type_wrapped(callback_data->pObjects[i].objectType))
 150         {
 151             object_name_infos[i].objectHandle = wine_vk_get_wrapper(object->instance, callback_data->pObjects[i].objectHandle);
 152             if (!object_name_infos[i].objectHandle)
 153             {
 154                 WARN("handle conversion failed 0x%s\n", wine_dbgstr_longlong(callback_data->pObjects[i].objectHandle));
 155                 free(object_name_infos);
 156                 return VK_FALSE;
 157             }
 158         }
 159         else
 160         {
 161             object_name_infos[i].objectHandle = callback_data->pObjects[i].objectHandle;
 162         }
 163     }
 164
 165     params.data.pObjects = object_name_infos;
 166
 167     /* applications should always return VK_FALSE */
 168     result = KeUserModeCallback( NtUserCallVulkanDebugUtilsCallback, &params, sizeof(params),
 169                                  &ret_ptr, &ret_len );
 170
 171     free(object_name_infos);
 172
 173     return result;
 174 }
 175
 176 static VkBool32 debug_report_callback_conversion(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT object_type,
 177     uint64_t object_handle, size_t location, int32_t code, const char *layer_prefix, const char *message, void *user_data)
 178 {
 179     struct wine_vk_debug_report_params params;
 180     struct wine_debug_report_callback *object;
 181     void *ret_ptr;
 182     ULONG ret_len;
 183
 184     TRACE("%#x, %#x, 0x%s, 0x%s, %d, %p, %p, %p\n", flags, object_type, wine_dbgstr_longlong(object_handle),
 185         wine_dbgstr_longlong(location), code, layer_prefix, message, user_data);
 186
 187     object = user_data;
 188
 189     if (!object->instance->instance)
 190     {
 191         /* instance wasn't yet created, this is a message from the native loader */
 192         return VK_FALSE;
 193     }
 194
 195     /* FIXME: we should pack all referenced structs instead of passing pointers */
 196     params.user_callback = object->user_callback;
 197     params.user_data = object->user_data;
 198     params.flags = flags;
 199     params.object_type = object_type;
 200     params.location = location;
 201     params.code = code;
 202     params.layer_prefix = layer_prefix;
 203     params.message = message;
 204
 205     params.object_handle = wine_vk_get_wrapper(object->instance, object_handle);
 206     if (!params.object_handle)
 207         params.object_type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
 208
 209     return KeUserModeCallback( NtUserCallVulkanDebugReportCallback, &params, sizeof(params),
 210                                &ret_ptr, &ret_len );
 211 }
 212
 213 static void wine_vk_physical_device_free(struct wine_phys_dev *phys_dev)
 214 {
 215     if (!phys_dev)
 216         return;
 217
 218     WINE_VK_REMOVE_HANDLE_MAPPING(phys_dev->instance, phys_dev);
 219     free(phys_dev->extensions);
 220     free(phys_dev);
 221 }
 222
 223 static struct wine_phys_dev *wine_vk_physical_device_alloc(struct wine_instance *instance,
 224         VkPhysicalDevice phys_dev, VkPhysicalDevice handle)
 225 {
 226     struct wine_phys_dev *object;
 227     uint32_t num_host_properties, num_properties = 0;
 228     VkExtensionProperties *host_properties = NULL;
 229     BOOL have_external_memory_host = FALSE;
 230     VkResult res;
 231     unsigned int i, j;
 232
 233     if (!(object = calloc(1, sizeof(*object))))
 234         return NULL;
 235
 236     object->instance = instance;
 237     object->handle = handle;
 238     object->phys_dev = phys_dev;
 239
 240     handle->base.unix_handle = (uintptr_t)object;
 241     WINE_VK_ADD_DISPATCHABLE_MAPPING(instance, handle, phys_dev, object);
 242
 243     instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(phys_dev, &object->memory_properties);
 244
 245     res = instance->funcs.p_vkEnumerateDeviceExtensionProperties(phys_dev,
 246             NULL, &num_host_properties, NULL);
 247     if (res != VK_SUCCESS)
 248     {
 249         ERR("Failed to enumerate device extensions, res=%d\n", res);
 250         goto err;
 251     }
 252
 253     host_properties = calloc(num_host_properties, sizeof(*host_properties));
 254     if (!host_properties)
 255     {
 256         ERR("Failed to allocate memory for device properties!\n");
 257         goto err;
 258     }
 259
 260     res = instance->funcs.p_vkEnumerateDeviceExtensionProperties(phys_dev,
 261             NULL, &num_host_properties, host_properties);
 262     if (res != VK_SUCCESS)
 263     {
 264         ERR("Failed to enumerate device extensions, res=%d\n", res);
 265         goto err;
 266     }
 267
 268     /* Count list of extensions for which we have an implementation.
 269      * TODO: perform translation for platform specific extensions.
 270      */
 271     for (i = 0; i < num_host_properties; i++)
 272     {
 273         if (wine_vk_device_extension_supported(host_properties[i].extensionName))
 274         {
 275             TRACE("Enabling extension '%s' for physical device %p\n", host_properties[i].extensionName, object);
 276             num_properties++;
 277         }
 278         else
 279         {
 280             TRACE("Skipping extension '%s', no implementation found in winevulkan.\n", host_properties[i].extensionName);
 281         }
 282         if (!strcmp(host_properties[i].extensionName, "VK_EXT_external_memory_host"))
 283             have_external_memory_host = TRUE;
 284     }
 285
 286     TRACE("Host supported extensions %u, Wine supported extensions %u\n", num_host_properties, num_properties);
 287
 288     if (!(object->extensions = calloc(num_properties, sizeof(*object->extensions))))
 289     {
 290         ERR("Failed to allocate memory for device extensions!\n");
 291         goto err;
 292     }
 293
 294     for (i = 0, j = 0; i < num_host_properties; i++)
 295     {
 296         if (wine_vk_device_extension_supported(host_properties[i].extensionName))
 297         {
 298             object->extensions[j] = host_properties[i];
 299             j++;
 300         }
 301     }
 302     object->extension_count = num_properties;
 303
 304     if (use_external_memory() && have_external_memory_host)
 305     {
 306         VkPhysicalDeviceExternalMemoryHostPropertiesEXT host_mem_props =
 307         {
 308             .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
 309         };
 310         VkPhysicalDeviceProperties2 props =
 311         {
 312             .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
 313             .pNext = &host_mem_props,
 314         };
 315         instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(phys_dev, &props);
 316         object->external_memory_align = host_mem_props.minImportedHostPointerAlignment;
 317         if (object->external_memory_align)
 318             TRACE("Using VK_EXT_external_memory_host for memory mapping with alignment: %u\n",
 319                   object->external_memory_align);
 320     }
 321
 322     free(host_properties);
 323     return object;
 324
 325 err:
 326     wine_vk_physical_device_free(object);
 327     free(host_properties);
 328     return NULL;
 329 }
 330
 331 static void wine_vk_free_command_buffers(struct wine_device *device,
 332         struct wine_cmd_pool *pool, uint32_t count, const VkCommandBuffer *buffers)
 333 {
 334     unsigned int i;
 335
 336     for (i = 0; i < count; i++)
 337     {
 338         struct wine_cmd_buffer *buffer = wine_cmd_buffer_from_handle(buffers[i]);
 339
 340         if (!buffer)
 341             continue;
 342
 343         device->funcs.p_vkFreeCommandBuffers(device->device, pool->command_pool, 1, &buffer->command_buffer);
 344         WINE_VK_REMOVE_HANDLE_MAPPING(device->phys_dev->instance, buffer);
 345         buffer->handle->base.unix_handle = 0;
 346         free(buffer);
 347     }
 348 }
 349
 350 static void wine_vk_device_get_queues(struct wine_device *device,
 351         uint32_t family_index, uint32_t queue_count, VkDeviceQueueCreateFlags flags,
 352         struct wine_queue *queues, VkQueue *handles)
 353 {
 354     VkDeviceQueueInfo2 queue_info;
 355     unsigned int i;
 356
 357     for (i = 0; i < queue_count; i++)
 358     {
 359         struct wine_queue *queue = &queues[i];
 360
 361         queue->device = device;
 362         queue->handle = (*handles)++;
 363         queue->family_index = family_index;
 364         queue->queue_index = i;
 365         queue->flags = flags;
 366
 367         /* The Vulkan spec says:
 368          *
 369          * "vkGetDeviceQueue must only be used to get queues that were created
 370          * with the flags parameter of VkDeviceQueueCreateInfo set to zero."
 371          */
 372         if (flags && device->funcs.p_vkGetDeviceQueue2)
 373         {
 374             queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2;
 375             queue_info.pNext = NULL;
 376             queue_info.flags = flags;
 377             queue_info.queueFamilyIndex = family_index;
 378             queue_info.queueIndex = i;
 379             device->funcs.p_vkGetDeviceQueue2(device->device, &queue_info, &queue->queue);
 380         }
 381         else
 382         {
 383             device->funcs.p_vkGetDeviceQueue(device->device, family_index, i, &queue->queue);
 384         }
 385
 386         queue->handle->base.unix_handle = (uintptr_t)queue;
 387         WINE_VK_ADD_DISPATCHABLE_MAPPING(device->phys_dev->instance, queue->handle, queue->queue, queue);
 388     }
 389 }
 390
 391 static VkResult wine_vk_device_convert_create_info(struct wine_phys_dev *phys_dev,
 392         struct conversion_context *ctx, const VkDeviceCreateInfo *src, VkDeviceCreateInfo *dst)
 393 {
 394     unsigned int i;
 395
 396     *dst = *src;
 397
 398     /* Should be filtered out by loader as ICDs don't support layers. */
 399     dst->enabledLayerCount = 0;
 400     dst->ppEnabledLayerNames = NULL;
 401
 402     TRACE("Enabled %u extensions.\n", dst->enabledExtensionCount);
 403     for (i = 0; i < dst->enabledExtensionCount; i++)
 404     {
 405         const char *extension_name = dst->ppEnabledExtensionNames[i];
 406         TRACE("Extension %u: %s.\n", i, debugstr_a(extension_name));
 407         if (!wine_vk_device_extension_supported(extension_name))
 408         {
 409             WARN("Extension %s is not supported.\n", debugstr_a(extension_name));
 410             return VK_ERROR_EXTENSION_NOT_PRESENT;
 411         }
 412     }
 413
 414     if (phys_dev->external_memory_align)
 415     {
 416         const char **new_extensions;
 417
 418         new_extensions = conversion_context_alloc(ctx, (dst->enabledExtensionCount + 2) *
 419                                                   sizeof(*dst->ppEnabledExtensionNames));
 420         memcpy(new_extensions, src->ppEnabledExtensionNames,
 421                dst->enabledExtensionCount * sizeof(*dst->ppEnabledExtensionNames));
 422         new_extensions[dst->enabledExtensionCount++] = "VK_KHR_external_memory";
 423         new_extensions[dst->enabledExtensionCount++] = "VK_EXT_external_memory_host";
 424         dst->ppEnabledExtensionNames = new_extensions;
 425     }
 426
 427     return VK_SUCCESS;
 428 }
 429
 430 /* Helper function used for freeing a device structure. This function supports full
 431  * and partial object cleanups and can thus be used for vkCreateDevice failures.
 432  */
 433 static void wine_vk_device_free(struct wine_device *device)
 434 {
 435     struct wine_queue *queue;
 436
 437     if (!device)
 438         return;
 439
 440     if (device->queues)
 441     {
 442         unsigned int i;
 443         for (i = 0; i < device->queue_count; i++)
 444         {
 445             queue = &device->queues[i];
 446             if (queue && queue->queue)
 447                 WINE_VK_REMOVE_HANDLE_MAPPING(device->phys_dev->instance, queue);
 448         }
 449         free(device->queues);
 450         device->queues = NULL;
 451     }
 452
 453     if (device->device && device->funcs.p_vkDestroyDevice)
 454     {
 455         WINE_VK_REMOVE_HANDLE_MAPPING(device->phys_dev->instance, device);
 456         device->funcs.p_vkDestroyDevice(device->device, NULL /* pAllocator */);
 457     }
 458
 459     free(device);
 460 }
 461
 462 NTSTATUS init_vulkan(void *args)
 463 {
 464     vk_funcs = __wine_get_vulkan_driver(WINE_VULKAN_DRIVER_VERSION);
 465     if (!vk_funcs)
 466     {
 467         ERR("Failed to load Wine graphics driver supporting Vulkan.\n");
 468         return STATUS_UNSUCCESSFUL;
 469     }
 470
 471     if (is_wow64())
 472     {
 473         SYSTEM_BASIC_INFORMATION info;
 474
 475         NtQuerySystemInformation(SystemEmulationBasicInformation, &info, sizeof(info), NULL);
 476         zero_bits = (ULONG_PTR)info.HighestUserAddress | 0x7fffffff;
 477     }
 478
 479     return STATUS_SUCCESS;
 480 }
 481
 482 /* Helper function for converting between win32 and host compatible VkInstanceCreateInfo.
 483  * This function takes care of extensions handled at winevulkan layer, a Wine graphics
 484  * driver is responsible for handling e.g. surface extensions.
 485  */
 486 static VkResult wine_vk_instance_convert_create_info(struct conversion_context *ctx,
 487         const VkInstanceCreateInfo *src, VkInstanceCreateInfo *dst, struct wine_instance *object)
 488 {
 489     VkDebugUtilsMessengerCreateInfoEXT *debug_utils_messenger;
 490     VkDebugReportCallbackCreateInfoEXT *debug_report_callback;
 491     VkBaseInStructure *header;
 492     unsigned int i;
 493
 494     *dst = *src;
 495
 496     object->utils_messenger_count = wine_vk_count_struct(dst, DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT);
 497     object->utils_messengers =  calloc(object->utils_messenger_count, sizeof(*object->utils_messengers));
 498     header = (VkBaseInStructure *) dst;
 499     for (i = 0; i < object->utils_messenger_count; i++)
 500     {
 501         header = find_next_struct(header->pNext, VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT);
 502         debug_utils_messenger = (VkDebugUtilsMessengerCreateInfoEXT *) header;
 503
 504         object->utils_messengers[i].instance = object;
 505         object->utils_messengers[i].debug_messenger = VK_NULL_HANDLE;
 506         object->utils_messengers[i].user_callback = debug_utils_messenger->pfnUserCallback;
 507         object->utils_messengers[i].user_data = debug_utils_messenger->pUserData;
 508
 509         /* convert_VkInstanceCreateInfo_* already copied the chain, so we can modify it in-place. */
 510         debug_utils_messenger->pfnUserCallback = (void *) &debug_utils_callback_conversion;
 511         debug_utils_messenger->pUserData = &object->utils_messengers[i];
 512     }
 513
 514     debug_report_callback = find_next_struct(header->pNext,
 515                                              VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT);
 516     if (debug_report_callback)
 517     {
 518         object->default_callback.instance = object;
 519         object->default_callback.debug_callback = VK_NULL_HANDLE;
 520         object->default_callback.user_callback = debug_report_callback->pfnCallback;
 521         object->default_callback.user_data = debug_report_callback->pUserData;
 522
 523         debug_report_callback->pfnCallback = (void *) &debug_report_callback_conversion;
 524         debug_report_callback->pUserData = &object->default_callback;
 525     }
 526
 527     /* ICDs don't support any layers, so nothing to copy. Modern versions of the loader
 528      * filter this data out as well.
 529      */
 530     if (object->quirks & WINEVULKAN_QUIRK_IGNORE_EXPLICIT_LAYERS) {
 531         dst->enabledLayerCount = 0;
 532         dst->ppEnabledLayerNames = NULL;
 533         WARN("Ignoring explicit layers!\n");
 534     } else if (dst->enabledLayerCount) {
 535         FIXME("Loading explicit layers is not supported by winevulkan!\n");
 536         return VK_ERROR_LAYER_NOT_PRESENT;
 537     }
 538
 539     TRACE("Enabled %u instance extensions.\n", dst->enabledExtensionCount);
 540     for (i = 0; i < dst->enabledExtensionCount; i++)
 541     {
 542         const char *extension_name = dst->ppEnabledExtensionNames[i];
 543         TRACE("Extension %u: %s.\n", i, debugstr_a(extension_name));
 544         if (!wine_vk_instance_extension_supported(extension_name))
 545         {
 546             WARN("Extension %s is not supported.\n", debugstr_a(extension_name));
 547             return VK_ERROR_EXTENSION_NOT_PRESENT;
 548         }
 549         if (!strcmp(extension_name, "VK_EXT_debug_utils") || !strcmp(extension_name, "VK_EXT_debug_report"))
 550         {
 551             object->enable_wrapper_list = VK_TRUE;
 552         }
 553     }
 554
 555     if (use_external_memory())
 556     {
 557         const char **new_extensions;
 558
 559         new_extensions = conversion_context_alloc(ctx, (dst->enabledExtensionCount + 2) *
 560                                                   sizeof(*dst->ppEnabledExtensionNames));
 561         memcpy(new_extensions, src->ppEnabledExtensionNames,
 562                dst->enabledExtensionCount * sizeof(*dst->ppEnabledExtensionNames));
 563         new_extensions[dst->enabledExtensionCount++] = "VK_KHR_get_physical_device_properties2";
 564         new_extensions[dst->enabledExtensionCount++] = "VK_KHR_external_memory_capabilities";
 565         dst->ppEnabledExtensionNames = new_extensions;
 566     }
 567
 568     return VK_SUCCESS;
 569 }
 570
 571 /* Helper function which stores wrapped physical devices in the instance object. */
 572 static VkResult wine_vk_instance_load_physical_devices(struct wine_instance *instance)
 573 {
 574     VkPhysicalDevice *tmp_phys_devs;
 575     uint32_t phys_dev_count;
 576     unsigned int i;
 577     VkResult res;
 578
 579     res = instance->funcs.p_vkEnumeratePhysicalDevices(instance->instance, &phys_dev_count, NULL);
 580     if (res != VK_SUCCESS)
 581     {
 582         ERR("Failed to enumerate physical devices, res=%d\n", res);
 583         return res;
 584     }
 585     if (!phys_dev_count)
 586         return res;
 587
 588     if (phys_dev_count > instance->handle->phys_dev_count)
 589     {
 590         instance->handle->phys_dev_count = phys_dev_count;
 591         return VK_ERROR_OUT_OF_POOL_MEMORY;
 592     }
 593     instance->handle->phys_dev_count = phys_dev_count;
 594
 595     if (!(tmp_phys_devs = calloc(phys_dev_count, sizeof(*tmp_phys_devs))))
 596         return VK_ERROR_OUT_OF_HOST_MEMORY;
 597
 598     res = instance->funcs.p_vkEnumeratePhysicalDevices(instance->instance, &phys_dev_count, tmp_phys_devs);
 599     if (res != VK_SUCCESS)
 600     {
 601         free(tmp_phys_devs);
 602         return res;
 603     }
 604
 605     instance->phys_devs = calloc(phys_dev_count, sizeof(*instance->phys_devs));
 606     if (!instance->phys_devs)
 607     {
 608         free(tmp_phys_devs);
 609         return VK_ERROR_OUT_OF_HOST_MEMORY;
 610     }
 611
 612     /* Wrap each native physical device handle into a dispatchable object for the ICD loader. */
 613     for (i = 0; i < phys_dev_count; i++)
 614     {
 615         struct wine_phys_dev *phys_dev = wine_vk_physical_device_alloc(instance, tmp_phys_devs[i],
 616                                                                        &instance->handle->phys_devs[i]);
 617         if (!phys_dev)
 618         {
 619             ERR("Unable to allocate memory for physical device!\n");
 620             free(tmp_phys_devs);
 621             return VK_ERROR_OUT_OF_HOST_MEMORY;
 622         }
 623
 624         instance->phys_devs[i] = phys_dev;
 625         instance->phys_dev_count = i + 1;
 626     }
 627     instance->phys_dev_count = phys_dev_count;
 628
 629     free(tmp_phys_devs);
 630     return VK_SUCCESS;
 631 }
 632
 633 static struct wine_phys_dev *wine_vk_instance_wrap_physical_device(struct wine_instance *instance,
 634         VkPhysicalDevice physical_device)
 635 {
 636     unsigned int i;
 637
 638     for (i = 0; i < instance->phys_dev_count; ++i)
 639     {
 640         struct wine_phys_dev *current = instance->phys_devs[i];
 641         if (current->phys_dev == physical_device)
 642             return current;
 643     }
 644
 645     ERR("Unrecognized physical device %p.\n", physical_device);
 646     return NULL;
 647 }
 648
 649 /* Helper function used for freeing an instance structure. This function supports full
 650  * and partial object cleanups and can thus be used for vkCreateInstance failures.
 651  */
 652 static void wine_vk_instance_free(struct wine_instance *instance)
 653 {
 654     if (!instance)
 655         return;
 656
 657     if (instance->phys_devs)
 658     {
 659         unsigned int i;
 660
 661         for (i = 0; i < instance->phys_dev_count; i++)
 662         {
 663             wine_vk_physical_device_free(instance->phys_devs[i]);
 664         }
 665         free(instance->phys_devs);
 666     }
 667
 668     if (instance->instance)
 669     {
 670         vk_funcs->p_vkDestroyInstance(instance->instance, NULL /* allocator */);
 671         WINE_VK_REMOVE_HANDLE_MAPPING(instance, instance);
 672     }
 673
 674     pthread_rwlock_destroy(&instance->wrapper_lock);
 675     free(instance->utils_messengers);
 676
 677     free(instance);
 678 }
 679
 680 VkResult wine_vkAllocateCommandBuffers(VkDevice handle, const VkCommandBufferAllocateInfo *allocate_info,
 681                                        VkCommandBuffer *buffers )
 682 {
 683     struct wine_device *device = wine_device_from_handle(handle);
 684     struct wine_cmd_buffer *buffer;
 685     struct wine_cmd_pool *pool;
 686     VkResult res = VK_SUCCESS;
 687     unsigned int i;
 688
 689     pool = wine_cmd_pool_from_handle(allocate_info->commandPool);
 690
 691     for (i = 0; i < allocate_info->commandBufferCount; i++)
 692     {
 693         VkCommandBufferAllocateInfo allocate_info_host;
 694
 695         /* TODO: future extensions (none yet) may require pNext conversion. */
 696         allocate_info_host.pNext = allocate_info->pNext;
 697         allocate_info_host.sType = allocate_info->sType;
 698         allocate_info_host.commandPool = pool->command_pool;
 699         allocate_info_host.level = allocate_info->level;
 700         allocate_info_host.commandBufferCount = 1;
 701
 702         TRACE("Allocating command buffer %u from pool 0x%s.\n",
 703                 i, wine_dbgstr_longlong(allocate_info_host.commandPool));
 704
 705         if (!(buffer = calloc(1, sizeof(*buffer))))
 706         {
 707             res = VK_ERROR_OUT_OF_HOST_MEMORY;
 708             break;
 709         }
 710
 711         buffer->handle = buffers[i];
 712         buffer->device = device;
 713         res = device->funcs.p_vkAllocateCommandBuffers(device->device,
 714                 &allocate_info_host, &buffer->command_buffer);
 715         buffer->handle->base.unix_handle = (uintptr_t)buffer;
 716         WINE_VK_ADD_DISPATCHABLE_MAPPING(device->phys_dev->instance, buffer->handle,
 717                                          buffer->command_buffer, buffer);
 718         if (res != VK_SUCCESS)
 719         {
 720             ERR("Failed to allocate command buffer, res=%d.\n", res);
 721             buffer->command_buffer = VK_NULL_HANDLE;
 722             break;
 723         }
 724     }
 725
 726     if (res != VK_SUCCESS)
 727         wine_vk_free_command_buffers(device, pool, i + 1, buffers);
 728
 729     return res;
 730 }
 731
 732 VkResult wine_vkCreateDevice(VkPhysicalDevice phys_dev_handle, const VkDeviceCreateInfo *create_info,
 733                              const VkAllocationCallbacks *allocator, VkDevice *ret_device,
 734                              void *client_ptr)
 735 {
 736     struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(phys_dev_handle);
 737     VkDevice device_handle = client_ptr;
 738     VkDeviceCreateInfo create_info_host;
 739     struct VkQueue_T *queue_handles;
 740     struct wine_queue *next_queue;
 741     struct conversion_context ctx;
 742     struct wine_device *object;
 743     unsigned int i;
 744     VkResult res;
 745
 746     if (allocator)
 747         FIXME("Support for allocation callbacks not implemented yet\n");
 748
 749     if (TRACE_ON(vulkan))
 750     {
 751         VkPhysicalDeviceProperties properties;
 752
 753         phys_dev->instance->funcs.p_vkGetPhysicalDeviceProperties(phys_dev->phys_dev, &properties);
 754
 755         TRACE("Device name: %s.\n", debugstr_a(properties.deviceName));
 756         TRACE("Vendor ID: %#x, Device ID: %#x.\n", properties.vendorID, properties.deviceID);
 757         TRACE("Driver version: %#x.\n", properties.driverVersion);
 758     }
 759
 760     if (!(object = calloc(1, sizeof(*object))))
 761         return VK_ERROR_OUT_OF_HOST_MEMORY;
 762
 763     object->phys_dev = phys_dev;
 764
 765     init_conversion_context(&ctx);
 766     res = wine_vk_device_convert_create_info(phys_dev, &ctx, create_info, &create_info_host);
 767     if (res == VK_SUCCESS)
 768         res = phys_dev->instance->funcs.p_vkCreateDevice(phys_dev->phys_dev,
 769                 &create_info_host, NULL /* allocator */, &object->device);
 770     free_conversion_context(&ctx);
 771     WINE_VK_ADD_DISPATCHABLE_MAPPING(phys_dev->instance, device_handle, object->device, object);
 772     if (res != VK_SUCCESS)
 773     {
 774         WARN("Failed to create device, res=%d.\n", res);
 775         goto fail;
 776     }
 777
 778     /* Just load all function pointers we are aware off. The loader takes care of filtering.
 779      * We use vkGetDeviceProcAddr as opposed to vkGetInstanceProcAddr for efficiency reasons
 780      * as functions pass through fewer dispatch tables within the loader.
 781      */
 782 #define USE_VK_FUNC(name) \
 783     object->funcs.p_##name = (void *)vk_funcs->p_vkGetDeviceProcAddr(object->device, #name); \
 784     if (object->funcs.p_##name == NULL) \
 785         TRACE("Not found '%s'.\n", #name);
 786     ALL_VK_DEVICE_FUNCS()
 787 #undef USE_VK_FUNC
 788
 789     /* We need to cache all queues within the device as each requires wrapping since queues are
 790      * dispatchable objects.
 791      */
 792     for (i = 0; i < create_info_host.queueCreateInfoCount; i++)
 793     {
 794         object->queue_count += create_info_host.pQueueCreateInfos[i].queueCount;
 795     }
 796
 797     if (!(object->queues = calloc(object->queue_count, sizeof(*object->queues))))
 798     {
 799         res = VK_ERROR_OUT_OF_HOST_MEMORY;
 800         goto fail;
 801     }
 802
 803     next_queue = object->queues;
 804     queue_handles = device_handle->queues;
 805     for (i = 0; i < create_info_host.queueCreateInfoCount; i++)
 806     {
 807         uint32_t flags = create_info_host.pQueueCreateInfos[i].flags;
 808         uint32_t family_index = create_info_host.pQueueCreateInfos[i].queueFamilyIndex;
 809         uint32_t queue_count = create_info_host.pQueueCreateInfos[i].queueCount;
 810
 811         TRACE("Queue family index %u, queue count %u.\n", family_index, queue_count);
 812
 813         wine_vk_device_get_queues(object, family_index, queue_count, flags, next_queue, &queue_handles);
 814         next_queue += queue_count;
 815     }
 816
 817     device_handle->quirks = phys_dev->instance->quirks;
 818     device_handle->base.unix_handle = (uintptr_t)object;
 819     *ret_device = device_handle;
 820     TRACE("Created device %p (native device %p).\n", object, object->device);
 821     return VK_SUCCESS;
 822
 823 fail:
 824     wine_vk_device_free(object);
 825     return res;
 826 }
 827
 828 VkResult wine_vkCreateInstance(const VkInstanceCreateInfo *create_info,
 829                                const VkAllocationCallbacks *allocator, VkInstance *instance,
 830                                void *client_ptr)
 831 {
 832     VkInstance client_instance = client_ptr;
 833     VkInstanceCreateInfo create_info_host;
 834     const VkApplicationInfo *app_info;
 835     struct conversion_context ctx;
 836     struct wine_instance *object;
 837     VkResult res;
 838
 839     if (allocator)
 840         FIXME("Support for allocation callbacks not implemented yet\n");
 841
 842     if (!(object = calloc(1, sizeof(*object))))
 843     {
 844         ERR("Failed to allocate memory for instance\n");
 845         return VK_ERROR_OUT_OF_HOST_MEMORY;
 846     }
 847     list_init(&object->wrappers);
 848     pthread_rwlock_init(&object->wrapper_lock, NULL);
 849
 850     init_conversion_context(&ctx);
 851     res = wine_vk_instance_convert_create_info(&ctx, create_info, &create_info_host, object);
 852     if (res == VK_SUCCESS)
 853         res = vk_funcs->p_vkCreateInstance(&create_info_host, NULL /* allocator */, &object->instance);
 854     free_conversion_context(&ctx);
 855     if (res != VK_SUCCESS)
 856     {
 857         ERR("Failed to create instance, res=%d\n", res);
 858         wine_vk_instance_free(object);
 859         return res;
 860     }
 861
 862     object->handle = client_instance;
 863     WINE_VK_ADD_DISPATCHABLE_MAPPING(object, object->handle, object->instance, object);
 864
 865     /* Load all instance functions we are aware of. Note the loader takes care
 866      * of any filtering for extensions which were not requested, but which the
 867      * ICD may support.
 868      */
 869 #define USE_VK_FUNC(name) \
 870     object->funcs.p_##name = (void *)vk_funcs->p_vkGetInstanceProcAddr(object->instance, #name);
 871     ALL_VK_INSTANCE_FUNCS()
 872 #undef USE_VK_FUNC
 873
 874     /* Cache physical devices for vkEnumeratePhysicalDevices within the instance as
 875      * each vkPhysicalDevice is a dispatchable object, which means we need to wrap
 876      * the native physical devices and present those to the application.
 877      * Cleanup happens as part of wine_vkDestroyInstance.
 878      */
 879     res = wine_vk_instance_load_physical_devices(object);
 880     if (res != VK_SUCCESS)
 881     {
 882         ERR("Failed to load physical devices, res=%d\n", res);
 883         wine_vk_instance_free(object);
 884         return res;
 885     }
 886
 887     if ((app_info = create_info->pApplicationInfo))
 888     {
 889         TRACE("Application name %s, application version %#x.\n",
 890                 debugstr_a(app_info->pApplicationName), app_info->applicationVersion);
 891         TRACE("Engine name %s, engine version %#x.\n", debugstr_a(app_info->pEngineName),
 892                 app_info->engineVersion);
 893         TRACE("API version %#x.\n", app_info->apiVersion);
 894
 895         if (app_info->pEngineName && !strcmp(app_info->pEngineName, "idTech"))
 896             object->quirks |= WINEVULKAN_QUIRK_GET_DEVICE_PROC_ADDR;
 897     }
 898
 899     object->quirks |= WINEVULKAN_QUIRK_ADJUST_MAX_IMAGE_COUNT;
 900
 901     client_instance->base.unix_handle = (uintptr_t)object;
 902     *instance = client_instance;
 903     TRACE("Created instance %p (native instance %p).\n", object, object->instance);
 904     return VK_SUCCESS;
 905 }
 906
 907 void wine_vkDestroyDevice(VkDevice handle, const VkAllocationCallbacks *allocator)
 908 {
 909     struct wine_device *device = wine_device_from_handle(handle);
 910
 911     if (allocator)
 912         FIXME("Support for allocation callbacks not implemented yet\n");
 913
 914     wine_vk_device_free(device);
 915 }
 916
 917 void wine_vkDestroyInstance(VkInstance handle, const VkAllocationCallbacks *allocator)
 918 {
 919     struct wine_instance *instance = wine_instance_from_handle(handle);
 920
 921     if (allocator)
 922         FIXME("Support allocation allocators\n");
 923
 924     wine_vk_instance_free(instance);
 925 }
 926
 927 VkResult wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice phys_dev_handle, const char *layer_name,
 928                                                    uint32_t *count, VkExtensionProperties *properties)
 929 {
 930     struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(phys_dev_handle);
 931
 932     /* This shouldn't get called with layer_name set, the ICD loader prevents it. */
 933     if (layer_name)
 934     {
 935         ERR("Layer enumeration not supported from ICD.\n");
 936         return VK_ERROR_LAYER_NOT_PRESENT;
 937     }
 938
 939     if (!properties)
 940     {
 941         *count = phys_dev->extension_count;
 942         return VK_SUCCESS;
 943     }
 944
 945     *count = min(*count, phys_dev->extension_count);
 946     memcpy(properties, phys_dev->extensions, *count * sizeof(*properties));
 947
 948     TRACE("Returning %u extensions.\n", *count);
 949     return *count < phys_dev->extension_count ? VK_INCOMPLETE : VK_SUCCESS;
 950 }
 951
 952 VkResult wine_vkEnumerateInstanceExtensionProperties(const char *name, uint32_t *count,
 953                                                      VkExtensionProperties *properties)
 954 {
 955     uint32_t num_properties = 0, num_host_properties;
 956     VkExtensionProperties *host_properties;
 957     unsigned int i, j;
 958     VkResult res;
 959
 960     res = vk_funcs->p_vkEnumerateInstanceExtensionProperties(NULL, &num_host_properties, NULL);
 961     if (res != VK_SUCCESS)
 962         return res;
 963
 964     if (!(host_properties = calloc(num_host_properties, sizeof(*host_properties))))
 965         return VK_ERROR_OUT_OF_HOST_MEMORY;
 966
 967     res = vk_funcs->p_vkEnumerateInstanceExtensionProperties(NULL, &num_host_properties, host_properties);
 968     if (res != VK_SUCCESS)
 969     {
 970         ERR("Failed to retrieve host properties, res=%d.\n", res);
 971         free(host_properties);
 972         return res;
 973     }
 974
 975     /* The Wine graphics driver provides us with all extensions supported by the host side
 976      * including extension fixup (e.g. VK_KHR_xlib_surface -> VK_KHR_win32_surface). It is
 977      * up to us here to filter the list down to extensions for which we have thunks.
 978      */
 979     for (i = 0; i < num_host_properties; i++)
 980     {
 981         if (wine_vk_instance_extension_supported(host_properties[i].extensionName))
 982             num_properties++;
 983         else
 984             TRACE("Instance extension '%s' is not supported.\n", host_properties[i].extensionName);
 985     }
 986
 987     if (!properties)
 988     {
 989         TRACE("Returning %u extensions.\n", num_properties);
 990         *count = num_properties;
 991         free(host_properties);
 992         return VK_SUCCESS;
 993     }
 994
 995     for (i = 0, j = 0; i < num_host_properties && j < *count; i++)
 996     {
 997         if (wine_vk_instance_extension_supported(host_properties[i].extensionName))
 998         {
 999             TRACE("Enabling extension '%s'.\n", host_properties[i].extensionName);
1000             properties[j++] = host_properties[i];
1001         }
1002     }
1003     *count = min(*count, num_properties);
1004
1005     free(host_properties);
1006     return *count < num_properties ? VK_INCOMPLETE : VK_SUCCESS;
1007 }
1008
1009 VkResult wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice phys_dev, uint32_t *count,
1010                                                VkLayerProperties *properties)
1011 {
1012     *count = 0;
1013     return VK_SUCCESS;
1014 }
1015
1016 VkResult wine_vkEnumerateInstanceVersion(uint32_t *version)
1017 {
1018     VkResult res;
1019
1020     static VkResult (*p_vkEnumerateInstanceVersion)(uint32_t *version);
1021     if (!p_vkEnumerateInstanceVersion)
1022         p_vkEnumerateInstanceVersion = vk_funcs->p_vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion");
1023
1024     if (p_vkEnumerateInstanceVersion)
1025     {
1026         res = p_vkEnumerateInstanceVersion(version);
1027     }
1028     else
1029     {
1030         *version = VK_API_VERSION_1_0;
1031         res = VK_SUCCESS;
1032     }
1033
1034     TRACE("API version %u.%u.%u.\n",
1035             VK_VERSION_MAJOR(*version), VK_VERSION_MINOR(*version), VK_VERSION_PATCH(*version));
1036     *version = min(WINE_VK_VERSION, *version);
1037     return res;
1038 }
1039
1040 VkResult wine_vkEnumeratePhysicalDevices(VkInstance handle, uint32_t *count, VkPhysicalDevice *devices)
1041 {
1042     struct wine_instance *instance = wine_instance_from_handle(handle);
1043     unsigned int i;
1044
1045     if (!devices)
1046     {
1047         *count = instance->phys_dev_count;
1048         return VK_SUCCESS;
1049     }
1050
1051     *count = min(*count, instance->phys_dev_count);
1052     for (i = 0; i < *count; i++)
1053     {
1054         devices[i] = instance->phys_devs[i]->handle;
1055     }
1056
1057     TRACE("Returning %u devices.\n", *count);
1058     return *count < instance->phys_dev_count ? VK_INCOMPLETE : VK_SUCCESS;
1059 }
1060
1061 void wine_vkFreeCommandBuffers(VkDevice handle, VkCommandPool command_pool, uint32_t count,
1062                                const VkCommandBuffer *buffers)
1063 {
1064     struct wine_device *device = wine_device_from_handle(handle);
1065     struct wine_cmd_pool *pool = wine_cmd_pool_from_handle(command_pool);
1066
1067     wine_vk_free_command_buffers(device, pool, count, buffers);
1068 }
1069
1070 static VkQueue wine_vk_device_find_queue(VkDevice handle, const VkDeviceQueueInfo2 *info)
1071 {
1072     struct wine_device *device = wine_device_from_handle(handle);
1073     struct wine_queue *queue;
1074     uint32_t i;
1075
1076     for (i = 0; i < device->queue_count; i++)
1077     {
1078         queue = &device->queues[i];
1079         if (queue->family_index == info->queueFamilyIndex
1080                 && queue->queue_index == info->queueIndex
1081                 && queue->flags == info->flags)
1082         {
1083             return queue->handle;
1084         }
1085     }
1086
1087     return VK_NULL_HANDLE;
1088 }
1089
1090 void wine_vkGetDeviceQueue(VkDevice device, uint32_t family_index, uint32_t queue_index, VkQueue *queue)
1091 {
1092     VkDeviceQueueInfo2 queue_info;
1093
1094     queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2;
1095     queue_info.pNext = NULL;
1096     queue_info.flags = 0;
1097     queue_info.queueFamilyIndex = family_index;
1098     queue_info.queueIndex = queue_index;
1099
1100     *queue = wine_vk_device_find_queue(device, &queue_info);
1101 }
1102
1103 void wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *info, VkQueue *queue)
1104 {
1105     const VkBaseInStructure *chain;
1106
1107     if ((chain = info->pNext))
1108         FIXME("Ignoring a linked structure of type %u.\n", chain->sType);
1109
1110     *queue = wine_vk_device_find_queue(device, info);
1111 }
1112
1113 VkResult wine_vkCreateCommandPool(VkDevice device_handle, const VkCommandPoolCreateInfo *info,
1114                                   const VkAllocationCallbacks *allocator, VkCommandPool *command_pool,
1115                                   void *client_ptr)
1116 {
1117     struct wine_device *device = wine_device_from_handle(device_handle);
1118     struct vk_command_pool *handle = client_ptr;
1119     struct wine_cmd_pool *object;
1120     VkResult res;
1121
1122     if (allocator)
1123         FIXME("Support for allocation callbacks not implemented yet\n");
1124
1125     if (!(object = calloc(1, sizeof(*object))))
1126         return VK_ERROR_OUT_OF_HOST_MEMORY;
1127
1128     res = device->funcs.p_vkCreateCommandPool(device->device, info, NULL, &object->command_pool);
1129
1130     if (res == VK_SUCCESS)
1131     {
1132         object->handle = (uintptr_t)handle;
1133         handle->unix_handle = (uintptr_t)object;
1134         WINE_VK_ADD_NON_DISPATCHABLE_MAPPING(device->phys_dev->instance, object->handle,
1135                                              object->command_pool, object);
1136         *command_pool = object->handle;
1137     }
1138     else
1139     {
1140         free(object);
1141     }
1142
1143     return res;
1144 }
1145
1146 void wine_vkDestroyCommandPool(VkDevice device_handle, VkCommandPool handle,
1147                                const VkAllocationCallbacks *allocator)
1148 {
1149     struct wine_device *device = wine_device_from_handle(device_handle);
1150     struct wine_cmd_pool *pool = wine_cmd_pool_from_handle(handle);
1151
1152     if (allocator)
1153         FIXME("Support for allocation callbacks not implemented yet\n");
1154
1155     WINE_VK_REMOVE_HANDLE_MAPPING(device->phys_dev->instance, pool);
1156
1157     device->funcs.p_vkDestroyCommandPool(device->device, pool->command_pool, NULL);
1158     free(pool);
1159 }
1160
1161 static VkResult wine_vk_enumerate_physical_device_groups(struct wine_instance *instance,
1162         VkResult (*p_vkEnumeratePhysicalDeviceGroups)(VkInstance, uint32_t *, VkPhysicalDeviceGroupProperties *),
1163         uint32_t *count, VkPhysicalDeviceGroupProperties *properties)
1164 {
1165     unsigned int i, j;
1166     VkResult res;
1167
1168     res = p_vkEnumeratePhysicalDeviceGroups(instance->instance, count, properties);
1169     if (res < 0 || !properties)
1170         return res;
1171
1172     for (i = 0; i < *count; ++i)
1173     {
1174         VkPhysicalDeviceGroupProperties *current = &properties[i];
1175         for (j = 0; j < current->physicalDeviceCount; ++j)
1176         {
1177             VkPhysicalDevice dev = current->physicalDevices[j];
1178             struct wine_phys_dev *phys_dev = wine_vk_instance_wrap_physical_device(instance, dev);
1179             if (!phys_dev)
1180                 return VK_ERROR_INITIALIZATION_FAILED;
1181             current->physicalDevices[j] = phys_dev->handle;
1182         }
1183     }
1184
1185     return res;
1186 }
1187
1188 VkResult wine_vkEnumeratePhysicalDeviceGroups(VkInstance handle, uint32_t *count,
1189                                               VkPhysicalDeviceGroupProperties *properties)
1190 {
1191     struct wine_instance *instance = wine_instance_from_handle(handle);
1192
1193     return wine_vk_enumerate_physical_device_groups(instance,
1194             instance->funcs.p_vkEnumeratePhysicalDeviceGroups, count, properties);
1195 }
1196
1197 VkResult wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance handle, uint32_t *count,
1198                                                  VkPhysicalDeviceGroupProperties *properties)
1199 {
1200     struct wine_instance *instance = wine_instance_from_handle(handle);
1201
1202     return wine_vk_enumerate_physical_device_groups(instance,
1203             instance->funcs.p_vkEnumeratePhysicalDeviceGroupsKHR, count, properties);
1204 }
1205
1206 void wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice phys_dev,
1207                                                      const VkPhysicalDeviceExternalFenceInfo *fence_info,
1208                                                      VkExternalFenceProperties *properties)
1209 {
1210     properties->exportFromImportedHandleTypes = 0;
1211     properties->compatibleHandleTypes = 0;
1212     properties->externalFenceFeatures = 0;
1213 }
1214
1215 void wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice phys_dev,
1216                                                         const VkPhysicalDeviceExternalFenceInfo *fence_info,
1217                                                         VkExternalFenceProperties *properties)
1218 {
1219     properties->exportFromImportedHandleTypes = 0;
1220     properties->compatibleHandleTypes = 0;
1221     properties->externalFenceFeatures = 0;
1222 }
1223
1224 void wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice phys_dev,
1225                                                       const VkPhysicalDeviceExternalBufferInfo *buffer_info,
1226                                                       VkExternalBufferProperties *properties)
1227 {
1228     memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
1229 }
1230
1231 void wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice phys_dev,
1232                                                          const VkPhysicalDeviceExternalBufferInfo *buffer_info,
1233                                                          VkExternalBufferProperties *properties)
1234 {
1235     memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
1236 }
1237
1238 VkResult wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice phys_dev_handle,
1239                                                         const VkPhysicalDeviceImageFormatInfo2 *format_info,
1240                                                         VkImageFormatProperties2 *properties)
1241 {
1242     struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(phys_dev_handle);
1243     VkExternalImageFormatProperties *external_image_properties;
1244     VkResult res;
1245
1246     res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(phys_dev->phys_dev,
1247             format_info, properties);
1248
1249     if ((external_image_properties = find_next_struct(properties,
1250                                                       VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES)))
1251     {
1252         VkExternalMemoryProperties *p = &external_image_properties->externalMemoryProperties;
1253         p->externalMemoryFeatures = 0;
1254         p->exportFromImportedHandleTypes = 0;
1255         p->compatibleHandleTypes = 0;
1256     }
1257
1258     return res;
1259 }
1260
1261 VkResult wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phys_dev_handle,
1262                                                            const VkPhysicalDeviceImageFormatInfo2 *format_info,
1263                                                            VkImageFormatProperties2 *properties)
1264 {
1265     struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(phys_dev_handle);
1266     VkExternalImageFormatProperties *external_image_properties;
1267     VkResult res;
1268
1269     res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(phys_dev->phys_dev,
1270             format_info, properties);
1271
1272     if ((external_image_properties = find_next_struct(properties,
1273                                                       VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES)))
1274     {
1275         VkExternalMemoryProperties *p = &external_image_properties->externalMemoryProperties;
1276         p->externalMemoryFeatures = 0;
1277         p->exportFromImportedHandleTypes = 0;
1278         p->compatibleHandleTypes = 0;
1279     }
1280
1281     return res;
1282 }
1283
1284 /* From ntdll/unix/sync.c */
1285 #define NANOSECONDS_IN_A_SECOND 1000000000
1286 #define TICKSPERSEC             10000000
1287
1288 static inline VkTimeDomainEXT get_performance_counter_time_domain(void)
1289 {
1290 #if !defined(__APPLE__) && defined(HAVE_CLOCK_GETTIME)
1291 # ifdef CLOCK_MONOTONIC_RAW
1292     return VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT;
1293 # else
1294     return VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT;
1295 # endif
1296 #else
1297     FIXME("No mapping for VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT on this platform.\n");
1298     return VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT;
1299 #endif
1300 }
1301
1302 static VkTimeDomainEXT map_to_host_time_domain(VkTimeDomainEXT domain)
1303 {
1304     /* Matches ntdll/unix/sync.c's performance counter implementation. */
1305     if (domain == VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT)
1306         return get_performance_counter_time_domain();
1307
1308     return domain;
1309 }
1310
1311 static inline uint64_t convert_monotonic_timestamp(uint64_t value)
1312 {
1313     return value / (NANOSECONDS_IN_A_SECOND / TICKSPERSEC);
1314 }
1315
1316 static inline uint64_t convert_timestamp(VkTimeDomainEXT host_domain, VkTimeDomainEXT target_domain, uint64_t value)
1317 {
1318     if (host_domain == target_domain)
1319         return value;
1320
1321     /* Convert between MONOTONIC time in ns -> QueryPerformanceCounter */
1322     if ((host_domain == VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT || host_domain == VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT)
1323             && target_domain == VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT)
1324         return convert_monotonic_timestamp(value);
1325
1326     FIXME("Couldn't translate between host domain %d and target domain %d\n", host_domain, target_domain);
1327     return value;
1328 }
1329
1330 VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice handle, uint32_t timestamp_count,
1331                                            const VkCalibratedTimestampInfoEXT *timestamp_infos,
1332                                            uint64_t *timestamps, uint64_t *max_deviation)
1333 {
1334     struct wine_device *device = wine_device_from_handle(handle);
1335     VkCalibratedTimestampInfoEXT* host_timestamp_infos;
1336     unsigned int i;
1337     VkResult res;
1338     TRACE("%p, %u, %p, %p, %p\n", device, timestamp_count, timestamp_infos, timestamps, max_deviation);
1339
1340     if (!(host_timestamp_infos = malloc(sizeof(VkCalibratedTimestampInfoEXT) * timestamp_count)))
1341         return VK_ERROR_OUT_OF_HOST_MEMORY;
1342
1343     for (i = 0; i < timestamp_count; i++)
1344     {
1345         host_timestamp_infos[i].sType = timestamp_infos[i].sType;
1346         host_timestamp_infos[i].pNext = timestamp_infos[i].pNext;
1347         host_timestamp_infos[i].timeDomain = map_to_host_time_domain(timestamp_infos[i].timeDomain);
1348     }
1349
1350     res = device->funcs.p_vkGetCalibratedTimestampsEXT(device->device, timestamp_count, host_timestamp_infos, timestamps, max_deviation);
1351     if (res != VK_SUCCESS)
1352         return res;
1353
1354     for (i = 0; i < timestamp_count; i++)
1355         timestamps[i] = convert_timestamp(host_timestamp_infos[i].timeDomain, timestamp_infos[i].timeDomain, timestamps[i]);
1356
1357     free(host_timestamp_infos);
1358
1359     return res;
1360 }
1361
1362 VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice handle,
1363                                                              uint32_t *time_domain_count,
1364                                                              VkTimeDomainEXT *time_domains)
1365 {
1366     struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle);
1367     BOOL supports_device = FALSE, supports_monotonic = FALSE, supports_monotonic_raw = FALSE;
1368     const VkTimeDomainEXT performance_counter_domain = get_performance_counter_time_domain();
1369     VkTimeDomainEXT *host_time_domains;
1370     uint32_t host_time_domain_count;
1371     VkTimeDomainEXT out_time_domains[2];
1372     uint32_t out_time_domain_count;
1373     unsigned int i;
1374     VkResult res;
1375
1376     /* Find out the time domains supported on the host */
1377     res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(phys_dev->phys_dev, &host_time_domain_count, NULL);
1378     if (res != VK_SUCCESS)
1379         return res;
1380
1381     if (!(host_time_domains = malloc(sizeof(VkTimeDomainEXT) * host_time_domain_count)))
1382         return VK_ERROR_OUT_OF_HOST_MEMORY;
1383
1384     res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(phys_dev->phys_dev, &host_time_domain_count, host_time_domains);
1385     if (res != VK_SUCCESS)
1386     {
1387         free(host_time_domains);
1388         return res;
1389     }
1390
1391     for (i = 0; i < host_time_domain_count; i++)
1392     {
1393         if (host_time_domains[i] == VK_TIME_DOMAIN_DEVICE_EXT)
1394             supports_device = TRUE;
1395         else if (host_time_domains[i] == VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT)
1396             supports_monotonic = TRUE;
1397         else if (host_time_domains[i] == VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT)
1398             supports_monotonic_raw = TRUE;
1399         else
1400             FIXME("Unknown time domain %d\n", host_time_domains[i]);
1401     }
1402
1403     free(host_time_domains);
1404
1405     out_time_domain_count = 0;
1406
1407     /* Map our monotonic times -> QPC */
1408     if (supports_monotonic_raw && performance_counter_domain == VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT)
1409         out_time_domains[out_time_domain_count++] = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT;
1410     else if (supports_monotonic && performance_counter_domain == VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT)
1411         out_time_domains[out_time_domain_count++] = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT;
1412     else
1413         FIXME("VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT not supported on this platform.\n");
1414
1415     /* Forward the device domain time */
1416     if (supports_device)
1417         out_time_domains[out_time_domain_count++] = VK_TIME_DOMAIN_DEVICE_EXT;
1418
1419     /* Send the count/domains back to the app */
1420     if (!time_domains)
1421     {
1422         *time_domain_count = out_time_domain_count;
1423         return VK_SUCCESS;
1424     }
1425
1426     for (i = 0; i < min(*time_domain_count, out_time_domain_count); i++)
1427         time_domains[i] = out_time_domains[i];
1428
1429     res = *time_domain_count < out_time_domain_count ? VK_INCOMPLETE : VK_SUCCESS;
1430     *time_domain_count = out_time_domain_count;
1431     return res;
1432 }
1433
1434 void wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice phys_dev,
1435                                                          const VkPhysicalDeviceExternalSemaphoreInfo *info,
1436                                                          VkExternalSemaphoreProperties *properties)
1437 {
1438     properties->exportFromImportedHandleTypes = 0;
1439     properties->compatibleHandleTypes = 0;
1440     properties->externalSemaphoreFeatures = 0;
1441 }
1442
1443 void wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice phys_dev,
1444                                                             const VkPhysicalDeviceExternalSemaphoreInfo *info,
1445                                                             VkExternalSemaphoreProperties *properties)
1446 {
1447     properties->exportFromImportedHandleTypes = 0;
1448     properties->compatibleHandleTypes = 0;
1449     properties->externalSemaphoreFeatures = 0;
1450 }
1451
1452 VkResult wine_vkCreateWin32SurfaceKHR(VkInstance handle, const VkWin32SurfaceCreateInfoKHR *createInfo,
1453                                       const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
1454 {
1455     struct wine_instance *instance = wine_instance_from_handle(handle);
1456     struct wine_surface *object;
1457     VkResult res;
1458
1459     if (allocator)
1460         FIXME("Support for allocation callbacks not implemented yet\n");
1461
1462     object = calloc(1, sizeof(*object));
1463
1464     if (!object)
1465         return VK_ERROR_OUT_OF_HOST_MEMORY;
1466
1467     res = instance->funcs.p_vkCreateWin32SurfaceKHR(instance->instance, createInfo, NULL, &object->driver_surface);
1468
1469     if (res != VK_SUCCESS)
1470     {
1471         free(object);
1472         return res;
1473     }
1474
1475     object->surface = vk_funcs->p_wine_get_native_surface(object->driver_surface);
1476
1477     WINE_VK_ADD_NON_DISPATCHABLE_MAPPING(instance, object, object->surface, object);
1478
1479     *surface = wine_surface_to_handle(object);
1480
1481     return VK_SUCCESS;
1482 }
1483
1484 void wine_vkDestroySurfaceKHR(VkInstance handle, VkSurfaceKHR surface,
1485                               const VkAllocationCallbacks *allocator)
1486 {
1487     struct wine_instance *instance = wine_instance_from_handle(handle);
1488     struct wine_surface *object = wine_surface_from_handle(surface);
1489
1490     if (!object)
1491         return;
1492
1493     instance->funcs.p_vkDestroySurfaceKHR(instance->instance, object->driver_surface, NULL);
1494
1495     WINE_VK_REMOVE_HANDLE_MAPPING(instance, object);
1496     free(object);
1497 }
1498
1499 VkResult wine_vkAllocateMemory(VkDevice handle, const VkMemoryAllocateInfo *alloc_info,
1500                                const VkAllocationCallbacks *allocator, VkDeviceMemory *ret)
1501 {
1502     struct wine_device *device = wine_device_from_handle(handle);
1503     struct wine_device_memory *memory;
1504     VkMemoryAllocateInfo info = *alloc_info;
1505     VkImportMemoryHostPointerInfoEXT host_pointer_info;
1506     uint32_t mem_flags;
1507     void *mapping = NULL;
1508     VkResult result;
1509
1510     /* For host visible memory, we try to use VK_EXT_external_memory_host on wow64
1511      * to ensure that mapped pointer is 32-bit. */
1512     mem_flags = device->phys_dev->memory_properties.memoryTypes[alloc_info->memoryTypeIndex].propertyFlags;
1513     if (device->phys_dev->external_memory_align && (mem_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) &&
1514         !find_next_struct(alloc_info->pNext, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT))
1515     {
1516         VkMemoryHostPointerPropertiesEXT props =
1517         {
1518             .sType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
1519         };
1520         uint32_t i, align = device->phys_dev->external_memory_align - 1;
1521         SIZE_T alloc_size = info.allocationSize;
1522         static int once;
1523
1524         if (!once++)
1525             FIXME("Using VK_EXT_external_memory_host\n");
1526
1527         if (NtAllocateVirtualMemory(GetCurrentProcess(), &mapping, zero_bits, &alloc_size,
1528                                     MEM_COMMIT, PAGE_READWRITE))
1529         {
1530             ERR("NtAllocateVirtualMemory failed\n");
1531             return VK_ERROR_OUT_OF_HOST_MEMORY;
1532         }
1533
1534         result = device->funcs.p_vkGetMemoryHostPointerPropertiesEXT(device->device,
1535                 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, mapping, &props);
1536         if (result != VK_SUCCESS)
1537         {
1538             ERR("vkGetMemoryHostPointerPropertiesEXT failed: %d\n", result);
1539             return result;
1540         }
1541
1542         if (!(props.memoryTypeBits & (1u << info.memoryTypeIndex)))
1543         {
1544             /* If requested memory type is not allowed to use external memory,
1545              * try to find a supported compatible type. */
1546             uint32_t mask = mem_flags & ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
1547             for (i = 0; i < device->phys_dev->memory_properties.memoryTypeCount; i++)
1548             {
1549                 if (!(props.memoryTypeBits & (1u << i)))
1550                     continue;
1551                 if ((device->phys_dev->memory_properties.memoryTypes[i].propertyFlags & mask) != mask)
1552                     continue;
1553
1554                 TRACE("Memory type not compatible with host memory, using %u instead\n", i);
1555                 info.memoryTypeIndex = i;
1556                 break;
1557             }
1558             if (i == device->phys_dev->memory_properties.memoryTypeCount)
1559             {
1560                 FIXME("Not found compatible memory type\n");
1561                 alloc_size = 0;
1562                 NtFreeVirtualMemory(GetCurrentProcess(), &mapping, &alloc_size, MEM_RELEASE);
1563             }
1564         }
1565
1566         if (props.memoryTypeBits & (1u << info.memoryTypeIndex))
1567         {
1568             host_pointer_info.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
1569             host_pointer_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
1570             host_pointer_info.pHostPointer = mapping;
1571             host_pointer_info.pNext = info.pNext;
1572             info.pNext = &host_pointer_info;
1573
1574             info.allocationSize = (info.allocationSize + align) & ~align;
1575         }
1576     }
1577
1578     if (!(memory = malloc(sizeof(*memory))))
1579         return VK_ERROR_OUT_OF_HOST_MEMORY;
1580
1581     result = device->funcs.p_vkAllocateMemory(device->device, &info, NULL, &memory->memory);
1582     if (result != VK_SUCCESS)
1583     {
1584         free(memory);
1585         return result;
1586     }
1587
1588     memory->mapping = mapping;
1589     *ret = (VkDeviceMemory)(uintptr_t)memory;
1590     return VK_SUCCESS;
1591 }
1592
1593 void wine_vkFreeMemory(VkDevice handle, VkDeviceMemory memory_handle, const VkAllocationCallbacks *allocator)
1594 {
1595     struct wine_device *device = wine_device_from_handle(handle);
1596     struct wine_device_memory *memory;
1597
1598     if (!memory_handle)
1599         return;
1600     memory = wine_device_memory_from_handle(memory_handle);
1601
1602     device->funcs.p_vkFreeMemory(device->device, memory->memory, NULL);
1603
1604     if (memory->mapping)
1605     {
1606         SIZE_T alloc_size = 0;
1607         NtFreeVirtualMemory(GetCurrentProcess(), &memory->mapping, &alloc_size, MEM_RELEASE);
1608     }
1609
1610     free(memory);
1611 }
1612
1613 VkResult wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
1614                           VkDeviceSize size, VkMemoryMapFlags flags, void **data)
1615 {
1616     const VkMemoryMapInfoKHR info =
1617     {
1618       .sType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR,
1619       .flags = flags,
1620       .memory = memory,
1621       .offset = offset,
1622       .size = size,
1623    };
1624
1625    return wine_vkMapMemory2KHR(device, &info, data);
1626 }
1627
1628 VkResult wine_vkMapMemory2KHR(VkDevice handle, const VkMemoryMapInfoKHR *map_info, void **data)
1629 {
1630     struct wine_device *device = wine_device_from_handle(handle);
1631     struct wine_device_memory *memory = wine_device_memory_from_handle(map_info->memory);
1632     VkMemoryMapInfoKHR info = *map_info;
1633     VkResult result;
1634
1635     info.memory = memory->memory;
1636     if (memory->mapping)
1637     {
1638         *data = (char *)memory->mapping + info.offset;
1639         TRACE("returning %p\n", *data);
1640         return VK_SUCCESS;
1641     }
1642
1643     if (device->funcs.p_vkMapMemory2KHR)
1644     {
1645         result = device->funcs.p_vkMapMemory2KHR(device->device, &info, data);
1646     }
1647     else
1648     {
1649         assert(!info.pNext);
1650         result = device->funcs.p_vkMapMemory(device->device, info.memory, info.offset,
1651                                              info.size, info.flags, data);
1652     }
1653
1654 #ifdef _WIN64
1655     if (NtCurrentTeb()->WowTebOffset && result == VK_SUCCESS && (UINT_PTR)*data >> 32)
1656     {
1657         FIXME("returned mapping %p does not fit 32-bit pointer\n", *data);
1658         device->funcs.p_vkUnmapMemory(device->device, memory->memory);
1659         *data = NULL;
1660         result = VK_ERROR_OUT_OF_HOST_MEMORY;
1661     }
1662 #endif
1663
1664     return result;
1665 }
1666
1667 void wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
1668 {
1669     const VkMemoryUnmapInfoKHR info =
1670     {
1671         .sType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR,
1672         .memory = memory,
1673     };
1674
1675     wine_vkUnmapMemory2KHR(device, &info);
1676 }
1677
1678 VkResult wine_vkUnmapMemory2KHR(VkDevice handle, const VkMemoryUnmapInfoKHR *unmap_info)
1679 {
1680     struct wine_device *device = wine_device_from_handle(handle);
1681     struct wine_device_memory *memory = wine_device_memory_from_handle(unmap_info->memory);
1682     VkMemoryUnmapInfoKHR info;
1683
1684     if (memory->mapping)
1685         return VK_SUCCESS;
1686
1687     if (!device->funcs.p_vkUnmapMemory2KHR)
1688     {
1689         assert(!unmap_info->pNext);
1690         device->funcs.p_vkUnmapMemory(device->device, memory->memory);
1691         return VK_SUCCESS;
1692     }
1693
1694     info = *unmap_info;
1695     info.memory = memory->memory;
1696     return device->funcs.p_vkUnmapMemory2KHR(device->device, &info);
1697 }
1698
1699 VkResult wine_vkCreateBuffer(VkDevice handle, const VkBufferCreateInfo *create_info,
1700                              const VkAllocationCallbacks *allocator, VkBuffer *buffer)
1701 {
1702     struct wine_device *device = wine_device_from_handle(handle);
1703     VkExternalMemoryBufferCreateInfo external_memory_info;
1704     VkBufferCreateInfo info = *create_info;
1705
1706     if (device->phys_dev->external_memory_align &&
1707         !find_next_struct(info.pNext, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO))
1708     {
1709         external_memory_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
1710         external_memory_info.pNext = info.pNext;
1711         external_memory_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
1712         info.pNext = &external_memory_info;
1713     }
1714
1715     return device->funcs.p_vkCreateBuffer(device->device, &info, NULL, buffer);
1716 }
1717
1718 VkResult wine_vkCreateImage(VkDevice handle, const VkImageCreateInfo *create_info,
1719                             const VkAllocationCallbacks *allocator, VkImage *image)
1720 {
1721     struct wine_device *device = wine_device_from_handle(handle);
1722     VkExternalMemoryImageCreateInfo external_memory_info;
1723     VkImageCreateInfo info = *create_info;
1724
1725     if (device->phys_dev->external_memory_align &&
1726         !find_next_struct(info.pNext, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO))
1727     {
1728         external_memory_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
1729         external_memory_info.pNext = info.pNext;
1730         external_memory_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
1731         info.pNext = &external_memory_info;
1732     }
1733
1734     return device->funcs.p_vkCreateImage(device->device, &info, NULL, image);
1735 }
1736
1737 static inline void adjust_max_image_count(struct wine_phys_dev *phys_dev, VkSurfaceCapabilitiesKHR* capabilities)
1738 {
1739     /* Many Windows games, for example Strange Brigade, No Man's Sky, Path of Exile
1740      * and World War Z, do not expect that maxImageCount can be set to 0.
1741      * A value of 0 means that there is no limit on the number of images.
1742      * Nvidia reports 8 on Windows, AMD 16.
1743      * https://vulkan.gpuinfo.org/displayreport.php?id=9122#surface
1744      * https://vulkan.gpuinfo.org/displayreport.php?id=9121#surface
1745      */
1746     if ((phys_dev->instance->quirks & WINEVULKAN_QUIRK_ADJUST_MAX_IMAGE_COUNT) && !capabilities->maxImageCount)
1747     {
1748         capabilities->maxImageCount = max(capabilities->minImageCount, 16);
1749     }
1750 }
1751
1752 VkResult wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice handle, VkSurfaceKHR surface_handle,
1753                                                         VkSurfaceCapabilitiesKHR *capabilities)
1754 {
1755     struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle);
1756     struct wine_surface *surface = wine_surface_from_handle(surface_handle);
1757     VkResult res;
1758
1759     res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev->phys_dev,
1760             surface->driver_surface, capabilities);
1761
1762     if (res == VK_SUCCESS)
1763         adjust_max_image_count(phys_dev, capabilities);
1764
1765     return res;
1766 }
1767
1768 VkResult wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice handle,
1769                                                          const VkPhysicalDeviceSurfaceInfo2KHR *surface_info,
1770                                                          VkSurfaceCapabilities2KHR *capabilities)
1771 {
1772     struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle);
1773     struct wine_surface *surface = wine_surface_from_handle(surface_info->surface);
1774     VkPhysicalDeviceSurfaceInfo2KHR host_info;
1775     VkResult res;
1776
1777     host_info.sType = surface_info->sType;
1778     host_info.pNext = surface_info->pNext;
1779     host_info.surface = surface->driver_surface;
1780     res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev->phys_dev,
1781             &host_info, capabilities);
1782
1783     if (res == VK_SUCCESS)
1784         adjust_max_image_count(phys_dev, &capabilities->surfaceCapabilities);
1785
1786     return res;
1787 }
1788
1789 VkResult wine_vkCreateDebugUtilsMessengerEXT(VkInstance handle,
1790                                              const VkDebugUtilsMessengerCreateInfoEXT *create_info,
1791                                              const VkAllocationCallbacks *allocator,
1792                                              VkDebugUtilsMessengerEXT *messenger)
1793 {
1794     struct wine_instance *instance = wine_instance_from_handle(handle);
1795     VkDebugUtilsMessengerCreateInfoEXT wine_create_info;
1796     struct wine_debug_utils_messenger *object;
1797     VkResult res;
1798
1799     if (allocator)
1800         FIXME("Support for allocation callbacks not implemented yet\n");
1801
1802     if (!(object = calloc(1, sizeof(*object))))
1803         return VK_ERROR_OUT_OF_HOST_MEMORY;
1804
1805     object->instance = instance;
1806     object->user_callback = create_info->pfnUserCallback;
1807     object->user_data = create_info->pUserData;
1808
1809     wine_create_info = *create_info;
1810
1811     wine_create_info.pfnUserCallback = (void *) &debug_utils_callback_conversion;
1812     wine_create_info.pUserData = object;
1813
1814     res = instance->funcs.p_vkCreateDebugUtilsMessengerEXT(instance->instance, &wine_create_info, NULL,  &object->debug_messenger);
1815
1816     if (res != VK_SUCCESS)
1817     {
1818         free(object);
1819         return res;
1820     }
1821
1822     WINE_VK_ADD_NON_DISPATCHABLE_MAPPING(instance, object, object->debug_messenger, object);
1823     *messenger = wine_debug_utils_messenger_to_handle(object);
1824
1825     return VK_SUCCESS;
1826 }
1827
1828 void wine_vkDestroyDebugUtilsMessengerEXT(VkInstance handle, VkDebugUtilsMessengerEXT messenger,
1829                                           const VkAllocationCallbacks *allocator)
1830 {
1831     struct wine_instance *instance = wine_instance_from_handle(handle);
1832     struct wine_debug_utils_messenger *object;
1833
1834     object = wine_debug_utils_messenger_from_handle(messenger);
1835
1836     if (!object)
1837         return;
1838
1839     instance->funcs.p_vkDestroyDebugUtilsMessengerEXT(instance->instance, object->debug_messenger, NULL);
1840     WINE_VK_REMOVE_HANDLE_MAPPING(instance, object);
1841
1842     free(object);
1843 }
1844
1845 VkResult wine_vkCreateDebugReportCallbackEXT(VkInstance handle,
1846                                              const VkDebugReportCallbackCreateInfoEXT *create_info,
1847                                              const VkAllocationCallbacks *allocator,
1848                                              VkDebugReportCallbackEXT *callback)
1849 {
1850     struct wine_instance *instance = wine_instance_from_handle(handle);
1851     VkDebugReportCallbackCreateInfoEXT wine_create_info;
1852     struct wine_debug_report_callback *object;
1853     VkResult res;
1854
1855     if (allocator)
1856         FIXME("Support for allocation callbacks not implemented yet\n");
1857
1858     if (!(object = calloc(1, sizeof(*object))))
1859         return VK_ERROR_OUT_OF_HOST_MEMORY;
1860
1861     object->instance = instance;
1862     object->user_callback = create_info->pfnCallback;
1863     object->user_data = create_info->pUserData;
1864
1865     wine_create_info = *create_info;
1866
1867     wine_create_info.pfnCallback = (void *) debug_report_callback_conversion;
1868     wine_create_info.pUserData = object;
1869
1870     res = instance->funcs.p_vkCreateDebugReportCallbackEXT(instance->instance, &wine_create_info, NULL, &object->debug_callback);
1871
1872     if (res != VK_SUCCESS)
1873     {
1874         free(object);
1875         return res;
1876     }
1877
1878     WINE_VK_ADD_NON_DISPATCHABLE_MAPPING(instance, object, object->debug_callback, object);
1879     *callback = wine_debug_report_callback_to_handle(object);
1880
1881     return VK_SUCCESS;
1882 }
1883
1884 void wine_vkDestroyDebugReportCallbackEXT(VkInstance handle, VkDebugReportCallbackEXT callback,
1885                                           const VkAllocationCallbacks *allocator)
1886 {
1887     struct wine_instance *instance = wine_instance_from_handle(handle);
1888     struct wine_debug_report_callback *object;
1889
1890     object = wine_debug_report_callback_from_handle(callback);
1891
1892     if (!object)
1893         return;
1894
1895     instance->funcs.p_vkDestroyDebugReportCallbackEXT(instance->instance, object->debug_callback, NULL);
1896
1897     WINE_VK_REMOVE_HANDLE_MAPPING(instance, object);
1898
1899     free(object);
1900 }
1901
1902 VkResult wine_vkCreateDeferredOperationKHR(VkDevice                     handle,
1903                                            const VkAllocationCallbacks* allocator,
1904                                            VkDeferredOperationKHR*      deferredOperation)
1905 {
1906     struct wine_device *device = wine_device_from_handle(handle);
1907     struct wine_deferred_operation *object;
1908     VkResult res;
1909
1910     if (allocator)
1911         FIXME("Support for allocation callbacks not implemented yet\n");
1912
1913     if (!(object = calloc(1, sizeof(*object))))
1914         return VK_ERROR_OUT_OF_HOST_MEMORY;
1915
1916     res = device->funcs.p_vkCreateDeferredOperationKHR(device->device, NULL, &object->deferred_operation);
1917
1918     if (res != VK_SUCCESS)
1919     {
1920         free(object);
1921         return res;
1922     }
1923
1924     init_conversion_context(&object->ctx);
1925
1926     WINE_VK_ADD_NON_DISPATCHABLE_MAPPING(device->phys_dev->instance, object, object->deferred_operation, object);
1927     *deferredOperation = wine_deferred_operation_to_handle(object);
1928
1929     return VK_SUCCESS;
1930 }
1931
1932 void wine_vkDestroyDeferredOperationKHR(VkDevice                     handle,
1933                                         VkDeferredOperationKHR       operation,
1934                                         const VkAllocationCallbacks* allocator)
1935 {
1936     struct wine_device *device = wine_device_from_handle(handle);
1937     struct wine_deferred_operation *object;
1938
1939     object = wine_deferred_operation_from_handle(operation);
1940
1941     if (!object)
1942         return;
1943
1944     device->funcs.p_vkDestroyDeferredOperationKHR(device->device, object->deferred_operation, NULL);
1945
1946     WINE_VK_REMOVE_HANDLE_MAPPING(device->phys_dev->instance, object);
1947
1948     free_conversion_context(&object->ctx);
1949     free(object);
1950 }
1951
1952 #ifdef _WIN64
1953
1954 NTSTATUS vk_is_available_instance_function(void *arg)
1955 {
1956     struct is_available_instance_function_params *params = arg;
1957     struct wine_instance *instance = wine_instance_from_handle(params->instance);
1958     return !!vk_funcs->p_vkGetInstanceProcAddr(instance->instance, params->name);
1959 }
1960
1961 NTSTATUS vk_is_available_device_function(void *arg)
1962 {
1963     struct is_available_device_function_params *params = arg;
1964     struct wine_device *device = wine_device_from_handle(params->device);
1965     return !!vk_funcs->p_vkGetDeviceProcAddr(device->device, params->name);
1966 }
1967
1968 #endif /* _WIN64 */
1969
1970 NTSTATUS vk_is_available_instance_function32(void *arg)
1971 {
1972     struct
1973     {
1974         UINT32 instance;
1975         UINT32 name;
1976     } *params = arg;
1977     struct wine_instance *instance = wine_instance_from_handle(UlongToPtr(params->instance));
1978     return !!vk_funcs->p_vkGetInstanceProcAddr(instance->instance, UlongToPtr(params->name));
1979 }
1980
1981 NTSTATUS vk_is_available_device_function32(void *arg)
1982 {
1983     struct
1984     {
1985         UINT32 device;
1986         UINT32 name;
1987     } *params = arg;
1988     struct wine_device *device = wine_device_from_handle(UlongToPtr(params->device));
1989     return !!vk_funcs->p_vkGetDeviceProcAddr(device->device, UlongToPtr(params->name));
1990 }