dlls/winex11.drv/vulkan.c

   1 /* X11DRV Vulkan 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 /* NOTE: If making changes here, consider whether they should be reflected in
  21  * the other drivers. */
  22
  23 #if 0
  24 #pragma makedep unix
  25 #endif
  26
  27 #include "config.h"
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <dlfcn.h>
  32
  33 #include "ntstatus.h"
  34 #define WIN32_NO_STATUS
  35 #include "windef.h"
  36 #include "winbase.h"
  37
  38 #include "wine/debug.h"
  39 #include "x11drv.h"
  40
  41 #define VK_NO_PROTOTYPES
  42 #define WINE_VK_HOST
  43
  44 #include "wine/vulkan.h"
  45 #include "wine/vulkan_driver.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  48
  49 #ifdef SONAME_LIBVULKAN
  50
  51 static pthread_mutex_t vulkan_mutex;
  52
  53 #define VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR 1000004000
  54
  55 static struct list surface_list = LIST_INIT( surface_list );
  56
  57 struct wine_vk_surface
  58 {
  59     LONG ref;
  60     struct list entry;
  61     Window window;
  62     VkSurfaceKHR host_surface;
  63     HWND hwnd;
  64     DWORD hwnd_thread_id;
  65 };
  66
  67 typedef struct VkXlibSurfaceCreateInfoKHR
  68 {
  69     VkStructureType sType;
  70     const void *pNext;
  71     VkXlibSurfaceCreateFlagsKHR flags;
  72     Display *dpy;
  73     Window window;
  74 } VkXlibSurfaceCreateInfoKHR;
  75
  76 static VkResult (*pvkCreateXlibSurfaceKHR)(VkInstance, const VkXlibSurfaceCreateInfoKHR *, const VkAllocationCallbacks *, VkSurfaceKHR *);
  77 static void (*pvkDestroySurfaceKHR)(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks *);
  78 static VkBool32 (*pvkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice, uint32_t, Display *, VisualID);
  79
  80 static const struct vulkan_funcs vulkan_funcs;
  81
  82 static inline struct wine_vk_surface *surface_from_handle(VkSurfaceKHR handle)
  83 {
  84     return (struct wine_vk_surface *)(uintptr_t)handle;
  85 }
  86
  87 static void wine_vk_surface_release( struct wine_vk_surface *surface )
  88 {
  89     if (InterlockedDecrement(&surface->ref))
  90         return;
  91
  92     if (surface->entry.next)
  93     {
  94         pthread_mutex_lock(&vulkan_mutex);
  95         list_remove(&surface->entry);
  96         pthread_mutex_unlock(&vulkan_mutex);
  97     }
  98
  99     destroy_client_window( surface->hwnd, surface->window );
 100     free(surface);
 101 }
 102
 103 void destroy_vk_surface( HWND hwnd )
 104 {
 105     struct wine_vk_surface *surface, *next;
 106
 107     pthread_mutex_lock( &vulkan_mutex );
 108     LIST_FOR_EACH_ENTRY_SAFE( surface, next, &surface_list, struct wine_vk_surface, entry )
 109     {
 110         if (surface->hwnd != hwnd) continue;
 111         surface->hwnd_thread_id = 0;
 112         surface->hwnd = NULL;
 113     }
 114     pthread_mutex_unlock( &vulkan_mutex );
 115 }
 116
 117 void vulkan_thread_detach(void)
 118 {
 119     struct wine_vk_surface *surface, *next;
 120     DWORD thread_id = GetCurrentThreadId();
 121
 122     pthread_mutex_lock(&vulkan_mutex);
 123     LIST_FOR_EACH_ENTRY_SAFE(surface, next, &surface_list, struct wine_vk_surface, entry)
 124     {
 125         if (surface->hwnd_thread_id != thread_id)
 126             continue;
 127
 128         TRACE("Detaching surface %p, hwnd %p.\n", surface, surface->hwnd);
 129         XReparentWindow(gdi_display, surface->window, get_dummy_parent(), 0, 0);
 130         XSync(gdi_display, False);
 131     }
 132     pthread_mutex_unlock(&vulkan_mutex);
 133 }
 134
 135 static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance,
 136         const VkWin32SurfaceCreateInfoKHR *create_info,
 137         const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
 138 {
 139     VkResult res;
 140     VkXlibSurfaceCreateInfoKHR create_info_host;
 141     struct wine_vk_surface *x11_surface;
 142
 143     TRACE("%p %p %p %p\n", instance, create_info, allocator, surface);
 144
 145     if (allocator)
 146         FIXME("Support for allocation callbacks not implemented yet\n");
 147
 148     /* TODO: support child window rendering. */
 149     if (NtUserGetAncestor( create_info->hwnd, GA_PARENT ) != NtUserGetDesktopWindow())
 150     {
 151         FIXME("Application requires child window rendering, which is not implemented yet!\n");
 152         return VK_ERROR_INCOMPATIBLE_DRIVER;
 153     }
 154
 155     x11_surface = calloc(1, sizeof(*x11_surface));
 156     if (!x11_surface)
 157         return VK_ERROR_OUT_OF_HOST_MEMORY;
 158
 159     x11_surface->ref = 1;
 160     x11_surface->hwnd = create_info->hwnd;
 161     x11_surface->window = create_client_window( create_info->hwnd, &default_visual, default_colormap );
 162     x11_surface->hwnd_thread_id = NtUserGetWindowThread( x11_surface->hwnd, NULL );
 163
 164     if (!x11_surface->window)
 165     {
 166         ERR("Failed to allocate client window for hwnd=%p\n", create_info->hwnd);
 167
 168         /* VK_KHR_win32_surface only allows out of host and device memory as errors. */
 169         free(x11_surface);
 170         return VK_ERROR_OUT_OF_HOST_MEMORY;
 171     }
 172
 173     create_info_host.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
 174     create_info_host.pNext = NULL;
 175     create_info_host.flags = 0; /* reserved */
 176     create_info_host.dpy = gdi_display;
 177     create_info_host.window = x11_surface->window;
 178
 179     res = pvkCreateXlibSurfaceKHR( instance, &create_info_host, NULL /* allocator */, &x11_surface->host_surface );
 180     if (res != VK_SUCCESS)
 181     {
 182         ERR("Failed to create Xlib surface, res=%d\n", res);
 183         destroy_client_window( x11_surface->hwnd, x11_surface->window );
 184         free(x11_surface);
 185         return res;
 186     }
 187
 188     pthread_mutex_lock(&vulkan_mutex);
 189     list_add_tail(&surface_list, &x11_surface->entry);
 190     pthread_mutex_unlock(&vulkan_mutex);
 191
 192     *surface = (uintptr_t)x11_surface;
 193
 194     TRACE("Created surface=0x%s\n", wine_dbgstr_longlong(*surface));
 195     return VK_SUCCESS;
 196 }
 197
 198 static void X11DRV_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
 199         const VkAllocationCallbacks *allocator)
 200 {
 201     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 202
 203     TRACE("%p 0x%s %p\n", instance, wine_dbgstr_longlong(surface), allocator);
 204
 205     if (allocator)
 206         FIXME("Support for allocation callbacks not implemented yet\n");
 207
 208     pvkDestroySurfaceKHR( instance, x11_surface->host_surface, NULL /* allocator */ );
 209     wine_vk_surface_release(x11_surface);
 210 }
 211
 212 static VkBool32 X11DRV_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice phys_dev,
 213         uint32_t index)
 214 {
 215     TRACE("%p %u\n", phys_dev, index);
 216
 217     return pvkGetPhysicalDeviceXlibPresentationSupportKHR(phys_dev, index, gdi_display,
 218             default_visual.visual->visualid);
 219 }
 220
 221 static const char *X11DRV_get_host_surface_extension(void)
 222 {
 223     return "VK_KHR_xlib_surface";
 224 }
 225
 226 static VkSurfaceKHR X11DRV_wine_get_host_surface( VkSurfaceKHR surface )
 227 {
 228     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 229
 230     TRACE("0x%s\n", wine_dbgstr_longlong(surface));
 231
 232     return x11_surface->host_surface;
 233 }
 234
 235 static void X11DRV_vulkan_surface_presented(HWND hwnd, VkResult result)
 236 {
 237 }
 238
 239 static const struct vulkan_funcs vulkan_funcs =
 240 {
 241     X11DRV_vkCreateWin32SurfaceKHR,
 242     X11DRV_vkDestroySurfaceKHR,
 243     NULL,
 244     NULL,
 245     X11DRV_vkGetPhysicalDeviceWin32PresentationSupportKHR,
 246     NULL,
 247
 248     X11DRV_get_host_surface_extension,
 249     X11DRV_wine_get_host_surface,
 250     X11DRV_vulkan_surface_presented,
 251 };
 252
 253 UINT X11DRV_VulkanInit( UINT version, void *vulkan_handle, struct vulkan_funcs *driver_funcs )
 254 {
 255     if (version != WINE_VULKAN_DRIVER_VERSION)
 256     {
 257         ERR( "version mismatch, win32u wants %u but driver has %u\n", version, WINE_VULKAN_DRIVER_VERSION );
 258         return STATUS_INVALID_PARAMETER;
 259     }
 260
 261     init_recursive_mutex( &vulkan_mutex );
 262
 263 #define LOAD_FUNCPTR( f ) if (!(p##f = dlsym( vulkan_handle, #f ))) return STATUS_PROCEDURE_NOT_FOUND;
 264     LOAD_FUNCPTR( vkCreateXlibSurfaceKHR );
 265     LOAD_FUNCPTR( vkDestroySurfaceKHR );
 266     LOAD_FUNCPTR( vkGetPhysicalDeviceXlibPresentationSupportKHR );
 267 #undef LOAD_FUNCPTR
 268
 269     *driver_funcs = vulkan_funcs;
 270     return STATUS_SUCCESS;
 271 }
 272
 273 #else /* No vulkan */
 274
 275 UINT X11DRV_VulkanInit( UINT version, void *vulkan_handle, struct vulkan_funcs *driver_funcs )
 276 {
 277     ERR( "Wine was built without Vulkan support.\n" );
 278     return STATUS_NOT_IMPLEMENTED;
 279 }
 280
 281 void destroy_vk_surface( HWND hwnd )
 282 {
 283 }
 284
 285 void vulkan_thread_detach(void)
 286 {
 287 }
 288
 289 #endif /* SONAME_LIBVULKAN */