85525431bf9565ae89f9b5aa12c578e951b078f7
[mesa.git] / src / glx / driwindows_glx.c
1 /*
2 * Copyright © 2014 Jon Turney
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include "glxclient.h"
25 #include "glx_error.h"
26 #include "dri_common.h"
27 #include "util/macros.h"
28 #include "windows/xwindowsdri.h"
29 #include "windows/windowsgl.h"
30
31 struct driwindows_display
32 {
33 __GLXDRIdisplay base;
34 int event_base;
35 };
36
37 struct driwindows_context
38 {
39 struct glx_context base;
40 windowsContext *windowsContext;
41 };
42
43 struct driwindows_config
44 {
45 struct glx_config base;
46 int pxfi;
47 };
48
49 struct driwindows_screen
50 {
51 struct glx_screen base;
52 __DRIscreen *driScreen;
53 __GLXDRIscreen vtable;
54 Bool copySubBuffer;
55 };
56
57 struct driwindows_drawable
58 {
59 __GLXDRIdrawable base;
60 windowsDrawable *windowsDrawable;
61 };
62
63 /**
64 * GLXDRI functions
65 */
66
67 static void
68 driwindows_destroy_context(struct glx_context *context)
69 {
70 struct driwindows_context *pcp = (struct driwindows_context *) context;
71
72 driReleaseDrawables(&pcp->base);
73
74 free((char *) context->extensions);
75
76 windows_destroy_context(pcp->windowsContext);
77
78 free(pcp);
79 }
80
81 static int
82 driwindows_bind_context(struct glx_context *context, struct glx_context *old,
83 GLXDrawable draw, GLXDrawable read)
84 {
85 struct driwindows_context *pcp = (struct driwindows_context *) context;
86 struct driwindows_drawable *pdraw, *pread;
87
88 pdraw = (struct driwindows_drawable *) driFetchDrawable(context, draw);
89 pread = (struct driwindows_drawable *) driFetchDrawable(context, read);
90
91 driReleaseDrawables(&pcp->base);
92
93 if (pdraw == NULL || pread == NULL)
94 return GLXBadDrawable;
95
96 if (windows_bind_context(pcp->windowsContext,
97 pdraw->windowsDrawable, pread->windowsDrawable))
98 return Success;
99
100 return GLXBadContext;
101 }
102
103 static void
104 driwindows_unbind_context(struct glx_context *context, struct glx_context *new)
105 {
106 struct driwindows_context *pcp = (struct driwindows_context *) context;
107
108 windows_unbind_context(pcp->windowsContext);
109 }
110
111 static void
112 driwindows_bind_tex_image(Display * dpy,
113 GLXDrawable drawable,
114 int buffer, const int *attrib_list)
115 {
116 struct glx_context *gc = __glXGetCurrentContext();
117 struct driwindows_context *pcp = (struct driwindows_context *) gc;
118 __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
119 struct driwindows_drawable *pdraw = (struct driwindows_drawable *) base;
120
121 __glXInitialize(dpy);
122
123 if (pdraw != NULL) {
124 windows_setTexBuffer(pcp->windowsContext,
125 pdraw->base.textureTarget,
126 pdraw->base.textureFormat,
127 pdraw->windowsDrawable);
128 }
129 }
130
131 static void
132 driwindows_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
133 {
134 struct glx_context *gc = __glXGetCurrentContext();
135 struct driwindows_context *pcp = (struct driwindows_context *) gc;
136 __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
137 struct glx_display *dpyPriv = __glXInitialize(dpy);
138 struct driwindows_drawable *pdraw = (struct driwindows_drawable *) base;
139
140 if (dpyPriv != NULL && pdraw != NULL) {
141 windows_releaseTexBuffer(pcp->windowsContext,
142 pdraw->base.textureTarget,
143 pdraw->windowsDrawable);
144 }
145 }
146
147 static const struct glx_context_vtable driwindows_context_vtable = {
148 .destroy = driwindows_destroy_context,
149 .bind = driwindows_bind_context,
150 .unbind = driwindows_unbind_context,
151 .wait_gl = NULL,
152 .wait_x = NULL,
153 .use_x_font = DRI_glXUseXFont,
154 .bind_tex_image = driwindows_bind_tex_image,
155 .release_tex_image = driwindows_release_tex_image,
156 .get_proc_address = NULL,
157 };
158
159 static struct glx_context *
160 driwindows_create_context(struct glx_screen *base,
161 struct glx_config *config_base,
162 struct glx_context *shareList, int renderType)
163 {
164 struct driwindows_context *pcp, *pcp_shared;
165 struct driwindows_config *config = (struct driwindows_config *) config_base;
166 struct driwindows_screen *psc = (struct driwindows_screen *) base;
167 windowsContext *shared = NULL;
168
169 if (!psc->base.driScreen)
170 return NULL;
171
172 /* Check the renderType value */
173 if (!validate_renderType_against_config(config_base, renderType))
174 return NULL;
175
176 if (shareList) {
177 /* If the shareList context is not on this renderer, we cannot possibly
178 * create a context that shares with it.
179 */
180 if (shareList->vtable->destroy != driwindows_destroy_context) {
181 return NULL;
182 }
183
184 pcp_shared = (struct driwindows_context *) shareList;
185 shared = pcp_shared->windowsContext;
186 }
187
188 pcp = calloc(1, sizeof *pcp);
189 if (pcp == NULL)
190 return NULL;
191
192 if (!glx_context_init(&pcp->base, &psc->base, &config->base)) {
193 free(pcp);
194 return NULL;
195 }
196
197 pcp->base.renderType = renderType;
198
199 InfoMessageF("visualID %x, fbConfigID %x -> pxfi %d\n", config_base->visualID, config_base->fbconfigID, config->pxfi);
200
201 pcp->windowsContext = windows_create_context(config->pxfi, shared);
202
203 if (!pcp->windowsContext) {
204 free(pcp);
205 return NULL;
206 }
207
208 pcp->base.vtable = &driwindows_context_vtable;
209
210 return &pcp->base;
211 }
212
213 static struct glx_context *
214 driwindows_create_context_attribs(struct glx_screen *base,
215 struct glx_config *config_base,
216 struct glx_context *shareList,
217 unsigned num_attribs,
218 const uint32_t *attribs,
219 unsigned *error)
220 {
221 struct driwindows_context *pcp, *pcp_shared;
222 struct driwindows_config *config = (struct driwindows_config *) config_base;
223 struct driwindows_screen *psc = (struct driwindows_screen *) base;
224 windowsContext *shared = NULL;
225
226 int i;
227 uint32_t renderType = GLX_RGBA_TYPE;
228
229 /* Extract renderType from attribs */
230 for (i = 0; i < num_attribs; i++) {
231 switch (attribs[i * 2]) {
232 case GLX_RENDER_TYPE:
233 renderType = attribs[i * 2 + 1];
234 break;
235 }
236 }
237
238 /*
239 Perhaps we should map GLX tokens to WGL tokens, but they appear to have
240 identical values, so far
241 */
242
243 if (!psc->base.driScreen)
244 return NULL;
245
246 /* Check the renderType value */
247 if (!validate_renderType_against_config(config_base, renderType)) {
248 return NULL;
249 }
250
251 if (shareList) {
252 /* If the shareList context is not on this renderer, we cannot possibly
253 * create a context that shares with it.
254 */
255 if (shareList->vtable->destroy != driwindows_destroy_context) {
256 return NULL;
257 }
258
259 pcp_shared = (struct driwindows_context *) shareList;
260 shared = pcp_shared->windowsContext;
261 }
262
263 pcp = calloc(1, sizeof *pcp);
264 if (pcp == NULL)
265 return NULL;
266
267 if (!glx_context_init(&pcp->base, &psc->base, &config->base)) {
268 free(pcp);
269 return NULL;
270 }
271
272 pcp->base.renderType = renderType;
273
274 InfoMessageF("visualID %x, fbConfigID %x -> pxfi %d\n", config_base->visualID, config_base->fbconfigID, config->pxfi);
275
276 pcp->windowsContext = windows_create_context_attribs(config->pxfi,
277 shared,
278 (const int *)attribs);
279 if (pcp->windowsContext == NULL) {
280 free(pcp);
281 return NULL;
282 }
283
284 pcp->base.vtable = &driwindows_context_vtable;
285
286 return &pcp->base;
287 }
288
289 static void
290 driwindowsDestroyDrawable(__GLXDRIdrawable * pdraw)
291 {
292 struct driwindows_drawable *pdp = (struct driwindows_drawable *) pdraw;
293
294 windows_destroy_drawable(pdp->windowsDrawable);
295
296 free(pdp);
297 }
298
299 static __GLXDRIdrawable *
300 driwindowsCreateDrawable(struct glx_screen *base, XID xDrawable,
301 GLXDrawable drawable, struct glx_config *modes)
302 {
303 struct driwindows_drawable *pdp;
304 struct driwindows_screen *psc = (struct driwindows_screen *) base;
305
306 pdp = calloc(1, sizeof(*pdp));
307 if (!pdp)
308 return NULL;
309
310 pdp->base.xDrawable = xDrawable;
311 pdp->base.drawable = drawable;
312 pdp->base.psc = &psc->base;
313
314 /*
315 By this stage, the X drawable already exists, but the GLX drawable may
316 not.
317
318 Query the server with the XID to find the correct HWND, HPBUFFERARB or
319 HBITMAP
320 */
321
322 unsigned int type;
323 void *handle;
324
325 if (!XWindowsDRIQueryDrawable(psc->base.dpy, base->scr, drawable, &type, &handle))
326 {
327 free(pdp);
328 return NULL;
329 }
330
331 /* No handle found is a failure */
332 if (!handle) {
333 free(pdp);
334 return NULL;
335 }
336
337 /* Create a new drawable */
338 pdp->windowsDrawable = windows_create_drawable(type, handle);
339
340 if (!pdp->windowsDrawable) {
341 free(pdp);
342 return NULL;
343 }
344
345 pdp->base.destroyDrawable = driwindowsDestroyDrawable;
346
347 return &pdp->base;
348 }
349
350 static int64_t
351 driwindowsSwapBuffers(__GLXDRIdrawable * pdraw,
352 int64_t target_msc, int64_t divisor, int64_t remainder,
353 Bool flush)
354 {
355 struct driwindows_drawable *pdp = (struct driwindows_drawable *) pdraw;
356
357 (void) target_msc;
358 (void) divisor;
359 (void) remainder;
360
361 if (flush) {
362 glFlush();
363 }
364
365 windows_swap_buffers(pdp->windowsDrawable);
366
367 return 0;
368 }
369
370 static void
371 driwindowsCopySubBuffer(__GLXDRIdrawable * pdraw,
372 int x, int y, int width, int height, Bool flush)
373 {
374 struct driwindows_drawable *pdp = (struct driwindows_drawable *) pdraw;
375
376 if (flush) {
377 glFlush();
378 }
379
380 windows_copy_subbuffer(pdp->windowsDrawable, x, y, width, height);
381 }
382
383 static void
384 driwindowsDestroyScreen(struct glx_screen *base)
385 {
386 struct driwindows_screen *psc = (struct driwindows_screen *) base;
387
388 /* Free the direct rendering per screen data */
389 psc->driScreen = NULL;
390 free(psc);
391 }
392
393 static const struct glx_screen_vtable driwindows_screen_vtable = {
394 .create_context = driwindows_create_context,
395 .create_context_attribs = driwindows_create_context_attribs,
396 .query_renderer_integer = NULL,
397 .query_renderer_string = NULL,
398 };
399
400 static Bool
401 driwindowsBindExtensions(struct driwindows_screen *psc)
402 {
403 Bool result = 1;
404
405 const struct
406 {
407 char *wglext;
408 char *glxext;
409 Bool mandatory;
410 } extensionMap[] = {
411 { "WGL_ARB_make_current_read", "GLX_SGI_make_current_read", 0 },
412 { "WGL_EXT_swap_control", "GLX_SGI_swap_control", 0 },
413 { "WGL_EXT_swap_control", "GLX_MESA_swap_control", 0 },
414 // { "WGL_ARB_render_texture", "GLX_EXT_texture_from_pixmap", 0 },
415 // Not exactly equivalent, needs some more glue to be written
416 { "WGL_ARB_pbuffer", "GLX_SGIX_pbuffer", 1 },
417 { "WGL_ARB_multisample", "GLX_ARB_multisample", 1 },
418 { "WGL_ARB_multisample", "GLX_SGIS_multisample", 1 },
419 { "WGL_ARB_create_context", "GLX_ARB_create_context", 0 },
420 { "WGL_ARB_create_context_profile", "GLX_ARB_create_context_profile", 0 },
421 { "WGL_ARB_create_context_robustness", "GLX_ARB_create_context_robustness", 0 },
422 { "WGL_EXT_create_context_es2_profile", "GLX_EXT_create_context_es2_profile", 0 },
423 };
424
425 char *wgl_extensions;
426 char *gl_extensions;
427 int i;
428
429 windows_extensions(&gl_extensions, &wgl_extensions);
430
431 for (i = 0; i < ARRAY_SIZE(extensionMap); i++) {
432 if (strstr(wgl_extensions, extensionMap[i].wglext)) {
433 __glXEnableDirectExtension(&psc->base, extensionMap[i].glxext);
434 InfoMessageF("enabled %s\n", extensionMap[i].glxext);
435 }
436 else if (extensionMap[i].mandatory) {
437 ErrorMessageF("required WGL extension %s is missing\n", extensionMap[i].wglext);
438 result = 0;
439 }
440 }
441
442 /*
443 Because it pre-dates WGL_EXT_extensions_string, GL_WIN_swap_hint might
444 only be in GL_EXTENSIONS
445 */
446 if (strstr(gl_extensions, "GL_WIN_swap_hint")) {
447 psc->copySubBuffer = 1;
448 __glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer");
449 InfoMessageF("enabled GLX_MESA_copy_sub_buffer\n");
450 }
451
452 free(gl_extensions);
453 free(wgl_extensions);
454
455 return result;
456 }
457
458 static struct glx_config *
459 driwindowsMapConfigs(struct glx_display *priv, int screen, struct glx_config *configs, struct glx_config *fbconfigs)
460 {
461 struct glx_config head, *tail, *m;
462
463 tail = &head;
464 head.next = NULL;
465
466 for (m = configs; m; m = m->next) {
467 int fbconfigID = GLX_DONT_CARE;
468 if (fbconfigs) {
469 /*
470 visuals have fbconfigID of GLX_DONT_CARE, so search for a fbconfig
471 with matching visualID and get the fbconfigID from there
472 */
473 struct glx_config *f;
474 for (f = fbconfigs; f; f = f->next) {
475 if (f->visualID == m->visualID)
476 fbconfigID = f->fbconfigID;
477 }
478 }
479 else {
480 fbconfigID = m->fbconfigID;
481 }
482
483 int pxfi;
484 XWindowsDRIFBConfigToPixelFormat(priv->dpy, screen, fbconfigID, &pxfi);
485 if (pxfi == 0)
486 continue;
487
488 struct driwindows_config *config = malloc(sizeof(*config));
489
490 tail->next = &config->base;
491 if (tail->next == NULL)
492 continue;
493
494 config->base = *m;
495 config->pxfi = pxfi;
496
497 tail = tail->next;
498 }
499
500 return head.next;
501 }
502
503 static struct glx_screen *
504 driwindowsCreateScreen(int screen, struct glx_display *priv)
505 {
506 __GLXDRIscreen *psp;
507 struct driwindows_screen *psc;
508 struct glx_config *configs = NULL, *visuals = NULL;
509 int directCapable;
510
511 psc = calloc(1, sizeof *psc);
512 if (psc == NULL)
513 return NULL;
514
515 if (!glx_screen_init(&psc->base, screen, priv)) {
516 free(psc);
517 return NULL;
518 }
519
520 if (!XWindowsDRIQueryDirectRenderingCapable(psc->base.dpy, screen, &directCapable) ||
521 !directCapable) {
522 ErrorMessageF("Screen is not Windows-DRI capable\n");
523 goto handle_error;
524 }
525
526 /* discover native supported extensions */
527 if (!driwindowsBindExtensions(psc)) {
528 goto handle_error;
529 }
530
531 /* Augment configs with pxfi information */
532 configs = driwindowsMapConfigs(priv, screen, psc->base.configs, NULL);
533 visuals = driwindowsMapConfigs(priv, screen, psc->base.visuals, configs);
534
535 if (!configs || !visuals) {
536 ErrorMessageF("No fbConfigs or visuals found\n");
537 goto handle_error;
538 }
539
540 glx_config_destroy_list(psc->base.configs);
541 psc->base.configs = configs;
542 glx_config_destroy_list(psc->base.visuals);
543 psc->base.visuals = visuals;
544
545 psc->base.vtable = &driwindows_screen_vtable;
546 psp = &psc->vtable;
547 psc->base.driScreen = psp;
548 psp->destroyScreen = driwindowsDestroyScreen;
549 psp->createDrawable = driwindowsCreateDrawable;
550 psp->swapBuffers = driwindowsSwapBuffers;
551
552 if (psc->copySubBuffer)
553 psp->copySubBuffer = driwindowsCopySubBuffer;
554
555 return &psc->base;
556
557 handle_error:
558 glx_screen_cleanup(&psc->base);
559
560 return NULL;
561 }
562
563 /* Called from __glXFreeDisplayPrivate.
564 */
565 static void
566 driwindowsDestroyDisplay(__GLXDRIdisplay * dpy)
567 {
568 free(dpy);
569 }
570
571 /*
572 * Allocate, initialize and return a __GLXDRIdisplay object.
573 * This is called from __glXInitialize() when we are given a new
574 * display pointer.
575 */
576 _X_HIDDEN __GLXDRIdisplay *
577 driwindowsCreateDisplay(Display * dpy)
578 {
579 struct driwindows_display *pdpyp;
580
581 int eventBase, errorBase;
582 int major, minor, patch;
583
584 /* Verify server has Windows-DRI extension */
585 if (!XWindowsDRIQueryExtension(dpy, &eventBase, &errorBase)) {
586 ErrorMessageF("Windows-DRI extension not available\n");
587 return NULL;
588 }
589
590 if (!XWindowsDRIQueryVersion(dpy, &major, &minor, &patch)) {
591 ErrorMessageF("Fetching Windows-DRI extension version failed\n");
592 return NULL;
593 }
594
595 if (!windows_check_renderer()) {
596 ErrorMessageF("Windows-DRI extension disabled for GDI Generic renderer\n");
597 return NULL;
598 }
599
600 pdpyp = malloc(sizeof *pdpyp);
601 if (pdpyp == NULL)
602 return NULL;
603
604 pdpyp->base.destroyDisplay = driwindowsDestroyDisplay;
605 pdpyp->base.createScreen = driwindowsCreateScreen;
606
607 pdpyp->event_base = eventBase;
608
609 return &pdpyp->base;
610 }