?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Update the PEB and TEB structures.
[wine.git] / dlls / winex11.drv / x11drv_main.c
blobaa39ecf2228086b63c150bc28244ab0aaaf57abf
1 /*
2 * X11DRV initialization code
3 *
4 * Copyright 1998 Patrik Stridvall
5 * Copyright 2000 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #if 0
23 #pragma makedep unix
24 #endif
25
26 #include "config.h"
27
28 #include <fcntl.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <sys/time.h>
34 #include <unistd.h>
35 #include <assert.h>
36 #include <dlfcn.h>
37 #include <X11/cursorfont.h>
38 #include <X11/Xlib.h>
39 #include <X11/XKBlib.h>
40 #ifdef HAVE_X11_EXTENSIONS_XRENDER_H
41 #include <X11/extensions/Xrender.h>
42 #endif
43
44 #include "ntstatus.h"
45 #define WIN32_NO_STATUS
46
47 #define VK_NO_PROTOTYPES
48 #define WINE_VK_HOST
49
50 #include "x11drv.h"
51 #include "winreg.h"
52 #include "xcomposite.h"
53 #include "wine/server.h"
54 #include "wine/debug.h"
55 #include "wine/list.h"
56 #include "wine/vulkan.h"
57 #include "wine/vulkan_driver.h"
58
59 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
60 WINE_DECLARE_DEBUG_CHANNEL(synchronous);
61 WINE_DECLARE_DEBUG_CHANNEL(winediag);
62
63 XVisualInfo default_visual = { 0 };
64 XVisualInfo argb_visual = { 0 };
65 Colormap default_colormap = None;
66 XPixmapFormatValues **pixmap_formats;
67 Atom systray_atom = 0;
68 unsigned int screen_bpp;
69 Window root_window;
70 BOOL usexvidmode = TRUE;
71 BOOL usexrandr = TRUE;
72 BOOL usexcomposite = TRUE;
73 BOOL use_take_focus = TRUE;
74 BOOL use_primary_selection = FALSE;
75 BOOL use_system_cursors = TRUE;
76 BOOL show_systray = TRUE;
77 BOOL grab_pointer = TRUE;
78 BOOL grab_fullscreen = FALSE;
79 BOOL managed_mode = TRUE;
80 BOOL decorated_mode = TRUE;
81 BOOL private_color_map = FALSE;
82 int primary_monitor = 0;
83 BOOL client_side_graphics = TRUE;
84 BOOL client_side_with_render = TRUE;
85 BOOL shape_layered_windows = TRUE;
86 int copy_default_colors = 128;
87 int alloc_system_colors = 256;
88 int xrender_error_base = 0;
89 char *process_name = NULL;
90 WNDPROC client_foreign_window_proc = NULL;
91
92 static x11drv_error_callback err_callback; /* current callback for error */
93 static Display *err_callback_display; /* display callback is set for */
94 static void *err_callback_arg; /* error callback argument */
95 static int err_callback_result; /* error callback result */
96 static unsigned long err_serial; /* serial number of first request */
97 static int (*old_error_handler)( Display *, XErrorEvent * );
98 static BOOL use_xim = TRUE;
99 static WCHAR input_style[20];
100
101 static pthread_mutex_t d3dkmt_mutex = PTHREAD_MUTEX_INITIALIZER;
102 static pthread_mutex_t error_mutex = PTHREAD_MUTEX_INITIALIZER;
103
104 struct x11_d3dkmt_adapter
105 {
106 D3DKMT_HANDLE handle; /* Kernel mode graphics adapter handle */
107 VkPhysicalDevice vk_device; /* Vulkan physical device */
108 struct list entry; /* List entry */
109 };
110
111 struct d3dkmt_vidpn_source
112 {
113 D3DKMT_VIDPNSOURCEOWNER_TYPE type; /* VidPN source owner type */
114 D3DDDI_VIDEO_PRESENT_SOURCE_ID id; /* VidPN present source id */
115 D3DKMT_HANDLE device; /* Kernel mode device context */
116 struct list entry; /* List entry */
117 };
118
119 static VkInstance d3dkmt_vk_instance; /* Vulkan instance for D3DKMT functions */
120 static struct list x11_d3dkmt_adapters = LIST_INIT( x11_d3dkmt_adapters );
121 static struct list d3dkmt_vidpn_sources = LIST_INIT( d3dkmt_vidpn_sources ); /* VidPN source information list */
122
123 #define IS_OPTION_TRUE(ch) \
124 ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
125 #define IS_OPTION_FALSE(ch) \
126 ((ch) == 'n' || (ch) == 'N' || (ch) == 'f' || (ch) == 'F' || (ch) == '0')
127
128 Atom X11DRV_Atoms[NB_XATOMS - FIRST_XATOM];
129
130 static const char * const atom_names[NB_XATOMS - FIRST_XATOM] =
131 {
132 "CLIPBOARD",
133 "COMPOUND_TEXT",
134 "EDID",
135 "INCR",
136 "MANAGER",
137 "MULTIPLE",
138 "SELECTION_DATA",
139 "TARGETS",
140 "TEXT",
141 "TIMESTAMP",
142 "UTF8_STRING",
143 "RAW_ASCENT",
144 "RAW_DESCENT",
145 "RAW_CAP_HEIGHT",
146 "Rel X",
147 "Rel Y",
148 "WM_PROTOCOLS",
149 "WM_DELETE_WINDOW",
150 "WM_STATE",
151 "WM_TAKE_FOCUS",
152 "DndProtocol",
153 "DndSelection",
154 "_ICC_PROFILE",
155 "_KDE_NET_WM_STATE_SKIP_SWITCHER",
156 "_MOTIF_WM_HINTS",
157 "_NET_STARTUP_INFO_BEGIN",
158 "_NET_STARTUP_INFO",
159 "_NET_SUPPORTED",
160 "_NET_SYSTEM_TRAY_OPCODE",
161 "_NET_SYSTEM_TRAY_S0",
162 "_NET_SYSTEM_TRAY_VISUAL",
163 "_NET_WM_FULLSCREEN_MONITORS",
164 "_NET_WM_ICON",
165 "_NET_WM_MOVERESIZE",
166 "_NET_WM_NAME",
167 "_NET_WM_PID",
168 "_NET_WM_PING",
169 "_NET_WM_STATE",
170 "_NET_WM_STATE_ABOVE",
171 "_NET_WM_STATE_DEMANDS_ATTENTION",
172 "_NET_WM_STATE_FULLSCREEN",
173 "_NET_WM_STATE_MAXIMIZED_HORZ",
174 "_NET_WM_STATE_MAXIMIZED_VERT",
175 "_NET_WM_STATE_SKIP_PAGER",
176 "_NET_WM_STATE_SKIP_TASKBAR",
177 "_NET_WM_USER_TIME",
178 "_NET_WM_USER_TIME_WINDOW",
179 "_NET_WM_WINDOW_OPACITY",
180 "_NET_WM_WINDOW_TYPE",
181 "_NET_WM_WINDOW_TYPE_DIALOG",
182 "_NET_WM_WINDOW_TYPE_NORMAL",
183 "_NET_WM_WINDOW_TYPE_UTILITY",
184 "_NET_WORKAREA",
185 "_GTK_WORKAREAS_D0",
186 "_XEMBED",
187 "_XEMBED_INFO",
188 "XdndAware",
189 "XdndEnter",
190 "XdndPosition",
191 "XdndStatus",
192 "XdndLeave",
193 "XdndFinished",
194 "XdndDrop",
195 "XdndActionCopy",
196 "XdndActionMove",
197 "XdndActionLink",
198 "XdndActionAsk",
199 "XdndActionPrivate",
200 "XdndSelection",
201 "XdndTypeList",
202 "HTML Format",
203 "WCF_DIF",
204 "WCF_ENHMETAFILE",
205 "WCF_HDROP",
206 "WCF_PENDATA",
207 "WCF_RIFF",
208 "WCF_SYLK",
209 "WCF_TIFF",
210 "WCF_WAVE",
211 "image/bmp",
212 "image/gif",
213 "image/jpeg",
214 "image/png",
215 "text/html",
216 "text/plain",
217 "text/rtf",
218 "text/richtext",
219 "text/uri-list"
220 };
221
222 /***********************************************************************
223 * ignore_error
224 *
225 * Check if the X error is one we can ignore.
226 */
227 static inline BOOL ignore_error( Display *display, XErrorEvent *event )
228 {
229 if ((event->request_code == X_SetInputFocus ||
230 event->request_code == X_ChangeWindowAttributes ||
231 event->request_code == X_SendEvent) &&
232 (event->error_code == BadMatch ||
233 event->error_code == BadWindow)) return TRUE;
234
235 /* the clipboard display interacts with external windows, ignore all errors */
236 if (display == clipboard_display) return TRUE;
237
238 /* ignore a number of errors on gdi display caused by creating/destroying windows */
239 if (display == gdi_display)
240 {
241 if (event->error_code == BadDrawable ||
242 event->error_code == BadGC ||
243 event->error_code == BadWindow)
244 return TRUE;
245 #ifdef HAVE_X11_EXTENSIONS_XRENDER_H
246 if (xrender_error_base) /* check for XRender errors */
247 {
248 if (event->error_code == xrender_error_base + BadPicture) return TRUE;
249 }
250 #endif
251 }
252 return FALSE;
253 }
254
255
256 /***********************************************************************
257 * X11DRV_expect_error
258 *
259 * Setup a callback function that will be called on an X error. The
260 * callback must return non-zero if the error is the one it expected.
261 */
262 void X11DRV_expect_error( Display *display, x11drv_error_callback callback, void *arg )
263 {
264 pthread_mutex_lock( &error_mutex );
265 XLockDisplay( display );
266 err_callback = callback;
267 err_callback_display = display;
268 err_callback_arg = arg;
269 err_callback_result = 0;
270 err_serial = NextRequest(display);
271 }
272
273
274 /***********************************************************************
275 * X11DRV_check_error
276 *
277 * Check if an expected X11 error occurred; return non-zero if yes.
278 * The caller is responsible for calling XSync first if necessary.
279 */
280 int X11DRV_check_error(void)
281 {
282 int res = err_callback_result;
283 err_callback = NULL;
284 XUnlockDisplay( err_callback_display );
285 pthread_mutex_unlock( &error_mutex );
286 return res;
287 }
288
289
290 /***********************************************************************
291 * error_handler
292 */
293 static int error_handler( Display *display, XErrorEvent *error_evt )
294 {
295 if (err_callback && display == err_callback_display &&
296 (!error_evt->serial || error_evt->serial >= err_serial))
297 {
298 if ((err_callback_result = err_callback( display, error_evt, err_callback_arg )))
299 {
300 TRACE( "got expected error %d req %d\n",
301 error_evt->error_code, error_evt->request_code );
302 return 0;
303 }
304 }
305 if (ignore_error( display, error_evt ))
306 {
307 TRACE( "got ignored error %d req %d\n",
308 error_evt->error_code, error_evt->request_code );
309 return 0;
310 }
311 if (TRACE_ON(synchronous))
312 {
313 ERR( "X protocol error: serial=%ld, request_code=%d - breaking into debugger\n",
314 error_evt->serial, error_evt->request_code );
315 assert( 0 );
316 }
317 old_error_handler( display, error_evt );
318 return 0;
319 }
320
321 /***********************************************************************
322 * init_pixmap_formats
323 */
324 static void init_pixmap_formats( Display *display )
325 {
326 int i, count, max = 32;
327 XPixmapFormatValues *formats = XListPixmapFormats( display, &count );
328
329 for (i = 0; i < count; i++)
330 {
331 TRACE( "depth %u, bpp %u, pad %u\n",
332 formats[i].depth, formats[i].bits_per_pixel, formats[i].scanline_pad );
333 if (formats[i].depth > max) max = formats[i].depth;
334 }
335 pixmap_formats = calloc( 1, sizeof(*pixmap_formats) * (max + 1) );
336 for (i = 0; i < count; i++) pixmap_formats[formats[i].depth] = &formats[i];
337 }
338
339
340 HKEY reg_open_key( HKEY root, const WCHAR *name, ULONG name_len )
341 {
342 UNICODE_STRING nameW = { name_len, name_len, (WCHAR *)name };
343 OBJECT_ATTRIBUTES attr;
344 HANDLE ret;
345
346 attr.Length = sizeof(attr);
347 attr.RootDirectory = root;
348 attr.ObjectName = &nameW;
349 attr.Attributes = 0;
350 attr.SecurityDescriptor = NULL;
351 attr.SecurityQualityOfService = NULL;
352
353 return NtOpenKeyEx( &ret, MAXIMUM_ALLOWED, &attr, 0 ) ? 0 : ret;
354 }
355
356
357 HKEY open_hkcu_key( const char *name )
358 {
359 WCHAR bufferW[256];
360 static HKEY hkcu;
361
362 if (!hkcu)
363 {
364 char buffer[256];
365 DWORD_PTR sid_data[(sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE) / sizeof(DWORD_PTR)];
366 DWORD i, len = sizeof(sid_data);
367 SID *sid;
368
369 if (NtQueryInformationToken( GetCurrentThreadEffectiveToken(), TokenUser, sid_data, len, &len ))
370 return 0;
371
372 sid = ((TOKEN_USER *)sid_data)->User.Sid;
373 len = sprintf( buffer, "\\Registry\\User\\S-%u-%u", sid->Revision,
374 (int)MAKELONG( MAKEWORD( sid->IdentifierAuthority.Value[5],
375 sid->IdentifierAuthority.Value[4] ),
376 MAKEWORD( sid->IdentifierAuthority.Value[3],
377 sid->IdentifierAuthority.Value[2] )));
378 for (i = 0; i < sid->SubAuthorityCount; i++)
379 len += sprintf( buffer + len, "-%u", (int)sid->SubAuthority[i] );
380
381 ascii_to_unicode( bufferW, buffer, len );
382 hkcu = reg_open_key( NULL, bufferW, len * sizeof(WCHAR) );
383 }
384
385 return reg_open_key( hkcu, bufferW, asciiz_to_unicode( bufferW, name ) - sizeof(WCHAR) );
386 }
387
388
389 ULONG query_reg_value( HKEY hkey, const WCHAR *name, KEY_VALUE_PARTIAL_INFORMATION *info, ULONG size )
390 {
391 unsigned int name_size = name ? lstrlenW( name ) * sizeof(WCHAR) : 0;
392 UNICODE_STRING nameW = { name_size, name_size, (WCHAR *)name };
393
394 if (NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
395 info, size, &size ))
396 return 0;
397
398 return size - FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
399 }
400
401
402 /***********************************************************************
403 * get_config_key
404 *
405 * Get a config key from either the app-specific or the default config
406 */
407 static inline DWORD get_config_key( HKEY defkey, HKEY appkey, const char *name,
408 WCHAR *buffer, DWORD size )
409 {
410 WCHAR nameW[128];
411 char buf[2048];
412 KEY_VALUE_PARTIAL_INFORMATION *info = (void *)buf;
413
414 asciiz_to_unicode( nameW, name );
415
416 if (appkey && query_reg_value( appkey, nameW, info, sizeof(buf) ))
417 {
418 size = min( info->DataLength, size - sizeof(WCHAR) );
419 memcpy( buffer, info->Data, size );
420 buffer[size / sizeof(WCHAR)] = 0;
421 return 0;
422 }
423
424 if (defkey && query_reg_value( defkey, nameW, info, sizeof(buf) ))
425 {
426 size = min( info->DataLength, size - sizeof(WCHAR) );
427 memcpy( buffer, info->Data, size );
428 buffer[size / sizeof(WCHAR)] = 0;
429 return 0;
430 }
431
432 return ERROR_FILE_NOT_FOUND;
433 }
434
435
436 /***********************************************************************
437 * setup_options
438 *
439 * Setup the x11drv options.
440 */
441 static void setup_options(void)
442 {
443 static const WCHAR x11driverW[] = {'\\','X','1','1',' ','D','r','i','v','e','r',0};
444 WCHAR buffer[MAX_PATH+16], *p, *appname;
445 HKEY hkey, appkey = 0;
446 DWORD len;
447
448 /* @@ Wine registry key: HKCU\Software\Wine\X11 Driver */
449 hkey = open_hkcu_key( "Software\\Wine\\X11 Driver" );
450
451 /* open the app-specific key */
452
453 appname = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
454 if ((p = wcsrchr( appname, '/' ))) appname = p + 1;
455 if ((p = wcsrchr( appname, '\\' ))) appname = p + 1;
456 len = lstrlenW( appname );
457
458 if (len && len < MAX_PATH)
459 {
460 HKEY tmpkey;
461 int i;
462 for (i = 0; appname[i]; i++) buffer[i] = RtlDowncaseUnicodeChar( appname[i] );
463 buffer[i] = 0;
464 appname = buffer;
465 if ((process_name = malloc( len * 3 + 1 )))
466 ntdll_wcstoumbs( appname, len + 1, process_name, len * 3 + 1, FALSE );
467 memcpy( appname + i, x11driverW, sizeof(x11driverW) );
468 /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\X11 Driver */
469 if ((tmpkey = open_hkcu_key( "Software\\Wine\\AppDefaults" )))
470 {
471 appkey = reg_open_key( tmpkey, appname, lstrlenW( appname ) * sizeof(WCHAR) );
472 NtClose( tmpkey );
473 }
474 }
475
476 if (!get_config_key( hkey, appkey, "Managed", buffer, sizeof(buffer) ))
477 managed_mode = IS_OPTION_TRUE( buffer[0] );
478
479 if (!get_config_key( hkey, appkey, "Decorated", buffer, sizeof(buffer) ))
480 decorated_mode = IS_OPTION_TRUE( buffer[0] );
481
482 if (!get_config_key( hkey, appkey, "UseXVidMode", buffer, sizeof(buffer) ))
483 usexvidmode = IS_OPTION_TRUE( buffer[0] );
484
485 if (!get_config_key( hkey, appkey, "UseXRandR", buffer, sizeof(buffer) ))
486 usexrandr = IS_OPTION_TRUE( buffer[0] );
487
488 if (!get_config_key( hkey, appkey, "UseTakeFocus", buffer, sizeof(buffer) ))
489 use_take_focus = IS_OPTION_TRUE( buffer[0] );
490
491 if (!get_config_key( hkey, appkey, "UsePrimarySelection", buffer, sizeof(buffer) ))
492 use_primary_selection = IS_OPTION_TRUE( buffer[0] );
493
494 if (!get_config_key( hkey, appkey, "UseSystemCursors", buffer, sizeof(buffer) ))
495 use_system_cursors = IS_OPTION_TRUE( buffer[0] );
496
497 if (!get_config_key( hkey, appkey, "ShowSystray", buffer, sizeof(buffer) ))
498 show_systray = IS_OPTION_TRUE( buffer[0] );
499
500 if (!get_config_key( hkey, appkey, "GrabPointer", buffer, sizeof(buffer) ))
501 grab_pointer = IS_OPTION_TRUE( buffer[0] );
502
503 if (!get_config_key( hkey, appkey, "GrabFullscreen", buffer, sizeof(buffer) ))
504 grab_fullscreen = IS_OPTION_TRUE( buffer[0] );
505
506 if (!get_config_key( hkey, appkey, "ScreenDepth", buffer, sizeof(buffer) ))
507 default_visual.depth = wcstol( buffer, NULL, 0 );
508
509 if (!get_config_key( hkey, appkey, "ClientSideGraphics", buffer, sizeof(buffer) ))
510 client_side_graphics = IS_OPTION_TRUE( buffer[0] );
511
512 if (!get_config_key( hkey, appkey, "ClientSideWithRender", buffer, sizeof(buffer) ))
513 client_side_with_render = IS_OPTION_TRUE( buffer[0] );
514
515 if (!get_config_key( hkey, appkey, "UseXIM", buffer, sizeof(buffer) ))
516 use_xim = IS_OPTION_TRUE( buffer[0] );
517
518 if (!get_config_key( hkey, appkey, "ShapeLayeredWindows", buffer, sizeof(buffer) ))
519 shape_layered_windows = IS_OPTION_TRUE( buffer[0] );
520
521 if (!get_config_key( hkey, appkey, "PrivateColorMap", buffer, sizeof(buffer) ))
522 private_color_map = IS_OPTION_TRUE( buffer[0] );
523
524 if (!get_config_key( hkey, appkey, "PrimaryMonitor", buffer, sizeof(buffer) ))
525 primary_monitor = wcstol( buffer, NULL, 0 );
526
527 if (!get_config_key( hkey, appkey, "CopyDefaultColors", buffer, sizeof(buffer) ))
528 copy_default_colors = wcstol( buffer, NULL, 0 );
529
530 if (!get_config_key( hkey, appkey, "AllocSystemColors", buffer, sizeof(buffer) ))
531 alloc_system_colors = wcstol( buffer, NULL, 0 );
532
533 get_config_key( hkey, appkey, "InputStyle", input_style, sizeof(input_style) );
534
535 NtClose( appkey );
536 NtClose( hkey );
537 }
538
539 #ifdef SONAME_LIBXCOMPOSITE
540
541 #define MAKE_FUNCPTR(f) typeof(f) * p##f;
542 MAKE_FUNCPTR(XCompositeQueryExtension)
543 MAKE_FUNCPTR(XCompositeQueryVersion)
544 MAKE_FUNCPTR(XCompositeVersion)
545 MAKE_FUNCPTR(XCompositeRedirectWindow)
546 MAKE_FUNCPTR(XCompositeRedirectSubwindows)
547 MAKE_FUNCPTR(XCompositeUnredirectWindow)
548 MAKE_FUNCPTR(XCompositeUnredirectSubwindows)
549 MAKE_FUNCPTR(XCompositeCreateRegionFromBorderClip)
550 MAKE_FUNCPTR(XCompositeNameWindowPixmap)
551 #undef MAKE_FUNCPTR
552
553 static int xcomp_event_base;
554 static int xcomp_error_base;
555
556 static void X11DRV_XComposite_Init(void)
557 {
558 void *xcomposite_handle = dlopen(SONAME_LIBXCOMPOSITE, RTLD_NOW);
559 if (!xcomposite_handle)
560 {
561 TRACE("Unable to open %s, XComposite disabled\n", SONAME_LIBXCOMPOSITE);
562 usexcomposite = FALSE;
563 return;
564 }
565
566 #define LOAD_FUNCPTR(f) \
567 if((p##f = dlsym(xcomposite_handle, #f)) == NULL) goto sym_not_found
568 LOAD_FUNCPTR(XCompositeQueryExtension);
569 LOAD_FUNCPTR(XCompositeQueryVersion);
570 LOAD_FUNCPTR(XCompositeVersion);
571 LOAD_FUNCPTR(XCompositeRedirectWindow);
572 LOAD_FUNCPTR(XCompositeRedirectSubwindows);
573 LOAD_FUNCPTR(XCompositeUnredirectWindow);
574 LOAD_FUNCPTR(XCompositeUnredirectSubwindows);
575 LOAD_FUNCPTR(XCompositeCreateRegionFromBorderClip);
576 LOAD_FUNCPTR(XCompositeNameWindowPixmap);
577 #undef LOAD_FUNCPTR
578
579 if(!pXCompositeQueryExtension(gdi_display, &xcomp_event_base,
580 &xcomp_error_base)) {
581 TRACE("XComposite extension could not be queried; disabled\n");
582 dlclose(xcomposite_handle);
583 xcomposite_handle = NULL;
584 usexcomposite = FALSE;
585 return;
586 }
587 TRACE("XComposite is up and running error_base = %d\n", xcomp_error_base);
588 return;
589
590 sym_not_found:
591 TRACE("Unable to load function pointers from %s, XComposite disabled\n", SONAME_LIBXCOMPOSITE);
592 dlclose(xcomposite_handle);
593 xcomposite_handle = NULL;
594 usexcomposite = FALSE;
595 }
596 #endif /* defined(SONAME_LIBXCOMPOSITE) */
597
598 static void init_visuals( Display *display, int screen )
599 {
600 int count;
601 XVisualInfo *info;
602
603 argb_visual.screen = screen;
604 argb_visual.class = TrueColor;
605 argb_visual.depth = 32;
606 argb_visual.red_mask = 0xff0000;
607 argb_visual.green_mask = 0x00ff00;
608 argb_visual.blue_mask = 0x0000ff;
609
610 if ((info = XGetVisualInfo( display, VisualScreenMask | VisualDepthMask | VisualClassMask |
611 VisualRedMaskMask | VisualGreenMaskMask | VisualBlueMaskMask,
612 &argb_visual, &count )))
613 {
614 argb_visual = *info;
615 XFree( info );
616 }
617
618 default_visual.screen = screen;
619 if (default_visual.depth) /* depth specified */
620 {
621 if (default_visual.depth == 32 && argb_visual.visual)
622 {
623 default_visual = argb_visual;
624 }
625 else if ((info = XGetVisualInfo( display, VisualScreenMask | VisualDepthMask, &default_visual, &count )))
626 {
627 default_visual = *info;
628 XFree( info );
629 }
630 else WARN( "no visual found for depth %d\n", default_visual.depth );
631 }
632
633 if (!default_visual.visual)
634 {
635 default_visual.depth = DefaultDepth( display, screen );
636 default_visual.visual = DefaultVisual( display, screen );
637 default_visual.visualid = default_visual.visual->visualid;
638 default_visual.class = default_visual.visual->class;
639 default_visual.red_mask = default_visual.visual->red_mask;
640 default_visual.green_mask = default_visual.visual->green_mask;
641 default_visual.blue_mask = default_visual.visual->blue_mask;
642 default_visual.colormap_size = default_visual.visual->map_entries;
643 default_visual.bits_per_rgb = default_visual.visual->bits_per_rgb;
644 }
645 default_colormap = XCreateColormap( display, root_window, default_visual.visual, AllocNone );
646
647 TRACE( "default visual %lx class %u argb %lx\n",
648 default_visual.visualid, default_visual.class, argb_visual.visualid );
649 }
650
651 /***********************************************************************
652 * X11DRV process initialisation routine
653 */
654 static NTSTATUS x11drv_init( void *arg )
655 {
656 struct init_params *params = arg;
657 Display *display;
658 void *libx11 = dlopen( SONAME_LIBX11, RTLD_NOW|RTLD_GLOBAL );
659
660 if (!libx11)
661 {
662 ERR( "failed to load %s: %s\n", SONAME_LIBX11, dlerror() );
663 return STATUS_UNSUCCESSFUL;
664 }
665 pXGetEventData = dlsym( libx11, "XGetEventData" );
666 pXFreeEventData = dlsym( libx11, "XFreeEventData" );
667 #ifdef SONAME_LIBXEXT
668 dlopen( SONAME_LIBXEXT, RTLD_NOW|RTLD_GLOBAL );
669 #endif
670
671 setup_options();
672
673 /* Open display */
674
675 if (!XInitThreads()) ERR( "XInitThreads failed, trouble ahead\n" );
676 if (!(display = XOpenDisplay( NULL ))) return STATUS_UNSUCCESSFUL;
677
678 client_foreign_window_proc = params->foreign_window_proc;
679
680 fcntl( ConnectionNumber(display), F_SETFD, 1 ); /* set close on exec flag */
681 root_window = DefaultRootWindow( display );
682 gdi_display = display;
683 old_error_handler = XSetErrorHandler( error_handler );
684
685 init_pixmap_formats( display );
686 init_visuals( display, DefaultScreen( display ));
687 screen_bpp = pixmap_formats[default_visual.depth]->bits_per_pixel;
688
689 XInternAtoms( display, (char **)atom_names, NB_XATOMS - FIRST_XATOM, False, X11DRV_Atoms );
690
691 init_win_context();
692
693 if (TRACE_ON(synchronous)) XSynchronize( display, True );
694
695 xinerama_init( DisplayWidth( display, default_visual.screen ),
696 DisplayHeight( display, default_visual.screen ));
697 X11DRV_Settings_Init();
698
699 /* initialize XVidMode */
700 X11DRV_XF86VM_Init();
701 /* initialize XRandR */
702 X11DRV_XRandR_Init();
703 #ifdef SONAME_LIBXCOMPOSITE
704 X11DRV_XComposite_Init();
705 #endif
706 X11DRV_XInput2_Init();
707
708 XkbUseExtension( gdi_display, NULL, NULL );
709 X11DRV_InitKeyboard( gdi_display );
710 if (use_xim) use_xim = xim_init( input_style );
711
712 init_user_driver();
713 X11DRV_DisplayDevices_Init(FALSE);
714 *params->show_systray = show_systray;
715 return STATUS_SUCCESS;
716 }
717
718
719 /***********************************************************************
720 * ThreadDetach (X11DRV.@)
721 */
722 void X11DRV_ThreadDetach(void)
723 {
724 struct x11drv_thread_data *data = x11drv_thread_data();
725
726 if (data)
727 {
728 vulkan_thread_detach();
729 if (data->xim) XCloseIM( data->xim );
730 if (data->font_set) XFreeFontSet( data->display, data->font_set );
731 XCloseDisplay( data->display );
732 free( data );
733 /* clear data in case we get re-entered from user32 before the thread is truly dead */
734 NtUserGetThreadInfo()->driver_data = 0;
735 }
736 }
737
738
739 /* store the display fd into the message queue */
740 static void set_queue_display_fd( Display *display )
741 {
742 HANDLE handle;
743 int ret;
744
745 if (wine_server_fd_to_handle( ConnectionNumber(display), GENERIC_READ | SYNCHRONIZE, 0, &handle ))
746 {
747 MESSAGE( "x11drv: Can't allocate handle for display fd\n" );
748 NtTerminateProcess( 0, 1 );
749 }
750 SERVER_START_REQ( set_queue_fd )
751 {
752 req->handle = wine_server_obj_handle( handle );
753 ret = wine_server_call( req );
754 }
755 SERVER_END_REQ;
756 if (ret)
757 {
758 MESSAGE( "x11drv: Can't store handle for display fd\n" );
759 NtTerminateProcess( 0, 1 );
760 }
761 NtClose( handle );
762 }
763
764
765 /***********************************************************************
766 * X11DRV thread initialisation routine
767 */
768 struct x11drv_thread_data *x11drv_init_thread_data(void)
769 {
770 struct x11drv_thread_data *data = x11drv_thread_data();
771
772 if (data) return data;
773
774 if (!(data = calloc( 1, sizeof(*data) )))
775 {
776 ERR( "could not create data\n" );
777 NtTerminateProcess( 0, 1 );
778 }
779 if (!(data->display = XOpenDisplay(NULL)))
780 {
781 ERR_(winediag)( "x11drv: Can't open display: %s. Please ensure that your X server is running and that $DISPLAY is set correctly.\n", XDisplayName(NULL));
782 NtTerminateProcess( 0, 1 );
783 }
784
785 fcntl( ConnectionNumber(data->display), F_SETFD, 1 ); /* set close on exec flag */
786
787 XkbUseExtension( data->display, NULL, NULL );
788 XkbSetDetectableAutoRepeat( data->display, True, NULL );
789 if (TRACE_ON(synchronous)) XSynchronize( data->display, True );
790
791 set_queue_display_fd( data->display );
792 NtUserGetThreadInfo()->driver_data = (UINT_PTR)data;
793
794 if (use_xim) xim_thread_attach( data );
795
796 return data;
797 }
798
799
800 /***********************************************************************
801 * SystemParametersInfo (X11DRV.@)
802 */
803 BOOL X11DRV_SystemParametersInfo( UINT action, UINT int_param, void *ptr_param, UINT flags )
804 {
805 switch (action)
806 {
807 case SPI_GETSCREENSAVEACTIVE:
808 if (ptr_param)
809 {
810 int timeout, temp;
811 XGetScreenSaver(gdi_display, &timeout, &temp, &temp, &temp);
812 *(BOOL *)ptr_param = timeout != 0;
813 return TRUE;
814 }
815 break;
816 case SPI_SETSCREENSAVEACTIVE:
817 {
818 int timeout, interval, prefer_blanking, allow_exposures;
819 static int last_timeout = 15 * 60;
820
821 XLockDisplay( gdi_display );
822 XGetScreenSaver(gdi_display, &timeout, &interval, &prefer_blanking,
823 &allow_exposures);
824 if (timeout) last_timeout = timeout;
825
826 timeout = int_param ? last_timeout : 0;
827 XSetScreenSaver(gdi_display, timeout, interval, prefer_blanking,
828 allow_exposures);
829 XUnlockDisplay( gdi_display );
830 }
831 break;
832 }
833 return FALSE; /* let user32 handle it */
834 }
835
836 NTSTATUS CDECL X11DRV_D3DKMTCloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
837 {
838 const struct vulkan_funcs *vulkan_funcs = get_vulkan_driver(WINE_VULKAN_DRIVER_VERSION);
839 struct x11_d3dkmt_adapter *adapter;
840
841 if (!vulkan_funcs)
842 return STATUS_UNSUCCESSFUL;
843
844 pthread_mutex_lock(&d3dkmt_mutex);
845 LIST_FOR_EACH_ENTRY(adapter, &x11_d3dkmt_adapters, struct x11_d3dkmt_adapter, entry)
846 {
847 if (adapter->handle == desc->hAdapter)
848 {
849 list_remove(&adapter->entry);
850 free(adapter);
851 break;
852 }
853 }
854
855 if (list_empty(&x11_d3dkmt_adapters))
856 {
857 vulkan_funcs->p_vkDestroyInstance(d3dkmt_vk_instance, NULL);
858 d3dkmt_vk_instance = NULL;
859 }
860 pthread_mutex_unlock(&d3dkmt_mutex);
861 return STATUS_SUCCESS;
862 }
863
864 /**********************************************************************
865 * X11DRV_D3DKMTSetVidPnSourceOwner
866 */
867 NTSTATUS CDECL X11DRV_D3DKMTSetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER *desc )
868 {
869 struct d3dkmt_vidpn_source *source, *source2;
870 NTSTATUS status = STATUS_SUCCESS;
871 BOOL found;
872 UINT i;
873
874 TRACE("(%p)\n", desc);
875
876 pthread_mutex_lock( &d3dkmt_mutex );
877
878 /* Check parameters */
879 for (i = 0; i < desc->VidPnSourceCount; ++i)
880 {
881 LIST_FOR_EACH_ENTRY( source, &d3dkmt_vidpn_sources, struct d3dkmt_vidpn_source, entry )
882 {
883 if (source->id == desc->pVidPnSourceId[i])
884 {
885 /* Same device */
886 if (source->device == desc->hDevice)
887 {
888 if ((source->type == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE
889 && (desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_SHARED
890 || desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EMULATED))
891 || (source->type == D3DKMT_VIDPNSOURCEOWNER_EMULATED
892 && desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE))
893 {
894 status = STATUS_INVALID_PARAMETER;
895 goto done;
896 }
897 }
898 /* Different devices */
899 else
900 {
901 if ((source->type == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE
902 || source->type == D3DKMT_VIDPNSOURCEOWNER_EMULATED)
903 && (desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE
904 || desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EMULATED))
905 {
906 status = STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE;
907 goto done;
908 }
909 }
910 }
911 }
912
913 /* On Windows, it seems that all video present sources are owned by DMM clients, so any attempt to set
914 * D3DKMT_VIDPNSOURCEOWNER_SHARED come back STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE */
915 if (desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_SHARED)
916 {
917 status = STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE;
918 goto done;
919 }
920
921 /* FIXME: D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVEGDI unsupported */
922 if (desc->pType[i] == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVEGDI || desc->pType[i] > D3DKMT_VIDPNSOURCEOWNER_EMULATED)
923 {
924 status = STATUS_INVALID_PARAMETER;
925 goto done;
926 }
927 }
928
929 /* Remove owner */
930 if (!desc->VidPnSourceCount && !desc->pType && !desc->pVidPnSourceId)
931 {
932 LIST_FOR_EACH_ENTRY_SAFE( source, source2, &d3dkmt_vidpn_sources, struct d3dkmt_vidpn_source, entry )
933 {
934 if (source->device == desc->hDevice)
935 {
936 list_remove( &source->entry );
937 free( source );
938 }
939 }
940 goto done;
941 }
942
943 /* Add owner */
944 for (i = 0; i < desc->VidPnSourceCount; ++i)
945 {
946 found = FALSE;
947 LIST_FOR_EACH_ENTRY( source, &d3dkmt_vidpn_sources, struct d3dkmt_vidpn_source, entry )
948 {
949 if (source->device == desc->hDevice && source->id == desc->pVidPnSourceId[i])
950 {
951 found = TRUE;
952 break;
953 }
954 }
955
956 if (found)
957 source->type = desc->pType[i];
958 else
959 {
960 source = malloc( sizeof( *source ) );
961 if (!source)
962 {
963 status = STATUS_NO_MEMORY;
964 goto done;
965 }
966
967 source->id = desc->pVidPnSourceId[i];
968 source->type = desc->pType[i];
969 source->device = desc->hDevice;
970 list_add_tail( &d3dkmt_vidpn_sources, &source->entry );
971 }
972 }
973
974 done:
975 pthread_mutex_unlock( &d3dkmt_mutex );
976 return status;
977 }
978
979 /**********************************************************************
980 * X11DRV_D3DKMTCheckVidPnExclusiveOwnership
981 */
982 NTSTATUS CDECL X11DRV_D3DKMTCheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc )
983 {
984 struct d3dkmt_vidpn_source *source;
985
986 TRACE("(%p)\n", desc);
987
988 if (!desc || !desc->hAdapter)
989 return STATUS_INVALID_PARAMETER;
990
991 pthread_mutex_lock( &d3dkmt_mutex );
992 LIST_FOR_EACH_ENTRY( source, &d3dkmt_vidpn_sources, struct d3dkmt_vidpn_source, entry )
993 {
994 if (source->id == desc->VidPnSourceId && source->type == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE)
995 {
996 pthread_mutex_unlock( &d3dkmt_mutex );
997 return STATUS_GRAPHICS_PRESENT_OCCLUDED;
998 }
999 }
1000 pthread_mutex_unlock( &d3dkmt_mutex );
1001 return STATUS_SUCCESS;
1002 }
1003
1004 static HANDLE get_display_device_init_mutex(void)
1005 {
1006 WCHAR bufferW[256];
1007 UNICODE_STRING name = {.Buffer = bufferW};
1008 OBJECT_ATTRIBUTES attr;
1009 char buffer[256];
1010 HANDLE mutex;
1011
1012 snprintf( buffer, ARRAY_SIZE(buffer), "\\Sessions\\%u\\BaseNamedObjects\\display_device_init",
1013 (int)NtCurrentTeb()->Peb->SessionId );
1014 name.Length = name.MaximumLength = asciiz_to_unicode( bufferW, buffer );
1015
1016 InitializeObjectAttributes( &attr, &name, OBJ_OPENIF, NULL, NULL );
1017 if (NtCreateMutant( &mutex, MUTEX_ALL_ACCESS, &attr, FALSE ) < 0) return 0;
1018 NtWaitForSingleObject( mutex, FALSE, NULL );
1019 return mutex;
1020 }
1021
1022 static void release_display_device_init_mutex(HANDLE mutex)
1023 {
1024 NtReleaseMutant( mutex, NULL );
1025 NtClose( mutex );
1026 }
1027
1028 /* Find the Vulkan device UUID corresponding to a LUID */
1029 static BOOL get_vulkan_uuid_from_luid( const LUID *luid, GUID *uuid )
1030 {
1031 static const WCHAR class_guidW[] = {'C','l','a','s','s','G','U','I','D',0};
1032 static const WCHAR devpropkey_gpu_vulkan_uuidW[] =
1033 {
1034 'P','r','o','p','e','r','t','i','e','s',
1035 '\\','{','2','3','3','A','9','E','F','3','-','A','F','C','4','-','4','A','B','D',
1036 '-','B','5','6','4','-','C','3','2','F','2','1','F','1','5','3','5','C','}',
1037 '\\','0','0','0','2'
1038 };
1039 static const WCHAR devpropkey_gpu_luidW[] =
1040 {
1041 'P','r','o','p','e','r','t','i','e','s',
1042 '\\','{','6','0','B','1','9','3','C','B','-','5','2','7','6','-','4','D','0','F',
1043 '-','9','6','F','C','-','F','1','7','3','A','B','A','D','3','E','C','6','}',
1044 '\\','0','0','0','2'
1045 };
1046 static const WCHAR guid_devclass_displayW[] =
1047 {'{','4','D','3','6','E','9','6','8','-','E','3','2','5','-','1','1','C','E','-',
1048 'B','F','C','1','-','0','8','0','0','2','B','E','1','0','3','1','8','}',0};
1049 static const WCHAR pci_keyW[] =
1050 {
1051 '\\','R','e','g','i','s','t','r','y',
1052 '\\','M','a','c','h','i','n','e',
1053 '\\','S','y','s','t','e','m',
1054 '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
1055 '\\','E','n','u','m',
1056 '\\','P','C','I'
1057 };
1058 char buffer[4096];
1059 KEY_VALUE_PARTIAL_INFORMATION *value = (void *)buffer;
1060 HKEY subkey, device_key, prop_key, pci_key;
1061 KEY_NODE_INFORMATION *key = (void *)buffer;
1062 DWORD size, i = 0;
1063 HANDLE mutex;
1064
1065 mutex = get_display_device_init_mutex();
1066
1067 pci_key = reg_open_key(NULL, pci_keyW, sizeof(pci_keyW));
1068 while (!NtEnumerateKey(pci_key, i++, KeyNodeInformation, key, sizeof(buffer), &size))
1069 {
1070 unsigned int j = 0;
1071
1072 if (!(subkey = reg_open_key(pci_key, key->Name, key->NameLength)))
1073 continue;
1074
1075 while (!NtEnumerateKey(subkey, j++, KeyNodeInformation, key, sizeof(buffer), &size))
1076 {
1077 if (!(device_key = reg_open_key(subkey, key->Name, key->NameLength)))
1078 continue;
1079
1080 size = query_reg_value(device_key, class_guidW, value, sizeof(buffer));
1081 if (size != sizeof(guid_devclass_displayW) ||
1082 wcscmp((WCHAR *)value->Data, guid_devclass_displayW))
1083 {
1084 NtClose(device_key);
1085 continue;
1086 }
1087
1088 if (!(prop_key = reg_open_key(device_key, devpropkey_gpu_luidW,
1089 sizeof(devpropkey_gpu_luidW))))
1090 {
1091 NtClose(device_key);
1092 continue;
1093 }
1094
1095 size = query_reg_value(prop_key, NULL, value, sizeof(buffer));
1096 NtClose(prop_key);
1097 if (size != sizeof(LUID) || memcmp(value->Data, luid, sizeof(LUID)))
1098 {
1099 NtClose(device_key);
1100 continue;
1101 }
1102
1103 if (!(prop_key = reg_open_key(device_key, devpropkey_gpu_vulkan_uuidW,
1104 sizeof(devpropkey_gpu_vulkan_uuidW))))
1105 {
1106 NtClose(device_key);
1107 continue;
1108 }
1109
1110 size = query_reg_value(prop_key, NULL, value, sizeof(buffer));
1111 NtClose(prop_key);
1112 if (size != sizeof(GUID))
1113 {
1114 NtClose(device_key);
1115 continue;
1116 }
1117
1118 *uuid = *(const GUID *)value->Data;
1119 NtClose(device_key);
1120 NtClose(subkey);
1121 NtClose(pci_key);
1122 release_display_device_init_mutex(mutex);
1123 return TRUE;
1124 }
1125 NtClose(subkey);
1126 }
1127 NtClose(pci_key);
1128
1129 release_display_device_init_mutex(mutex);
1130 return FALSE;
1131 }
1132
1133 NTSTATUS CDECL X11DRV_D3DKMTOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc )
1134 {
1135 static const char *extensions[] =
1136 {
1137 VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
1138 VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
1139 };
1140 const struct vulkan_funcs *vulkan_funcs;
1141 PFN_vkGetPhysicalDeviceProperties2KHR pvkGetPhysicalDeviceProperties2KHR;
1142 PFN_vkEnumeratePhysicalDevices pvkEnumeratePhysicalDevices;
1143 VkPhysicalDevice *vk_physical_devices = NULL;
1144 VkPhysicalDeviceProperties2 properties2;
1145 NTSTATUS status = STATUS_UNSUCCESSFUL;
1146 UINT device_count, device_idx = 0;
1147 struct x11_d3dkmt_adapter *adapter;
1148 VkInstanceCreateInfo create_info;
1149 VkPhysicalDeviceIDProperties id;
1150 VkResult vr;
1151 GUID uuid;
1152
1153 if (!get_vulkan_uuid_from_luid(&desc->AdapterLuid, &uuid))
1154 {
1155 WARN("Failed to find Vulkan device with LUID %08x:%08x.\n",
1156 (int)desc->AdapterLuid.HighPart, (int)desc->AdapterLuid.LowPart);
1157 return STATUS_INVALID_PARAMETER;
1158 }
1159
1160 /* Find the Vulkan device with corresponding UUID */
1161 if (!(vulkan_funcs = get_vulkan_driver(WINE_VULKAN_DRIVER_VERSION)))
1162 {
1163 WARN("Vulkan is unavailable.\n");
1164 return STATUS_UNSUCCESSFUL;
1165 }
1166
1167 pthread_mutex_lock(&d3dkmt_mutex);
1168
1169 if (!d3dkmt_vk_instance)
1170 {
1171 memset(&create_info, 0, sizeof(create_info));
1172 create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
1173 create_info.enabledExtensionCount = ARRAY_SIZE(extensions);
1174 create_info.ppEnabledExtensionNames = extensions;
1175
1176 vr = vulkan_funcs->p_vkCreateInstance(&create_info, NULL, &d3dkmt_vk_instance);
1177 if (vr != VK_SUCCESS)
1178 {
1179 WARN("Failed to create a Vulkan instance, vr %d.\n", vr);
1180 goto done;
1181 }
1182 }
1183
1184 #define LOAD_VK_FUNC(f) \
1185 if (!(p##f = (void *)vulkan_funcs->p_vkGetInstanceProcAddr(d3dkmt_vk_instance, #f))) \
1186 { \
1187 WARN("Failed to load " #f ".\n"); \
1188 goto done; \
1189 }
1190
1191 LOAD_VK_FUNC(vkEnumeratePhysicalDevices)
1192 LOAD_VK_FUNC(vkGetPhysicalDeviceProperties2KHR)
1193 #undef LOAD_VK_FUNC
1194
1195 vr = pvkEnumeratePhysicalDevices(d3dkmt_vk_instance, &device_count, NULL);
1196 if (vr != VK_SUCCESS || !device_count)
1197 {
1198 WARN("No Vulkan device found, vr %d, device_count %d.\n", vr, device_count);
1199 goto done;
1200 }
1201
1202 if (!(vk_physical_devices = calloc(device_count, sizeof(*vk_physical_devices))))
1203 goto done;
1204
1205 vr = pvkEnumeratePhysicalDevices(d3dkmt_vk_instance, &device_count, vk_physical_devices);
1206 if (vr != VK_SUCCESS)
1207 {
1208 WARN("vkEnumeratePhysicalDevices failed, vr %d.\n", vr);
1209 goto done;
1210 }
1211
1212 for (device_idx = 0; device_idx < device_count; ++device_idx)
1213 {
1214 memset(&id, 0, sizeof(id));
1215 id.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
1216 properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
1217 properties2.pNext = &id;
1218
1219 pvkGetPhysicalDeviceProperties2KHR(vk_physical_devices[device_idx], &properties2);
1220 if (!IsEqualGUID(&uuid, id.deviceUUID))
1221 continue;
1222
1223 if (!(adapter = malloc(sizeof(*adapter))))
1224 {
1225 status = STATUS_NO_MEMORY;
1226 goto done;
1227 }
1228
1229 adapter->handle = desc->hAdapter;
1230 adapter->vk_device = vk_physical_devices[device_idx];
1231 list_add_head(&x11_d3dkmt_adapters, &adapter->entry);
1232 status = STATUS_SUCCESS;
1233 break;
1234 }
1235
1236 done:
1237 if (d3dkmt_vk_instance && list_empty(&x11_d3dkmt_adapters))
1238 {
1239 vulkan_funcs->p_vkDestroyInstance(d3dkmt_vk_instance, NULL);
1240 d3dkmt_vk_instance = NULL;
1241 }
1242 pthread_mutex_unlock(&d3dkmt_mutex);
1243 free(vk_physical_devices);
1244 return status;
1245 }
1246
1247 NTSTATUS CDECL X11DRV_D3DKMTQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
1248 {
1249 const struct vulkan_funcs *vulkan_funcs = get_vulkan_driver(WINE_VULKAN_DRIVER_VERSION);
1250 PFN_vkGetPhysicalDeviceMemoryProperties2KHR pvkGetPhysicalDeviceMemoryProperties2KHR;
1251 VkPhysicalDeviceMemoryBudgetPropertiesEXT budget;
1252 VkPhysicalDeviceMemoryProperties2 properties2;
1253 NTSTATUS status = STATUS_INVALID_PARAMETER;
1254 struct x11_d3dkmt_adapter *adapter;
1255 unsigned int i;
1256
1257 desc->Budget = 0;
1258 desc->CurrentUsage = 0;
1259 desc->CurrentReservation = 0;
1260 desc->AvailableForReservation = 0;
1261
1262 if (!vulkan_funcs)
1263 {
1264 WARN("Vulkan is unavailable.\n");
1265 return STATUS_UNSUCCESSFUL;
1266 }
1267
1268 pthread_mutex_lock(&d3dkmt_mutex);
1269 LIST_FOR_EACH_ENTRY(adapter, &x11_d3dkmt_adapters, struct x11_d3dkmt_adapter, entry)
1270 {
1271 if (adapter->handle != desc->hAdapter)
1272 continue;
1273
1274 if (!(pvkGetPhysicalDeviceMemoryProperties2KHR = (void *)vulkan_funcs->p_vkGetInstanceProcAddr(d3dkmt_vk_instance, "vkGetPhysicalDeviceMemoryProperties2KHR")))
1275 {
1276 WARN("Failed to load vkGetPhysicalDeviceMemoryProperties2KHR.\n");
1277 status = STATUS_UNSUCCESSFUL;
1278 goto done;
1279 }
1280
1281 memset(&budget, 0, sizeof(budget));
1282 budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
1283 properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
1284 properties2.pNext = &budget;
1285 pvkGetPhysicalDeviceMemoryProperties2KHR(adapter->vk_device, &properties2);
1286 for (i = 0; i < properties2.memoryProperties.memoryHeapCount; ++i)
1287 {
1288 if ((desc->MemorySegmentGroup == D3DKMT_MEMORY_SEGMENT_GROUP_LOCAL
1289 && properties2.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
1290 || (desc->MemorySegmentGroup == D3DKMT_MEMORY_SEGMENT_GROUP_NON_LOCAL
1291 && !(properties2.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)))
1292 {
1293 desc->Budget += budget.heapBudget[i];
1294 desc->CurrentUsage += budget.heapUsage[i];
1295 }
1296 }
1297 desc->AvailableForReservation = desc->Budget / 2;
1298 status = STATUS_SUCCESS;
1299 break;
1300 }
1301 done:
1302 pthread_mutex_unlock(&d3dkmt_mutex);
1303 return status;
1304 }
1305
1306 NTSTATUS x11drv_client_func( enum x11drv_client_funcs id, const void *params, ULONG size )
1307 {
1308 void *ret_ptr;
1309 ULONG ret_len;
1310 return KeUserModeCallback( id, params, size, &ret_ptr, &ret_len );
1311 }
1312
1313
1314 NTSTATUS x11drv_client_call( enum client_callback func, UINT arg )
1315 {
1316 struct client_callback_params params = { .id = func, .arg = arg };
1317 return x11drv_client_func( client_func_callback, &params, sizeof(params) );
1318 }
1319
1320
1321 const unixlib_entry_t __wine_unix_call_funcs[] =
1322 {
1323 x11drv_create_desktop,
1324 x11drv_init,
1325 x11drv_systray_clear,
1326 x11drv_systray_dock,
1327 x11drv_systray_hide,
1328 x11drv_systray_init,
1329 x11drv_tablet_attach_queue,
1330 x11drv_tablet_get_packet,
1331 x11drv_tablet_info,
1332 x11drv_tablet_load_info,
1333 x11drv_xim_preedit_state,
1334 x11drv_xim_reset,
1335 };
1336
1337
1338 C_ASSERT( ARRAYSIZE(__wine_unix_call_funcs) == unix_funcs_count );
1339
1340
1341 #ifdef _WIN64
1342
1343 static NTSTATUS x11drv_wow64_init( void *arg )
1344 {
1345 struct
1346 {
1347 ULONG foreign_window_proc;
1348 ULONG show_systray;
1349 } *params32 = arg;
1350 struct init_params params;
1351
1352 params.foreign_window_proc = UlongToPtr( params32->foreign_window_proc );
1353 params.show_systray = UlongToPtr( params32->show_systray );
1354 return x11drv_init( &params );
1355 }
1356
1357 static NTSTATUS x11drv_wow64_systray_clear( void *arg )
1358 {
1359 HWND hwnd = UlongToPtr( *(ULONG *)arg );
1360 return x11drv_systray_clear( &hwnd );
1361 }
1362
1363 static NTSTATUS x11drv_wow64_systray_dock( void *arg )
1364 {
1365 struct
1366 {
1367 UINT64 event_handle;
1368 ULONG icon;
1369 int cx;
1370 int cy;
1371 ULONG layered;
1372 } *params32 = arg;
1373 struct systray_dock_params params;
1374
1375 params.event_handle = params32->event_handle;
1376 params.icon = UlongToPtr( params32->icon );
1377 params.cx = params32->cx;
1378 params.cy = params32->cy;
1379 params.layered = UlongToPtr( params32->layered );
1380 return x11drv_systray_dock( &params );
1381 }
1382
1383 static NTSTATUS x11drv_wow64_systray_hide( void *arg )
1384 {
1385 HWND hwnd = UlongToPtr( *(ULONG *)arg );
1386 return x11drv_systray_hide( &hwnd );
1387 }
1388
1389 static NTSTATUS x11drv_wow64_tablet_get_packet( void *arg )
1390 {
1391 FIXME( "%p\n", arg );
1392 return 0;
1393 }
1394
1395 static NTSTATUS x11drv_wow64_tablet_info( void *arg )
1396 {
1397 struct
1398 {
1399 UINT category;
1400 UINT index;
1401 ULONG output;
1402 } *params32 = arg;
1403 struct tablet_info_params params;
1404
1405 params.category = params32->category;
1406 params.index = params32->index;
1407 params.output = UlongToPtr( params32->output );
1408 return x11drv_tablet_info( &params );
1409 }
1410
1411 static NTSTATUS x11drv_wow64_xim_preedit_state( void *arg )
1412 {
1413 struct
1414 {
1415 ULONG hwnd;
1416 BOOL open;
1417 } *params32 = arg;
1418 struct xim_preedit_state_params params;
1419
1420 params.hwnd = UlongToHandle( params32->hwnd );
1421 params.open = params32->open;
1422 return x11drv_xim_preedit_state( &params );
1423 }
1424
1425 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
1426 {
1427 x11drv_create_desktop,
1428 x11drv_wow64_init,
1429 x11drv_wow64_systray_clear,
1430 x11drv_wow64_systray_dock,
1431 x11drv_wow64_systray_hide,
1432 x11drv_systray_init,
1433 x11drv_tablet_attach_queue,
1434 x11drv_wow64_tablet_get_packet,
1435 x11drv_wow64_tablet_info,
1436 x11drv_tablet_load_info,
1437 x11drv_wow64_xim_preedit_state,
1438 x11drv_xim_reset,
1439 };
1440
1441 C_ASSERT( ARRAYSIZE(__wine_unix_call_wow64_funcs) == unix_funcs_count );
1442
1443 #endif /* _WIN64 */
Windows API implementation