egl/x11: pick the user requested screen
[mesa.git] / src / egl / drivers / dri2 / platform_x11.c
1 /*
2 * Copyright © 2011 Intel Corporation
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,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Kristian Høgsberg <krh@bitplanet.net>
26 */
27
28 #include <stdbool.h>
29 #include <stdint.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <stdio.h>
33 #include <limits.h>
34 #include <dlfcn.h>
35 #include <fcntl.h>
36 #include <errno.h>
37 #include <unistd.h>
38 #ifdef HAVE_LIBDRM
39 #include <xf86drm.h>
40 #endif
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include "util/debug.h"
44 #include "util/macros.h"
45
46 #include "egl_dri2.h"
47 #include "egl_dri2_fallbacks.h"
48 #include "loader.h"
49
50 #ifdef HAVE_DRI3
51 #include "platform_x11_dri3.h"
52 #endif
53
54 static EGLBoolean
55 dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
56 EGLint interval);
57
58 uint32_t
59 dri2_format_for_depth(struct dri2_egl_display *dri2_dpy, uint32_t depth);
60
61 static void
62 swrastCreateDrawable(struct dri2_egl_display * dri2_dpy,
63 struct dri2_egl_surface * dri2_surf)
64 {
65 uint32_t mask;
66 const uint32_t function = GXcopy;
67 uint32_t valgc[2];
68
69 /* create GC's */
70 dri2_surf->gc = xcb_generate_id(dri2_dpy->conn);
71 mask = XCB_GC_FUNCTION;
72 xcb_create_gc(dri2_dpy->conn, dri2_surf->gc, dri2_surf->drawable, mask, &function);
73
74 dri2_surf->swapgc = xcb_generate_id(dri2_dpy->conn);
75 mask = XCB_GC_FUNCTION | XCB_GC_GRAPHICS_EXPOSURES;
76 valgc[0] = function;
77 valgc[1] = False;
78 xcb_create_gc(dri2_dpy->conn, dri2_surf->swapgc, dri2_surf->drawable, mask, valgc);
79 switch (dri2_surf->depth) {
80 case 32:
81 case 30:
82 case 24:
83 dri2_surf->bytes_per_pixel = 4;
84 break;
85 case 16:
86 dri2_surf->bytes_per_pixel = 2;
87 break;
88 case 8:
89 dri2_surf->bytes_per_pixel = 1;
90 break;
91 case 0:
92 dri2_surf->bytes_per_pixel = 0;
93 break;
94 default:
95 _eglLog(_EGL_WARNING, "unsupported depth %d", dri2_surf->depth);
96 }
97 }
98
99 static void
100 swrastDestroyDrawable(struct dri2_egl_display * dri2_dpy,
101 struct dri2_egl_surface * dri2_surf)
102 {
103 xcb_free_gc(dri2_dpy->conn, dri2_surf->gc);
104 xcb_free_gc(dri2_dpy->conn, dri2_surf->swapgc);
105 }
106
107 static bool
108 x11_get_drawable_info(__DRIdrawable * draw,
109 int *x, int *y, int *w, int *h,
110 void *loaderPrivate)
111 {
112 struct dri2_egl_surface *dri2_surf = loaderPrivate;
113 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display);
114
115 xcb_get_geometry_cookie_t cookie;
116 xcb_get_geometry_reply_t *reply;
117 xcb_generic_error_t *error;
118 bool ret;
119
120 cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
121 reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
122 if (reply == NULL)
123 return false;
124
125 if (error != NULL) {
126 ret = false;
127 _eglLog(_EGL_WARNING, "error in xcb_get_geometry");
128 free(error);
129 } else {
130 *x = reply->x;
131 *y = reply->y;
132 *w = reply->width;
133 *h = reply->height;
134 ret = true;
135 }
136 free(reply);
137 return ret;
138 }
139
140 static void
141 swrastGetDrawableInfo(__DRIdrawable * draw,
142 int *x, int *y, int *w, int *h,
143 void *loaderPrivate)
144 {
145 *x = *y = *w = *h = 0;
146 x11_get_drawable_info(draw, x, y, w, h, loaderPrivate);
147 }
148
149 static void
150 swrastPutImage(__DRIdrawable * draw, int op,
151 int x, int y, int w, int h,
152 char *data, void *loaderPrivate)
153 {
154 struct dri2_egl_surface *dri2_surf = loaderPrivate;
155 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display);
156
157 xcb_gcontext_t gc;
158
159 switch (op) {
160 case __DRI_SWRAST_IMAGE_OP_DRAW:
161 gc = dri2_surf->gc;
162 break;
163 case __DRI_SWRAST_IMAGE_OP_SWAP:
164 gc = dri2_surf->swapgc;
165 break;
166 default:
167 return;
168 }
169
170 xcb_put_image(dri2_dpy->conn, XCB_IMAGE_FORMAT_Z_PIXMAP, dri2_surf->drawable,
171 gc, w, h, x, y, 0, dri2_surf->depth,
172 w*h*dri2_surf->bytes_per_pixel, (const uint8_t *)data);
173 }
174
175 static void
176 swrastGetImage(__DRIdrawable * read,
177 int x, int y, int w, int h,
178 char *data, void *loaderPrivate)
179 {
180 struct dri2_egl_surface *dri2_surf = loaderPrivate;
181 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display);
182
183 xcb_get_image_cookie_t cookie;
184 xcb_get_image_reply_t *reply;
185 xcb_generic_error_t *error;
186
187 cookie = xcb_get_image (dri2_dpy->conn, XCB_IMAGE_FORMAT_Z_PIXMAP,
188 dri2_surf->drawable, x, y, w, h, ~0);
189 reply = xcb_get_image_reply (dri2_dpy->conn, cookie, &error);
190 if (reply == NULL)
191 return;
192
193 if (error != NULL) {
194 _eglLog(_EGL_WARNING, "error in xcb_get_image");
195 free(error);
196 } else {
197 uint32_t bytes = xcb_get_image_data_length(reply);
198 uint8_t *idata = xcb_get_image_data(reply);
199 memcpy(data, idata, bytes);
200 }
201 free(reply);
202 }
203
204
205 static xcb_screen_t *
206 get_xcb_screen(xcb_screen_iterator_t iter, int screen)
207 {
208 for (; iter.rem; --screen, xcb_screen_next(&iter))
209 if (screen == 0)
210 return iter.data;
211
212 return NULL;
213 }
214
215 static xcb_visualtype_t *
216 get_xcb_visualtype_for_depth(struct dri2_egl_display *dri2_dpy, int depth)
217 {
218 xcb_visualtype_iterator_t visual_iter;
219 xcb_screen_t *screen = dri2_dpy->screen;
220 xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(screen);
221
222 for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
223 if (depth_iter.data->depth != depth)
224 continue;
225
226 visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
227 if (visual_iter.rem)
228 return visual_iter.data;
229 }
230
231 return NULL;
232 }
233
234 /* Get red channel mask for given depth. */
235 unsigned int
236 dri2_x11_get_red_mask_for_depth(struct dri2_egl_display *dri2_dpy, int depth)
237 {
238 xcb_visualtype_t *visual = get_xcb_visualtype_for_depth(dri2_dpy, depth);
239
240 if (visual)
241 return visual->red_mask;
242
243 return 0;
244 }
245
246 /**
247 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
248 */
249 static _EGLSurface *
250 dri2_x11_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
251 _EGLConfig *conf, void *native_surface,
252 const EGLint *attrib_list)
253 {
254 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
255 struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
256 struct dri2_egl_surface *dri2_surf;
257 xcb_get_geometry_cookie_t cookie;
258 xcb_get_geometry_reply_t *reply;
259 xcb_generic_error_t *error;
260 const __DRIconfig *config;
261
262 (void) drv;
263
264 dri2_surf = malloc(sizeof *dri2_surf);
265 if (!dri2_surf) {
266 _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
267 return NULL;
268 }
269
270 if (!dri2_init_surface(&dri2_surf->base, disp, type, conf, attrib_list,
271 false, native_surface))
272 goto cleanup_surf;
273
274 dri2_surf->region = XCB_NONE;
275 if (type == EGL_PBUFFER_BIT) {
276 dri2_surf->drawable = xcb_generate_id(dri2_dpy->conn);
277 xcb_create_pixmap(dri2_dpy->conn, conf->BufferSize,
278 dri2_surf->drawable, dri2_dpy->screen->root,
279 dri2_surf->base.Width, dri2_surf->base.Height);
280 } else {
281 STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_surface));
282 dri2_surf->drawable = (uintptr_t) native_surface;
283 }
284
285 config = dri2_get_dri_config(dri2_conf, type,
286 dri2_surf->base.GLColorspace);
287
288 if (!config) {
289 _eglError(EGL_BAD_MATCH, "Unsupported surfacetype/colorspace configuration");
290 goto cleanup_pixmap;
291 }
292
293 if (dri2_dpy->dri2) {
294 dri2_surf->dri_drawable =
295 dri2_dpy->dri2->createNewDrawable(dri2_dpy->dri_screen, config,
296 dri2_surf);
297 } else {
298 assert(dri2_dpy->swrast);
299 dri2_surf->dri_drawable =
300 dri2_dpy->swrast->createNewDrawable(dri2_dpy->dri_screen, config,
301 dri2_surf);
302 }
303
304 if (dri2_surf->dri_drawable == NULL) {
305 _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
306 goto cleanup_pixmap;
307 }
308
309 if (type != EGL_PBUFFER_BIT) {
310 cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
311 reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
312 if (error != NULL) {
313 if (error->error_code == BadAlloc)
314 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
315 else if (type == EGL_WINDOW_BIT)
316 _eglError(EGL_BAD_NATIVE_WINDOW, "xcb_get_geometry");
317 else
318 _eglError(EGL_BAD_NATIVE_PIXMAP, "xcb_get_geometry");
319 free(error);
320 goto cleanup_dri_drawable;
321 } else if (reply == NULL) {
322 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
323 goto cleanup_dri_drawable;
324 }
325
326 dri2_surf->base.Width = reply->width;
327 dri2_surf->base.Height = reply->height;
328 dri2_surf->depth = reply->depth;
329 free(reply);
330 }
331
332 if (dri2_dpy->dri2) {
333 xcb_void_cookie_t cookie;
334 int conn_error;
335
336 cookie = xcb_dri2_create_drawable_checked(dri2_dpy->conn,
337 dri2_surf->drawable);
338 error = xcb_request_check(dri2_dpy->conn, cookie);
339 conn_error = xcb_connection_has_error(dri2_dpy->conn);
340 if (conn_error || error != NULL) {
341 if (type == EGL_PBUFFER_BIT || conn_error || error->error_code == BadAlloc)
342 _eglError(EGL_BAD_ALLOC, "xcb_dri2_create_drawable_checked");
343 else if (type == EGL_WINDOW_BIT)
344 _eglError(EGL_BAD_NATIVE_WINDOW,
345 "xcb_dri2_create_drawable_checked");
346 else
347 _eglError(EGL_BAD_NATIVE_PIXMAP,
348 "xcb_dri2_create_drawable_checked");
349 free(error);
350 goto cleanup_dri_drawable;
351 }
352 } else {
353 if (type == EGL_PBUFFER_BIT) {
354 dri2_surf->depth = _eglGetConfigKey(conf, EGL_BUFFER_SIZE);
355 }
356 swrastCreateDrawable(dri2_dpy, dri2_surf);
357 }
358
359 /* we always copy the back buffer to front */
360 dri2_surf->base.PostSubBufferSupportedNV = EGL_TRUE;
361
362 return &dri2_surf->base;
363
364 cleanup_dri_drawable:
365 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
366 cleanup_pixmap:
367 if (type == EGL_PBUFFER_BIT)
368 xcb_free_pixmap(dri2_dpy->conn, dri2_surf->drawable);
369 cleanup_surf:
370 free(dri2_surf);
371
372 return NULL;
373 }
374
375 /**
376 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
377 */
378 static _EGLSurface *
379 dri2_x11_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
380 _EGLConfig *conf, void *native_window,
381 const EGLint *attrib_list)
382 {
383 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
384 _EGLSurface *surf;
385
386 surf = dri2_x11_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
387 native_window, attrib_list);
388 if (surf != NULL) {
389 /* When we first create the DRI2 drawable, its swap interval on the
390 * server side is 1.
391 */
392 surf->SwapInterval = 1;
393
394 /* Override that with a driconf-set value. */
395 dri2_x11_swap_interval(drv, disp, surf, dri2_dpy->default_swap_interval);
396 }
397
398 return surf;
399 }
400
401 static _EGLSurface *
402 dri2_x11_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
403 _EGLConfig *conf, void *native_pixmap,
404 const EGLint *attrib_list)
405 {
406 return dri2_x11_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
407 native_pixmap, attrib_list);
408 }
409
410 static _EGLSurface *
411 dri2_x11_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
412 _EGLConfig *conf, const EGLint *attrib_list)
413 {
414 return dri2_x11_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
415 NULL, attrib_list);
416 }
417
418 static EGLBoolean
419 dri2_x11_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
420 {
421 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
422 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
423
424 (void) drv;
425
426 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
427
428 if (dri2_dpy->dri2) {
429 xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable);
430 } else {
431 assert(dri2_dpy->swrast);
432 swrastDestroyDrawable(dri2_dpy, dri2_surf);
433 }
434
435 if (surf->Type == EGL_PBUFFER_BIT)
436 xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable);
437
438 dri2_fini_surface(surf);
439 free(surf);
440
441 return EGL_TRUE;
442 }
443
444 /**
445 * Function utilizes swrastGetDrawableInfo to get surface
446 * geometry from x server and calls default query surface
447 * implementation that returns the updated values.
448 *
449 * In case of errors we still return values that we currently
450 * have.
451 */
452 static EGLBoolean
453 dri2_query_surface(_EGLDriver *drv, _EGLDisplay *disp,
454 _EGLSurface *surf, EGLint attribute,
455 EGLint *value)
456 {
457 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
458 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
459 int x, y, w, h;
460
461 __DRIdrawable *drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
462
463 switch (attribute) {
464 case EGL_WIDTH:
465 case EGL_HEIGHT:
466 if (x11_get_drawable_info(drawable, &x, &y, &w, &h, dri2_surf)) {
467 surf->Width = w;
468 surf->Height = h;
469 }
470 break;
471 default:
472 break;
473 }
474 return _eglQuerySurface(drv, disp, surf, attribute, value);
475 }
476
477 /**
478 * Process list of buffer received from the server
479 *
480 * Processes the list of buffers received in a reply from the server to either
481 * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
482 */
483 static void
484 dri2_x11_process_buffers(struct dri2_egl_surface *dri2_surf,
485 xcb_dri2_dri2_buffer_t *buffers, unsigned count)
486 {
487 struct dri2_egl_display *dri2_dpy =
488 dri2_egl_display(dri2_surf->base.Resource.Display);
489 xcb_rectangle_t rectangle;
490
491 dri2_surf->have_fake_front = false;
492
493 /* This assumes the DRI2 buffer attachment tokens matches the
494 * __DRIbuffer tokens. */
495 for (unsigned i = 0; i < count; i++) {
496 dri2_surf->buffers[i].attachment = buffers[i].attachment;
497 dri2_surf->buffers[i].name = buffers[i].name;
498 dri2_surf->buffers[i].pitch = buffers[i].pitch;
499 dri2_surf->buffers[i].cpp = buffers[i].cpp;
500 dri2_surf->buffers[i].flags = buffers[i].flags;
501
502 /* We only use the DRI drivers single buffer configs. This
503 * means that if we try to render to a window, DRI2 will give us
504 * the fake front buffer, which we'll use as a back buffer.
505 * Note that EGL doesn't require that several clients rendering
506 * to the same window must see the same aux buffers. */
507 if (dri2_surf->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
508 dri2_surf->have_fake_front = true;
509 }
510
511 if (dri2_surf->region != XCB_NONE)
512 xcb_xfixes_destroy_region(dri2_dpy->conn, dri2_surf->region);
513
514 rectangle.x = 0;
515 rectangle.y = 0;
516 rectangle.width = dri2_surf->base.Width;
517 rectangle.height = dri2_surf->base.Height;
518 dri2_surf->region = xcb_generate_id(dri2_dpy->conn);
519 xcb_xfixes_create_region(dri2_dpy->conn, dri2_surf->region, 1, &rectangle);
520 }
521
522 static __DRIbuffer *
523 dri2_x11_get_buffers(__DRIdrawable * driDrawable,
524 int *width, int *height,
525 unsigned int *attachments, int count,
526 int *out_count, void *loaderPrivate)
527 {
528 struct dri2_egl_surface *dri2_surf = loaderPrivate;
529 struct dri2_egl_display *dri2_dpy =
530 dri2_egl_display(dri2_surf->base.Resource.Display);
531 xcb_dri2_dri2_buffer_t *buffers;
532 xcb_dri2_get_buffers_reply_t *reply;
533 xcb_dri2_get_buffers_cookie_t cookie;
534
535 (void) driDrawable;
536
537 cookie = xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
538 dri2_surf->drawable,
539 count, count, attachments);
540 reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn, cookie, NULL);
541 if (reply == NULL)
542 return NULL;
543 buffers = xcb_dri2_get_buffers_buffers (reply);
544 if (buffers == NULL)
545 return NULL;
546
547 *out_count = reply->count;
548 dri2_surf->base.Width = *width = reply->width;
549 dri2_surf->base.Height = *height = reply->height;
550 dri2_x11_process_buffers(dri2_surf, buffers, *out_count);
551
552 free(reply);
553
554 return dri2_surf->buffers;
555 }
556
557 static __DRIbuffer *
558 dri2_x11_get_buffers_with_format(__DRIdrawable * driDrawable,
559 int *width, int *height,
560 unsigned int *attachments, int count,
561 int *out_count, void *loaderPrivate)
562 {
563 struct dri2_egl_surface *dri2_surf = loaderPrivate;
564 struct dri2_egl_display *dri2_dpy =
565 dri2_egl_display(dri2_surf->base.Resource.Display);
566 xcb_dri2_dri2_buffer_t *buffers;
567 xcb_dri2_get_buffers_with_format_reply_t *reply;
568 xcb_dri2_get_buffers_with_format_cookie_t cookie;
569 xcb_dri2_attach_format_t *format_attachments;
570
571 (void) driDrawable;
572
573 format_attachments = (xcb_dri2_attach_format_t *) attachments;
574 cookie = xcb_dri2_get_buffers_with_format_unchecked (dri2_dpy->conn,
575 dri2_surf->drawable,
576 count, count,
577 format_attachments);
578
579 reply = xcb_dri2_get_buffers_with_format_reply (dri2_dpy->conn,
580 cookie, NULL);
581 if (reply == NULL)
582 return NULL;
583
584 buffers = xcb_dri2_get_buffers_with_format_buffers (reply);
585 dri2_surf->base.Width = *width = reply->width;
586 dri2_surf->base.Height = *height = reply->height;
587 *out_count = reply->count;
588 dri2_x11_process_buffers(dri2_surf, buffers, *out_count);
589
590 free(reply);
591
592 return dri2_surf->buffers;
593 }
594
595 static void
596 dri2_x11_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
597 {
598 (void) driDrawable;
599
600 /* FIXME: Does EGL support front buffer rendering at all? */
601
602 #if 0
603 struct dri2_egl_surface *dri2_surf = loaderPrivate;
604
605 dri2WaitGL(dri2_surf);
606 #else
607 (void) loaderPrivate;
608 #endif
609 }
610
611 static int
612 dri2_x11_do_authenticate(struct dri2_egl_display *dri2_dpy, uint32_t id)
613 {
614 xcb_dri2_authenticate_reply_t *authenticate;
615 xcb_dri2_authenticate_cookie_t authenticate_cookie;
616 int ret = 0;
617
618 authenticate_cookie =
619 xcb_dri2_authenticate_unchecked(dri2_dpy->conn, dri2_dpy->screen->root, id);
620 authenticate =
621 xcb_dri2_authenticate_reply(dri2_dpy->conn, authenticate_cookie, NULL);
622
623 if (authenticate == NULL || !authenticate->authenticated)
624 ret = -1;
625
626 free(authenticate);
627
628 return ret;
629 }
630
631 static EGLBoolean
632 dri2_x11_local_authenticate(struct dri2_egl_display *dri2_dpy)
633 {
634 #ifdef HAVE_LIBDRM
635 drm_magic_t magic;
636
637 if (drmGetMagic(dri2_dpy->fd, &magic)) {
638 _eglLog(_EGL_WARNING, "DRI2: failed to get drm magic");
639 return EGL_FALSE;
640 }
641
642 if (dri2_x11_do_authenticate(dri2_dpy, magic) < 0) {
643 _eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
644 return EGL_FALSE;
645 }
646 #endif
647 return EGL_TRUE;
648 }
649
650 static EGLBoolean
651 dri2_x11_connect(struct dri2_egl_display *dri2_dpy)
652 {
653 xcb_xfixes_query_version_reply_t *xfixes_query;
654 xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
655 xcb_dri2_query_version_reply_t *dri2_query;
656 xcb_dri2_query_version_cookie_t dri2_query_cookie;
657 xcb_dri2_connect_reply_t *connect;
658 xcb_dri2_connect_cookie_t connect_cookie;
659 xcb_generic_error_t *error;
660 char *driver_name, *loader_driver_name, *device_name;
661 const xcb_query_extension_reply_t *extension;
662
663 xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
664 xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
665
666 extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_xfixes_id);
667 if (!(extension && extension->present))
668 return EGL_FALSE;
669
670 extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_dri2_id);
671 if (!(extension && extension->present))
672 return EGL_FALSE;
673
674 xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
675 XCB_XFIXES_MAJOR_VERSION,
676 XCB_XFIXES_MINOR_VERSION);
677
678 dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
679 XCB_DRI2_MAJOR_VERSION,
680 XCB_DRI2_MINOR_VERSION);
681
682 connect_cookie = xcb_dri2_connect_unchecked(dri2_dpy->conn, dri2_dpy->screen->root,
683 XCB_DRI2_DRIVER_TYPE_DRI);
684
685 xfixes_query =
686 xcb_xfixes_query_version_reply (dri2_dpy->conn,
687 xfixes_query_cookie, &error);
688 if (xfixes_query == NULL ||
689 error != NULL || xfixes_query->major_version < 2) {
690 _eglLog(_EGL_WARNING, "DRI2: failed to query xfixes version");
691 free(error);
692 free(xfixes_query);
693 return EGL_FALSE;
694 }
695 free(xfixes_query);
696
697 dri2_query =
698 xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
699 if (dri2_query == NULL || error != NULL) {
700 _eglLog(_EGL_WARNING, "DRI2: failed to query version");
701 free(error);
702 return EGL_FALSE;
703 }
704 dri2_dpy->dri2_major = dri2_query->major_version;
705 dri2_dpy->dri2_minor = dri2_query->minor_version;
706 free(dri2_query);
707
708 connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
709 if (connect == NULL ||
710 connect->driver_name_length + connect->device_name_length == 0) {
711 _eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
712 return EGL_FALSE;
713 }
714
715 device_name = xcb_dri2_connect_device_name (connect);
716
717 dri2_dpy->fd = loader_open_device(device_name);
718 if (dri2_dpy->fd == -1) {
719 _eglLog(_EGL_WARNING,
720 "DRI2: could not open %s (%s)", device_name, strerror(errno));
721 free(connect);
722 return EGL_FALSE;
723 }
724
725 if (!dri2_x11_local_authenticate(dri2_dpy)) {
726 close(dri2_dpy->fd);
727 free(connect);
728 return EGL_FALSE;
729 }
730
731 driver_name = xcb_dri2_connect_driver_name (connect);
732
733 /* If Mesa knows about the appropriate driver for this fd, then trust it.
734 * Otherwise, default to the server's value.
735 */
736 loader_driver_name = loader_get_driver_for_fd(dri2_dpy->fd);
737 if (loader_driver_name) {
738 dri2_dpy->driver_name = loader_driver_name;
739 } else {
740 dri2_dpy->driver_name =
741 strndup(driver_name,
742 xcb_dri2_connect_driver_name_length(connect));
743 }
744
745 if (dri2_dpy->driver_name == NULL) {
746 close(dri2_dpy->fd);
747 free(connect);
748 return EGL_FALSE;
749 }
750
751 #ifdef HAVE_WAYLAND_PLATFORM
752 dri2_dpy->device_name =
753 strndup(device_name,
754 xcb_dri2_connect_device_name_length(connect));
755 #endif
756
757 free(connect);
758
759 return EGL_TRUE;
760 }
761
762 static int
763 dri2_x11_authenticate(_EGLDisplay *disp, uint32_t id)
764 {
765 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
766
767 return dri2_x11_do_authenticate(dri2_dpy, id);
768 }
769
770 static bool
771 dri2_x11_config_match_attrib(struct dri2_egl_display *dri2_dpy,
772 const __DRIconfig *config,
773 unsigned int attrib,
774 unsigned int value)
775 {
776 uint32_t config_val;
777 if (!dri2_dpy->core->getConfigAttrib(config, attrib, &config_val))
778 return false;
779 return config_val == value;
780 }
781
782 static EGLBoolean
783 dri2_x11_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
784 _EGLDisplay *disp, bool supports_preserved)
785 {
786 xcb_depth_iterator_t d;
787 xcb_visualtype_t *visuals;
788 int config_count = 0;
789 EGLint surface_type;
790
791 d = xcb_screen_allowed_depths_iterator(dri2_dpy->screen);
792
793 surface_type =
794 EGL_WINDOW_BIT |
795 EGL_PIXMAP_BIT |
796 EGL_PBUFFER_BIT;
797
798 if (supports_preserved)
799 surface_type |= EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
800
801 while (d.rem > 0) {
802 EGLBoolean class_added[6] = { 0, };
803
804 visuals = xcb_depth_visuals(d.data);
805
806 for (int i = 0; i < xcb_depth_visuals_length(d.data); i++) {
807 if (class_added[visuals[i]._class])
808 continue;
809
810 class_added[visuals[i]._class] = EGL_TRUE;
811
812 for (int j = 0; dri2_dpy->driver_configs[j]; j++) {
813 struct dri2_egl_config *dri2_conf;
814 const __DRIconfig *config = dri2_dpy->driver_configs[j];
815
816 const EGLint config_attrs[] = {
817 EGL_NATIVE_VISUAL_ID, visuals[i].visual_id,
818 EGL_NATIVE_VISUAL_TYPE, visuals[i]._class,
819 EGL_NONE
820 };
821
822 unsigned int rgba_masks[4] = {
823 visuals[i].red_mask,
824 visuals[i].green_mask,
825 visuals[i].blue_mask,
826 0,
827 };
828
829 dri2_conf = dri2_add_config(disp, config, config_count + 1,
830 surface_type, config_attrs,
831 rgba_masks);
832 if (dri2_conf)
833 if (dri2_conf->base.ConfigID == config_count + 1)
834 config_count++;
835
836 /* Allow a 24-bit RGB visual to match a 32-bit RGBA EGLConfig.
837 * Ditto for 30-bit RGB visuals to match a 32-bit RGBA EGLConfig.
838 * Otherwise it will only match a 32-bit RGBA visual. On a
839 * composited window manager on X11, this will make all of the
840 * EGLConfigs with destination alpha get blended by the
841 * compositor. This is probably not what the application
842 * wants... especially on drivers that only have 32-bit RGBA
843 * EGLConfigs! */
844 if (d.data->depth == 24 || d.data->depth == 30) {
845 rgba_masks[3] =
846 ~(rgba_masks[0] | rgba_masks[1] | rgba_masks[2]);
847 dri2_conf = dri2_add_config(disp, config, config_count + 1,
848 surface_type, config_attrs,
849 rgba_masks);
850 if (dri2_conf)
851 if (dri2_conf->base.ConfigID == config_count + 1)
852 config_count++;
853 }
854 }
855 }
856
857 xcb_depth_next(&d);
858 }
859
860 /* Add a 565-no-depth-no-stencil pbuffer-only config. If X11 is depth 24,
861 * we wouldn't have 565 available, which the CTS demands.
862 */
863 for (int j = 0; dri2_dpy->driver_configs[j]; j++) {
864 const __DRIconfig *config = dri2_dpy->driver_configs[j];
865 const EGLint config_attrs[] = {
866 EGL_NATIVE_VISUAL_ID, 0,
867 EGL_NATIVE_VISUAL_TYPE, EGL_NONE,
868 EGL_NONE
869 };
870 EGLint surface_type = EGL_PBUFFER_BIT;
871 unsigned int rgba_masks[4] = {
872 0x1f << 11,
873 0x3f << 5,
874 0x1f << 0,
875 0,
876 };
877
878 /* Check that we've found single-sample, no depth, no stencil. */
879 if (!dri2_x11_config_match_attrib(dri2_dpy, config,
880 __DRI_ATTRIB_DEPTH_SIZE, 0) ||
881 !dri2_x11_config_match_attrib(dri2_dpy, config,
882 __DRI_ATTRIB_STENCIL_SIZE, 0) ||
883 !dri2_x11_config_match_attrib(dri2_dpy, config,
884 __DRI_ATTRIB_SAMPLES, 0)) {
885 continue;
886 }
887
888 if (dri2_add_config(disp, config, config_count + 1, surface_type,
889 config_attrs, rgba_masks)) {
890 config_count++;
891 break;
892 }
893 }
894
895 if (!config_count) {
896 _eglLog(_EGL_WARNING, "DRI2: failed to create any config");
897 return EGL_FALSE;
898 }
899
900 return EGL_TRUE;
901 }
902
903 static EGLBoolean
904 dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp,
905 _EGLSurface *draw, xcb_xfixes_region_t region)
906 {
907 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
908 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
909 enum xcb_dri2_attachment_t render_attachment;
910 xcb_dri2_copy_region_cookie_t cookie;
911
912 /* No-op for a pixmap or pbuffer surface */
913 if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT)
914 return EGL_TRUE;
915
916 dri2_dpy->flush->flush(dri2_surf->dri_drawable);
917
918 if (dri2_surf->have_fake_front)
919 render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT;
920 else
921 render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT;
922
923 cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
924 dri2_surf->drawable,
925 region,
926 XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
927 render_attachment);
928 free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
929
930 return EGL_TRUE;
931 }
932
933 static int64_t
934 dri2_x11_swap_buffers_msc(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
935 int64_t msc, int64_t divisor, int64_t remainder)
936 {
937 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
938 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
939 uint32_t msc_hi = msc >> 32;
940 uint32_t msc_lo = msc & 0xffffffff;
941 uint32_t divisor_hi = divisor >> 32;
942 uint32_t divisor_lo = divisor & 0xffffffff;
943 uint32_t remainder_hi = remainder >> 32;
944 uint32_t remainder_lo = remainder & 0xffffffff;
945 xcb_dri2_swap_buffers_cookie_t cookie;
946 xcb_dri2_swap_buffers_reply_t *reply;
947 int64_t swap_count = -1;
948
949 if (draw->SwapBehavior == EGL_BUFFER_PRESERVED || !dri2_dpy->swap_available) {
950 swap_count = dri2_copy_region(drv, disp, draw, dri2_surf->region) ? 0 : -1;
951 } else {
952 dri2_flush_drawable_for_swapbuffers(disp, draw);
953
954 cookie = xcb_dri2_swap_buffers_unchecked(dri2_dpy->conn,
955 dri2_surf->drawable, msc_hi,
956 msc_lo, divisor_hi, divisor_lo,
957 remainder_hi, remainder_lo);
958
959 reply = xcb_dri2_swap_buffers_reply(dri2_dpy->conn, cookie, NULL);
960
961 if (reply) {
962 swap_count = combine_u32_into_u64(reply->swap_hi, reply->swap_lo);
963 free(reply);
964 }
965 }
966
967 /* Since we aren't watching for the server's invalidate events like we're
968 * supposed to (due to XCB providing no mechanism for filtering the events
969 * the way xlib does), and SwapBuffers is a common cause of invalidate
970 * events, just shove one down to the driver, even though we haven't told
971 * the driver that we're the kind of loader that provides reliable
972 * invalidate events. This causes the driver to request buffers again at
973 * its next draw, so that we get the correct buffers if a pageflip
974 * happened. The driver should still be using the viewport hack to catch
975 * window resizes.
976 */
977 if (dri2_dpy->flush->base.version >= 3 && dri2_dpy->flush->invalidate)
978 dri2_dpy->flush->invalidate(dri2_surf->dri_drawable);
979
980 return swap_count;
981 }
982
983 static EGLBoolean
984 dri2_x11_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
985 {
986 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
987 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
988
989 if (!dri2_dpy->flush) {
990 dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
991 return EGL_TRUE;
992 }
993
994 if (dri2_x11_swap_buffers_msc(drv, disp, draw, 0, 0, 0) == -1) {
995 /* Swap failed with a window drawable. */
996 return _eglError(EGL_BAD_NATIVE_WINDOW, __func__);
997 }
998 return EGL_TRUE;
999 }
1000
1001 static EGLBoolean
1002 dri2_x11_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp,
1003 _EGLSurface *draw,
1004 EGLint numRects, const EGLint *rects)
1005 {
1006 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1007 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1008 EGLBoolean ret;
1009 xcb_xfixes_region_t region;
1010 xcb_rectangle_t rectangles[16];
1011
1012 if (numRects > (int)ARRAY_SIZE(rectangles))
1013 return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1014
1015 for (int i = 0; i < numRects; i++) {
1016 rectangles[i].x = rects[i * 4];
1017 rectangles[i].y = dri2_surf->base.Height - rects[i * 4 + 1] - rects[i * 4 + 3];
1018 rectangles[i].width = rects[i * 4 + 2];
1019 rectangles[i].height = rects[i * 4 + 3];
1020 }
1021
1022 region = xcb_generate_id(dri2_dpy->conn);
1023 xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
1024 ret = dri2_copy_region(drv, disp, draw, region);
1025 xcb_xfixes_destroy_region(dri2_dpy->conn, region);
1026
1027 return ret;
1028 }
1029
1030 static EGLBoolean
1031 dri2_x11_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
1032 EGLint x, EGLint y, EGLint width, EGLint height)
1033 {
1034 const EGLint rect[4] = { x, y, width, height };
1035
1036 if (x < 0 || y < 0 || width < 0 || height < 0)
1037 _eglError(EGL_BAD_PARAMETER, "eglPostSubBufferNV");
1038
1039 return dri2_x11_swap_buffers_region(drv, disp, draw, 1, rect);
1040 }
1041
1042 static EGLBoolean
1043 dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1044 EGLint interval)
1045 {
1046 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1047 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1048
1049 if (dri2_dpy->swap_available)
1050 xcb_dri2_swap_interval(dri2_dpy->conn, dri2_surf->drawable, interval);
1051
1052 return EGL_TRUE;
1053 }
1054
1055 static EGLBoolean
1056 dri2_x11_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1057 void *native_pixmap_target)
1058 {
1059 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1060 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1061 xcb_gcontext_t gc;
1062 xcb_pixmap_t target;
1063
1064 STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_pixmap_target));
1065 target = (uintptr_t) native_pixmap_target;
1066
1067 (void) drv;
1068
1069 dri2_dpy->flush->flush(dri2_surf->dri_drawable);
1070
1071 gc = xcb_generate_id(dri2_dpy->conn);
1072 xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
1073 xcb_copy_area(dri2_dpy->conn,
1074 dri2_surf->drawable,
1075 target,
1076 gc,
1077 0, 0,
1078 0, 0,
1079 dri2_surf->base.Width,
1080 dri2_surf->base.Height);
1081 xcb_free_gc(dri2_dpy->conn, gc);
1082
1083 return EGL_TRUE;
1084 }
1085
1086 uint32_t
1087 dri2_format_for_depth(struct dri2_egl_display *dri2_dpy, uint32_t depth)
1088 {
1089 switch (depth) {
1090 case 16:
1091 return __DRI_IMAGE_FORMAT_RGB565;
1092 case 24:
1093 return __DRI_IMAGE_FORMAT_XRGB8888;
1094 case 30:
1095 /* Different preferred formats for different hw */
1096 if (dri2_x11_get_red_mask_for_depth(dri2_dpy, 30) == 0x3ff)
1097 return __DRI_IMAGE_FORMAT_XBGR2101010;
1098 else
1099 return __DRI_IMAGE_FORMAT_XRGB2101010;
1100 case 32:
1101 return __DRI_IMAGE_FORMAT_ARGB8888;
1102 default:
1103 return __DRI_IMAGE_FORMAT_NONE;
1104 }
1105 }
1106
1107 static _EGLImage *
1108 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
1109 EGLClientBuffer buffer, const EGLint *attr_list)
1110 {
1111 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1112 struct dri2_egl_image *dri2_img;
1113 unsigned int attachments[1];
1114 xcb_drawable_t drawable;
1115 xcb_dri2_get_buffers_cookie_t buffers_cookie;
1116 xcb_dri2_get_buffers_reply_t *buffers_reply;
1117 xcb_dri2_dri2_buffer_t *buffers;
1118 xcb_get_geometry_cookie_t geometry_cookie;
1119 xcb_get_geometry_reply_t *geometry_reply;
1120 xcb_generic_error_t *error;
1121 int stride, format;
1122
1123 (void) ctx;
1124
1125 drawable = (xcb_drawable_t) (uintptr_t) buffer;
1126 xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
1127 attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
1128 buffers_cookie =
1129 xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
1130 drawable, 1, 1, attachments);
1131 geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
1132 buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
1133 buffers_cookie, NULL);
1134 if (buffers_reply == NULL)
1135 return NULL;
1136
1137 buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
1138 if (buffers == NULL) {
1139 return NULL;
1140 }
1141
1142 geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
1143 geometry_cookie, &error);
1144 if (geometry_reply == NULL || error != NULL) {
1145 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1146 free(error);
1147 free(buffers_reply);
1148 return NULL;
1149 }
1150
1151 format = dri2_format_for_depth(dri2_dpy, geometry_reply->depth);
1152 if (format == __DRI_IMAGE_FORMAT_NONE) {
1153 _eglError(EGL_BAD_PARAMETER,
1154 "dri2_create_image_khr: unsupported pixmap depth");
1155 free(buffers_reply);
1156 free(geometry_reply);
1157 return NULL;
1158 }
1159
1160 dri2_img = malloc(sizeof *dri2_img);
1161 if (!dri2_img) {
1162 free(buffers_reply);
1163 free(geometry_reply);
1164 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1165 return EGL_NO_IMAGE_KHR;
1166 }
1167
1168 _eglInitImage(&dri2_img->base, disp);
1169
1170 stride = buffers[0].pitch / buffers[0].cpp;
1171 dri2_img->dri_image =
1172 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
1173 buffers_reply->width,
1174 buffers_reply->height,
1175 format,
1176 buffers[0].name,
1177 stride,
1178 dri2_img);
1179
1180 free(buffers_reply);
1181 free(geometry_reply);
1182
1183 return &dri2_img->base;
1184 }
1185
1186 static _EGLImage *
1187 dri2_x11_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
1188 _EGLContext *ctx, EGLenum target,
1189 EGLClientBuffer buffer, const EGLint *attr_list)
1190 {
1191 (void) drv;
1192
1193 switch (target) {
1194 case EGL_NATIVE_PIXMAP_KHR:
1195 return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
1196 default:
1197 return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
1198 }
1199 }
1200
1201 static EGLBoolean
1202 dri2_x11_get_sync_values(_EGLDisplay *display, _EGLSurface *surface,
1203 EGLuint64KHR *ust, EGLuint64KHR *msc,
1204 EGLuint64KHR *sbc)
1205 {
1206 struct dri2_egl_display *dri2_dpy = dri2_egl_display(display);
1207 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
1208 xcb_dri2_get_msc_cookie_t cookie;
1209 xcb_dri2_get_msc_reply_t *reply;
1210
1211 cookie = xcb_dri2_get_msc(dri2_dpy->conn, dri2_surf->drawable);
1212 reply = xcb_dri2_get_msc_reply(dri2_dpy->conn, cookie, NULL);
1213
1214 if (!reply)
1215 return _eglError(EGL_BAD_ACCESS, __func__);
1216
1217 *ust = ((EGLuint64KHR) reply->ust_hi << 32) | reply->ust_lo;
1218 *msc = ((EGLuint64KHR) reply->msc_hi << 32) | reply->msc_lo;
1219 *sbc = ((EGLuint64KHR) reply->sbc_hi << 32) | reply->sbc_lo;
1220 free(reply);
1221
1222 return EGL_TRUE;
1223 }
1224
1225 static const struct dri2_egl_display_vtbl dri2_x11_swrast_display_vtbl = {
1226 .authenticate = NULL,
1227 .create_window_surface = dri2_x11_create_window_surface,
1228 .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1229 .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1230 .destroy_surface = dri2_x11_destroy_surface,
1231 .create_image = dri2_create_image_khr,
1232 .swap_buffers = dri2_x11_swap_buffers,
1233 .set_damage_region = dri2_fallback_set_damage_region,
1234 .swap_buffers_region = dri2_fallback_swap_buffers_region,
1235 .post_sub_buffer = dri2_fallback_post_sub_buffer,
1236 /* XXX: should really implement this since X11 has pixmaps */
1237 .copy_buffers = dri2_fallback_copy_buffers,
1238 .query_buffer_age = dri2_fallback_query_buffer_age,
1239 .query_surface = dri2_query_surface,
1240 .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1241 .get_sync_values = dri2_fallback_get_sync_values,
1242 .get_dri_drawable = dri2_surface_get_dri_drawable,
1243 };
1244
1245 static const struct dri2_egl_display_vtbl dri2_x11_display_vtbl = {
1246 .authenticate = dri2_x11_authenticate,
1247 .create_window_surface = dri2_x11_create_window_surface,
1248 .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1249 .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1250 .destroy_surface = dri2_x11_destroy_surface,
1251 .create_image = dri2_x11_create_image_khr,
1252 .swap_interval = dri2_x11_swap_interval,
1253 .swap_buffers = dri2_x11_swap_buffers,
1254 .swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage,
1255 .swap_buffers_region = dri2_x11_swap_buffers_region,
1256 .set_damage_region = dri2_fallback_set_damage_region,
1257 .post_sub_buffer = dri2_x11_post_sub_buffer,
1258 .copy_buffers = dri2_x11_copy_buffers,
1259 .query_buffer_age = dri2_fallback_query_buffer_age,
1260 .query_surface = dri2_query_surface,
1261 .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1262 .get_sync_values = dri2_x11_get_sync_values,
1263 .get_dri_drawable = dri2_surface_get_dri_drawable,
1264 };
1265
1266 static const __DRIswrastLoaderExtension swrast_loader_extension = {
1267 .base = { __DRI_SWRAST_LOADER, 1 },
1268
1269 .getDrawableInfo = swrastGetDrawableInfo,
1270 .putImage = swrastPutImage,
1271 .getImage = swrastGetImage,
1272 };
1273
1274 static const __DRIextension *swrast_loader_extensions[] = {
1275 &swrast_loader_extension.base,
1276 &image_lookup_extension.base,
1277 NULL,
1278 };
1279
1280 static int
1281 dri2_find_screen_for_display(const _EGLDisplay *disp, int fallback_screen)
1282 {
1283 const EGLAttrib *attr;
1284
1285 for (attr = disp->Options.Attribs; attr; attr += 2) {
1286 if (attr[0] == EGL_PLATFORM_X11_SCREEN_EXT)
1287 return attr[1];
1288 }
1289
1290 return fallback_screen;
1291 }
1292
1293 static EGLBoolean
1294 dri2_get_xcb_connection(_EGLDriver *drv, _EGLDisplay *disp,
1295 struct dri2_egl_display *dri2_dpy)
1296 {
1297 xcb_screen_iterator_t s;
1298 int screen;
1299 const char *msg;
1300
1301 disp->DriverData = (void *) dri2_dpy;
1302 if (disp->PlatformDisplay == NULL) {
1303 dri2_dpy->conn = xcb_connect(NULL, &screen);
1304 dri2_dpy->own_device = true;
1305 screen = dri2_find_screen_for_display(disp, screen);
1306 } else {
1307 Display *dpy = disp->PlatformDisplay;
1308 dri2_dpy->conn = XGetXCBConnection(dpy);
1309 screen = DefaultScreen(dpy);
1310 }
1311
1312 if (!dri2_dpy->conn || xcb_connection_has_error(dri2_dpy->conn)) {
1313 msg = "xcb_connect failed";
1314 goto disconnect;
1315 }
1316
1317 s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
1318 dri2_dpy->screen = get_xcb_screen(s, screen);
1319 if (!dri2_dpy->screen) {
1320 msg = "failed to get xcb screen";
1321 goto disconnect;
1322 }
1323
1324 return EGL_TRUE;
1325 disconnect:
1326 if (disp->PlatformDisplay == NULL)
1327 xcb_disconnect(dri2_dpy->conn);
1328
1329 return _eglError(EGL_BAD_ALLOC, msg);
1330 }
1331
1332 static EGLBoolean
1333 dri2_initialize_x11_swrast(_EGLDriver *drv, _EGLDisplay *disp)
1334 {
1335 _EGLDevice *dev;
1336 struct dri2_egl_display *dri2_dpy;
1337
1338 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1339 if (!dri2_dpy)
1340 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1341
1342 dri2_dpy->fd = -1;
1343 if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1344 goto cleanup;
1345
1346 dev = _eglAddDevice(dri2_dpy->fd, true);
1347 if (!dev) {
1348 _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1349 goto cleanup;
1350 }
1351
1352 disp->Device = dev;
1353
1354 /*
1355 * Every hardware driver_name is set using strdup. Doing the same in
1356 * here will allow is to simply free the memory at dri2_terminate().
1357 */
1358 dri2_dpy->driver_name = strdup("swrast");
1359 if (!dri2_load_driver_swrast(disp))
1360 goto cleanup;
1361
1362 dri2_dpy->loader_extensions = swrast_loader_extensions;
1363
1364 if (!dri2_create_screen(disp))
1365 goto cleanup;
1366
1367 if (!dri2_setup_extensions(disp))
1368 goto cleanup;
1369
1370 dri2_setup_screen(disp);
1371
1372 if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, true))
1373 goto cleanup;
1374
1375 /* Fill vtbl last to prevent accidentally calling virtual function during
1376 * initialization.
1377 */
1378 dri2_dpy->vtbl = &dri2_x11_swrast_display_vtbl;
1379
1380 return EGL_TRUE;
1381
1382 cleanup:
1383 dri2_display_destroy(disp);
1384 return EGL_FALSE;
1385 }
1386
1387 static void
1388 dri2_x11_setup_swap_interval(_EGLDisplay *disp)
1389 {
1390 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1391 int arbitrary_max_interval = 1000;
1392
1393 /* default behavior for no SwapBuffers support: no vblank syncing
1394 * either.
1395 */
1396 dri2_dpy->min_swap_interval = 0;
1397 dri2_dpy->max_swap_interval = 0;
1398 dri2_dpy->default_swap_interval = 0;
1399
1400 if (!dri2_dpy->swap_available)
1401 return;
1402
1403 /* If we do have swapbuffers, then we can support pretty much any swap
1404 * interval.
1405 */
1406 dri2_setup_swap_interval(disp, arbitrary_max_interval);
1407 }
1408
1409 #ifdef HAVE_DRI3
1410
1411 static const __DRIextension *dri3_image_loader_extensions[] = {
1412 &dri3_image_loader_extension.base,
1413 &image_lookup_extension.base,
1414 &use_invalidate.base,
1415 &background_callable_extension.base,
1416 NULL,
1417 };
1418
1419 static EGLBoolean
1420 dri2_initialize_x11_dri3(_EGLDriver *drv, _EGLDisplay *disp)
1421 {
1422 _EGLDevice *dev;
1423 struct dri2_egl_display *dri2_dpy;
1424
1425 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1426 if (!dri2_dpy)
1427 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1428
1429 dri2_dpy->fd = -1;
1430 if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1431 goto cleanup;
1432
1433 if (!dri3_x11_connect(dri2_dpy))
1434 goto cleanup;
1435
1436 dev = _eglAddDevice(dri2_dpy->fd, false);
1437 if (!dev) {
1438 _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1439 goto cleanup;
1440 }
1441
1442 disp->Device = dev;
1443
1444 if (!dri2_load_driver_dri3(disp))
1445 goto cleanup;
1446
1447 dri2_dpy->loader_extensions = dri3_image_loader_extensions;
1448
1449 dri2_dpy->swap_available = true;
1450 dri2_dpy->invalidate_available = true;
1451
1452 if (!dri2_create_screen(disp))
1453 goto cleanup;
1454
1455 if (!dri2_setup_extensions(disp))
1456 goto cleanup;
1457
1458 dri2_setup_screen(disp);
1459
1460 dri2_x11_setup_swap_interval(disp);
1461
1462 if (!dri2_dpy->is_different_gpu)
1463 disp->Extensions.KHR_image_pixmap = EGL_TRUE;
1464 disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
1465 disp->Extensions.CHROMIUM_sync_control = EGL_TRUE;
1466 disp->Extensions.EXT_buffer_age = EGL_TRUE;
1467
1468 dri2_set_WL_bind_wayland_display(drv, disp);
1469
1470 if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, false))
1471 goto cleanup;
1472
1473 dri2_dpy->loader_dri3_ext.core = dri2_dpy->core;
1474 dri2_dpy->loader_dri3_ext.image_driver = dri2_dpy->image_driver;
1475 dri2_dpy->loader_dri3_ext.flush = dri2_dpy->flush;
1476 dri2_dpy->loader_dri3_ext.tex_buffer = dri2_dpy->tex_buffer;
1477 dri2_dpy->loader_dri3_ext.image = dri2_dpy->image;
1478 dri2_dpy->loader_dri3_ext.config = dri2_dpy->config;
1479
1480 /* Fill vtbl last to prevent accidentally calling virtual function during
1481 * initialization.
1482 */
1483 dri2_dpy->vtbl = &dri3_x11_display_vtbl;
1484
1485 _eglLog(_EGL_INFO, "Using DRI3");
1486
1487 return EGL_TRUE;
1488
1489 cleanup:
1490 dri2_display_destroy(disp);
1491 return EGL_FALSE;
1492 }
1493 #endif
1494
1495 static const __DRIdri2LoaderExtension dri2_loader_extension_old = {
1496 .base = { __DRI_DRI2_LOADER, 2 },
1497
1498 .getBuffers = dri2_x11_get_buffers,
1499 .flushFrontBuffer = dri2_x11_flush_front_buffer,
1500 .getBuffersWithFormat = NULL,
1501 };
1502
1503 static const __DRIdri2LoaderExtension dri2_loader_extension = {
1504 .base = { __DRI_DRI2_LOADER, 3 },
1505
1506 .getBuffers = dri2_x11_get_buffers,
1507 .flushFrontBuffer = dri2_x11_flush_front_buffer,
1508 .getBuffersWithFormat = dri2_x11_get_buffers_with_format,
1509 };
1510
1511 static const __DRIextension *dri2_loader_extensions_old[] = {
1512 &dri2_loader_extension_old.base,
1513 &image_lookup_extension.base,
1514 &background_callable_extension.base,
1515 NULL,
1516 };
1517
1518 static const __DRIextension *dri2_loader_extensions[] = {
1519 &dri2_loader_extension.base,
1520 &image_lookup_extension.base,
1521 &use_invalidate.base,
1522 &background_callable_extension.base,
1523 NULL,
1524 };
1525
1526 static EGLBoolean
1527 dri2_initialize_x11_dri2(_EGLDriver *drv, _EGLDisplay *disp)
1528 {
1529 _EGLDevice *dev;
1530 struct dri2_egl_display *dri2_dpy;
1531
1532 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1533 if (!dri2_dpy)
1534 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1535
1536 dri2_dpy->fd = -1;
1537 if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1538 goto cleanup;
1539
1540 if (!dri2_x11_connect(dri2_dpy))
1541 goto cleanup;
1542
1543 dev = _eglAddDevice(dri2_dpy->fd, false);
1544 if (!dev) {
1545 _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1546 goto cleanup;
1547 }
1548
1549 disp->Device = dev;
1550
1551 if (!dri2_load_driver(disp))
1552 goto cleanup;
1553
1554 if (dri2_dpy->dri2_minor >= 1)
1555 dri2_dpy->loader_extensions = dri2_loader_extensions;
1556 else
1557 dri2_dpy->loader_extensions = dri2_loader_extensions_old;
1558
1559 dri2_dpy->swap_available = (dri2_dpy->dri2_minor >= 2);
1560 dri2_dpy->invalidate_available = (dri2_dpy->dri2_minor >= 3);
1561
1562 if (!dri2_create_screen(disp))
1563 goto cleanup;
1564
1565 if (!dri2_setup_extensions(disp))
1566 goto cleanup;
1567
1568 dri2_setup_screen(disp);
1569
1570 dri2_x11_setup_swap_interval(disp);
1571
1572 disp->Extensions.KHR_image_pixmap = EGL_TRUE;
1573 disp->Extensions.NOK_swap_region = EGL_TRUE;
1574 disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
1575 disp->Extensions.NV_post_sub_buffer = EGL_TRUE;
1576 disp->Extensions.CHROMIUM_sync_control = EGL_TRUE;
1577
1578 dri2_set_WL_bind_wayland_display(drv, disp);
1579
1580 if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, true))
1581 goto cleanup;
1582
1583 /* Fill vtbl last to prevent accidentally calling virtual function during
1584 * initialization.
1585 */
1586 dri2_dpy->vtbl = &dri2_x11_display_vtbl;
1587
1588 _eglLog(_EGL_INFO, "Using DRI2");
1589
1590 return EGL_TRUE;
1591
1592 cleanup:
1593 dri2_display_destroy(disp);
1594 return EGL_FALSE;
1595 }
1596
1597 EGLBoolean
1598 dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp)
1599 {
1600 EGLBoolean initialized = EGL_FALSE;
1601
1602 if (!disp->Options.ForceSoftware) {
1603 #ifdef HAVE_DRI3
1604 if (!env_var_as_boolean("LIBGL_DRI3_DISABLE", false))
1605 initialized = dri2_initialize_x11_dri3(drv, disp);
1606 #endif
1607
1608 if (!initialized)
1609 initialized = dri2_initialize_x11_dri2(drv, disp);
1610 }
1611
1612 if (!initialized)
1613 initialized = dri2_initialize_x11_swrast(drv, disp);
1614
1615 return initialized;
1616 }
1617
1618 void
1619 dri2_teardown_x11(struct dri2_egl_display *dri2_dpy)
1620 {
1621 if (dri2_dpy->own_device)
1622 xcb_disconnect(dri2_dpy->conn);
1623 }