projects / mesa.git / blob
? search:


9d3e4484c53df5920f56c7594fcfa6009c04ebd7
[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 #include "util/bitscan.h"
46
47 #include "egl_dri2.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(const _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->CreateWindowSurface().
248 */
249 static _EGLSurface *
250 dri2_x11_create_surface(const _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 = calloc(1, 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_create_drawable(dri2_dpy, config, dri2_surf, dri2_surf))
294 goto cleanup_pixmap;
295
296 if (type != EGL_PBUFFER_BIT) {
297 cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
298 reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
299 if (error != NULL) {
300 if (error->error_code == BadAlloc)
301 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
302 else if (type == EGL_WINDOW_BIT)
303 _eglError(EGL_BAD_NATIVE_WINDOW, "xcb_get_geometry");
304 else
305 _eglError(EGL_BAD_NATIVE_PIXMAP, "xcb_get_geometry");
306 free(error);
307 goto cleanup_dri_drawable;
308 } else if (reply == NULL) {
309 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
310 goto cleanup_dri_drawable;
311 }
312
313 dri2_surf->base.Width = reply->width;
314 dri2_surf->base.Height = reply->height;
315 dri2_surf->depth = reply->depth;
316 free(reply);
317 }
318
319 if (dri2_dpy->dri2) {
320 xcb_void_cookie_t cookie;
321 int conn_error;
322
323 cookie = xcb_dri2_create_drawable_checked(dri2_dpy->conn,
324 dri2_surf->drawable);
325 error = xcb_request_check(dri2_dpy->conn, cookie);
326 conn_error = xcb_connection_has_error(dri2_dpy->conn);
327 if (conn_error || error != NULL) {
328 if (type == EGL_PBUFFER_BIT || conn_error || error->error_code == BadAlloc)
329 _eglError(EGL_BAD_ALLOC, "xcb_dri2_create_drawable_checked");
330 else if (type == EGL_WINDOW_BIT)
331 _eglError(EGL_BAD_NATIVE_WINDOW,
332 "xcb_dri2_create_drawable_checked");
333 else
334 _eglError(EGL_BAD_NATIVE_PIXMAP,
335 "xcb_dri2_create_drawable_checked");
336 free(error);
337 goto cleanup_dri_drawable;
338 }
339 } else {
340 if (type == EGL_PBUFFER_BIT) {
341 dri2_surf->depth = conf->BufferSize;
342 }
343 swrastCreateDrawable(dri2_dpy, dri2_surf);
344 }
345
346 /* we always copy the back buffer to front */
347 dri2_surf->base.PostSubBufferSupportedNV = EGL_TRUE;
348
349 return &dri2_surf->base;
350
351 cleanup_dri_drawable:
352 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
353 cleanup_pixmap:
354 if (type == EGL_PBUFFER_BIT)
355 xcb_free_pixmap(dri2_dpy->conn, dri2_surf->drawable);
356 cleanup_surf:
357 free(dri2_surf);
358
359 return NULL;
360 }
361
362 /**
363 * Called via eglCreateWindowSurface(), drv->CreateWindowSurface().
364 */
365 static _EGLSurface *
366 dri2_x11_create_window_surface(const _EGLDriver *drv, _EGLDisplay *disp,
367 _EGLConfig *conf, void *native_window,
368 const EGLint *attrib_list)
369 {
370 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
371 _EGLSurface *surf;
372
373 surf = dri2_x11_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
374 native_window, attrib_list);
375 if (surf != NULL) {
376 /* When we first create the DRI2 drawable, its swap interval on the
377 * server side is 1.
378 */
379 surf->SwapInterval = 1;
380
381 /* Override that with a driconf-set value. */
382 dri2_x11_swap_interval(disp->Driver, disp, surf, dri2_dpy->default_swap_interval);
383 }
384
385 return surf;
386 }
387
388 static _EGLSurface *
389 dri2_x11_create_pixmap_surface(const _EGLDriver *drv, _EGLDisplay *disp,
390 _EGLConfig *conf, void *native_pixmap,
391 const EGLint *attrib_list)
392 {
393 return dri2_x11_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
394 native_pixmap, attrib_list);
395 }
396
397 static _EGLSurface *
398 dri2_x11_create_pbuffer_surface(const _EGLDriver *drv, _EGLDisplay *disp,
399 _EGLConfig *conf, const EGLint *attrib_list)
400 {
401 return dri2_x11_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
402 NULL, attrib_list);
403 }
404
405 static EGLBoolean
406 dri2_x11_destroy_surface(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
407 {
408 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
409 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
410
411 (void) drv;
412
413 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
414
415 if (dri2_dpy->dri2) {
416 xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable);
417 } else {
418 assert(dri2_dpy->swrast);
419 swrastDestroyDrawable(dri2_dpy, dri2_surf);
420 }
421
422 if (surf->Type == EGL_PBUFFER_BIT)
423 xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable);
424
425 dri2_fini_surface(surf);
426 free(surf);
427
428 return EGL_TRUE;
429 }
430
431 /**
432 * Function utilizes swrastGetDrawableInfo to get surface
433 * geometry from x server and calls default query surface
434 * implementation that returns the updated values.
435 *
436 * In case of errors we still return values that we currently
437 * have.
438 */
439 static EGLBoolean
440 dri2_query_surface(const _EGLDriver *drv, _EGLDisplay *disp,
441 _EGLSurface *surf, EGLint attribute,
442 EGLint *value)
443 {
444 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
445 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
446 int x, y, w, h;
447
448 __DRIdrawable *drawable = dri2_dpy->vtbl->get_dri_drawable(surf);
449
450 switch (attribute) {
451 case EGL_WIDTH:
452 case EGL_HEIGHT:
453 if (x11_get_drawable_info(drawable, &x, &y, &w, &h, dri2_surf)) {
454 surf->Width = w;
455 surf->Height = h;
456 }
457 break;
458 default:
459 break;
460 }
461 return _eglQuerySurface(drv, disp, surf, attribute, value);
462 }
463
464 /**
465 * Process list of buffer received from the server
466 *
467 * Processes the list of buffers received in a reply from the server to either
468 * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
469 */
470 static void
471 dri2_x11_process_buffers(struct dri2_egl_surface *dri2_surf,
472 xcb_dri2_dri2_buffer_t *buffers, unsigned count)
473 {
474 struct dri2_egl_display *dri2_dpy =
475 dri2_egl_display(dri2_surf->base.Resource.Display);
476 xcb_rectangle_t rectangle;
477
478 dri2_surf->have_fake_front = false;
479
480 /* This assumes the DRI2 buffer attachment tokens matches the
481 * __DRIbuffer tokens. */
482 for (unsigned i = 0; i < count; i++) {
483 dri2_surf->buffers[i].attachment = buffers[i].attachment;
484 dri2_surf->buffers[i].name = buffers[i].name;
485 dri2_surf->buffers[i].pitch = buffers[i].pitch;
486 dri2_surf->buffers[i].cpp = buffers[i].cpp;
487 dri2_surf->buffers[i].flags = buffers[i].flags;
488
489 /* We only use the DRI drivers single buffer configs. This
490 * means that if we try to render to a window, DRI2 will give us
491 * the fake front buffer, which we'll use as a back buffer.
492 * Note that EGL doesn't require that several clients rendering
493 * to the same window must see the same aux buffers. */
494 if (dri2_surf->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
495 dri2_surf->have_fake_front = true;
496 }
497
498 if (dri2_surf->region != XCB_NONE)
499 xcb_xfixes_destroy_region(dri2_dpy->conn, dri2_surf->region);
500
501 rectangle.x = 0;
502 rectangle.y = 0;
503 rectangle.width = dri2_surf->base.Width;
504 rectangle.height = dri2_surf->base.Height;
505 dri2_surf->region = xcb_generate_id(dri2_dpy->conn);
506 xcb_xfixes_create_region(dri2_dpy->conn, dri2_surf->region, 1, &rectangle);
507 }
508
509 static __DRIbuffer *
510 dri2_x11_get_buffers(__DRIdrawable * driDrawable,
511 int *width, int *height,
512 unsigned int *attachments, int count,
513 int *out_count, void *loaderPrivate)
514 {
515 struct dri2_egl_surface *dri2_surf = loaderPrivate;
516 struct dri2_egl_display *dri2_dpy =
517 dri2_egl_display(dri2_surf->base.Resource.Display);
518 xcb_dri2_dri2_buffer_t *buffers;
519 xcb_dri2_get_buffers_reply_t *reply;
520 xcb_dri2_get_buffers_cookie_t cookie;
521
522 (void) driDrawable;
523
524 cookie = xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
525 dri2_surf->drawable,
526 count, count, attachments);
527 reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn, cookie, NULL);
528 if (reply == NULL)
529 return NULL;
530 buffers = xcb_dri2_get_buffers_buffers (reply);
531 if (buffers == NULL)
532 return NULL;
533
534 *out_count = reply->count;
535 dri2_surf->base.Width = *width = reply->width;
536 dri2_surf->base.Height = *height = reply->height;
537 dri2_x11_process_buffers(dri2_surf, buffers, *out_count);
538
539 free(reply);
540
541 return dri2_surf->buffers;
542 }
543
544 static __DRIbuffer *
545 dri2_x11_get_buffers_with_format(__DRIdrawable * driDrawable,
546 int *width, int *height,
547 unsigned int *attachments, int count,
548 int *out_count, void *loaderPrivate)
549 {
550 struct dri2_egl_surface *dri2_surf = loaderPrivate;
551 struct dri2_egl_display *dri2_dpy =
552 dri2_egl_display(dri2_surf->base.Resource.Display);
553 xcb_dri2_dri2_buffer_t *buffers;
554 xcb_dri2_get_buffers_with_format_reply_t *reply;
555 xcb_dri2_get_buffers_with_format_cookie_t cookie;
556 xcb_dri2_attach_format_t *format_attachments;
557
558 (void) driDrawable;
559
560 format_attachments = (xcb_dri2_attach_format_t *) attachments;
561 cookie = xcb_dri2_get_buffers_with_format_unchecked (dri2_dpy->conn,
562 dri2_surf->drawable,
563 count, count,
564 format_attachments);
565
566 reply = xcb_dri2_get_buffers_with_format_reply (dri2_dpy->conn,
567 cookie, NULL);
568 if (reply == NULL)
569 return NULL;
570
571 buffers = xcb_dri2_get_buffers_with_format_buffers (reply);
572 dri2_surf->base.Width = *width = reply->width;
573 dri2_surf->base.Height = *height = reply->height;
574 *out_count = reply->count;
575 dri2_x11_process_buffers(dri2_surf, buffers, *out_count);
576
577 free(reply);
578
579 return dri2_surf->buffers;
580 }
581
582 static void
583 dri2_x11_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
584 {
585 (void) driDrawable;
586
587 /* FIXME: Does EGL support front buffer rendering at all? */
588
589 #if 0
590 struct dri2_egl_surface *dri2_surf = loaderPrivate;
591
592 dri2WaitGL(dri2_surf);
593 #else
594 (void) loaderPrivate;
595 #endif
596 }
597
598 static int
599 dri2_x11_do_authenticate(struct dri2_egl_display *dri2_dpy, uint32_t id)
600 {
601 xcb_dri2_authenticate_reply_t *authenticate;
602 xcb_dri2_authenticate_cookie_t authenticate_cookie;
603 int ret = 0;
604
605 authenticate_cookie =
606 xcb_dri2_authenticate_unchecked(dri2_dpy->conn, dri2_dpy->screen->root, id);
607 authenticate =
608 xcb_dri2_authenticate_reply(dri2_dpy->conn, authenticate_cookie, NULL);
609
610 if (authenticate == NULL || !authenticate->authenticated)
611 ret = -1;
612
613 free(authenticate);
614
615 return ret;
616 }
617
618 static EGLBoolean
619 dri2_x11_local_authenticate(struct dri2_egl_display *dri2_dpy)
620 {
621 #ifdef HAVE_LIBDRM
622 drm_magic_t magic;
623
624 if (drmGetMagic(dri2_dpy->fd, &magic)) {
625 _eglLog(_EGL_WARNING, "DRI2: failed to get drm magic");
626 return EGL_FALSE;
627 }
628
629 if (dri2_x11_do_authenticate(dri2_dpy, magic) < 0) {
630 _eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
631 return EGL_FALSE;
632 }
633 #endif
634 return EGL_TRUE;
635 }
636
637 static EGLBoolean
638 dri2_x11_connect(struct dri2_egl_display *dri2_dpy)
639 {
640 xcb_xfixes_query_version_reply_t *xfixes_query;
641 xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
642 xcb_dri2_query_version_reply_t *dri2_query;
643 xcb_dri2_query_version_cookie_t dri2_query_cookie;
644 xcb_dri2_connect_reply_t *connect;
645 xcb_dri2_connect_cookie_t connect_cookie;
646 xcb_generic_error_t *error;
647 char *driver_name, *loader_driver_name, *device_name;
648 const xcb_query_extension_reply_t *extension;
649
650 xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
651 xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
652
653 extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_xfixes_id);
654 if (!(extension && extension->present))
655 return EGL_FALSE;
656
657 extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_dri2_id);
658 if (!(extension && extension->present))
659 return EGL_FALSE;
660
661 xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
662 XCB_XFIXES_MAJOR_VERSION,
663 XCB_XFIXES_MINOR_VERSION);
664
665 dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
666 XCB_DRI2_MAJOR_VERSION,
667 XCB_DRI2_MINOR_VERSION);
668
669 connect_cookie = xcb_dri2_connect_unchecked(dri2_dpy->conn, dri2_dpy->screen->root,
670 XCB_DRI2_DRIVER_TYPE_DRI);
671
672 xfixes_query =
673 xcb_xfixes_query_version_reply (dri2_dpy->conn,
674 xfixes_query_cookie, &error);
675 if (xfixes_query == NULL ||
676 error != NULL || xfixes_query->major_version < 2) {
677 _eglLog(_EGL_WARNING, "DRI2: failed to query xfixes version");
678 free(error);
679 free(xfixes_query);
680 return EGL_FALSE;
681 }
682 free(xfixes_query);
683
684 dri2_query =
685 xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
686 if (dri2_query == NULL || error != NULL) {
687 _eglLog(_EGL_WARNING, "DRI2: failed to query version");
688 free(error);
689 return EGL_FALSE;
690 }
691 dri2_dpy->dri2_major = dri2_query->major_version;
692 dri2_dpy->dri2_minor = dri2_query->minor_version;
693 free(dri2_query);
694
695 connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
696 if (connect == NULL ||
697 connect->driver_name_length + connect->device_name_length == 0) {
698 _eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
699 return EGL_FALSE;
700 }
701
702 device_name = xcb_dri2_connect_device_name (connect);
703
704 dri2_dpy->fd = loader_open_device(device_name);
705 if (dri2_dpy->fd == -1) {
706 _eglLog(_EGL_WARNING,
707 "DRI2: could not open %s (%s)", device_name, strerror(errno));
708 free(connect);
709 return EGL_FALSE;
710 }
711
712 if (!dri2_x11_local_authenticate(dri2_dpy)) {
713 close(dri2_dpy->fd);
714 free(connect);
715 return EGL_FALSE;
716 }
717
718 driver_name = xcb_dri2_connect_driver_name (connect);
719
720 /* If Mesa knows about the appropriate driver for this fd, then trust it.
721 * Otherwise, default to the server's value.
722 */
723 loader_driver_name = loader_get_driver_for_fd(dri2_dpy->fd);
724 if (loader_driver_name) {
725 dri2_dpy->driver_name = loader_driver_name;
726 } else {
727 dri2_dpy->driver_name =
728 strndup(driver_name,
729 xcb_dri2_connect_driver_name_length(connect));
730 }
731
732 if (dri2_dpy->driver_name == NULL) {
733 close(dri2_dpy->fd);
734 free(connect);
735 return EGL_FALSE;
736 }
737
738 #ifdef HAVE_WAYLAND_PLATFORM
739 dri2_dpy->device_name =
740 strndup(device_name,
741 xcb_dri2_connect_device_name_length(connect));
742 #endif
743
744 free(connect);
745
746 return EGL_TRUE;
747 }
748
749 static int
750 dri2_x11_authenticate(_EGLDisplay *disp, uint32_t id)
751 {
752 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
753
754 return dri2_x11_do_authenticate(dri2_dpy, id);
755 }
756
757 static EGLBoolean
758 dri2_x11_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
759 _EGLDisplay *disp, bool supports_preserved)
760 {
761 xcb_depth_iterator_t d;
762 xcb_visualtype_t *visuals;
763 int config_count = 0;
764 EGLint surface_type;
765
766 d = xcb_screen_allowed_depths_iterator(dri2_dpy->screen);
767
768 surface_type =
769 EGL_WINDOW_BIT |
770 EGL_PIXMAP_BIT |
771 EGL_PBUFFER_BIT;
772
773 if (supports_preserved)
774 surface_type |= EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
775
776 while (d.rem > 0) {
777 EGLBoolean class_added[6] = { 0, };
778
779 visuals = xcb_depth_visuals(d.data);
780
781 for (int i = 0; i < xcb_depth_visuals_length(d.data); i++) {
782 if (class_added[visuals[i]._class])
783 continue;
784
785 class_added[visuals[i]._class] = EGL_TRUE;
786
787 for (int j = 0; dri2_dpy->driver_configs[j]; j++) {
788 struct dri2_egl_config *dri2_conf;
789 const __DRIconfig *config = dri2_dpy->driver_configs[j];
790
791 const EGLint config_attrs[] = {
792 EGL_NATIVE_VISUAL_ID, visuals[i].visual_id,
793 EGL_NATIVE_VISUAL_TYPE, visuals[i]._class,
794 EGL_NONE
795 };
796
797 int rgba_shifts[4] = {
798 ffs(visuals[i].red_mask) - 1,
799 ffs(visuals[i].green_mask) - 1,
800 ffs(visuals[i].blue_mask) - 1,
801 -1,
802 };
803
804 unsigned int rgba_sizes[4] = {
805 util_bitcount(visuals[i].red_mask),
806 util_bitcount(visuals[i].green_mask),
807 util_bitcount(visuals[i].blue_mask),
808 0,
809 };
810
811 dri2_conf = dri2_add_config(disp, config, config_count + 1,
812 surface_type, config_attrs,
813 rgba_shifts, rgba_sizes);
814 if (dri2_conf)
815 if (dri2_conf->base.ConfigID == config_count + 1)
816 config_count++;
817
818 /* Allow a 24-bit RGB visual to match a 32-bit RGBA EGLConfig.
819 * Ditto for 30-bit RGB visuals to match a 32-bit RGBA EGLConfig.
820 * Otherwise it will only match a 32-bit RGBA visual. On a
821 * composited window manager on X11, this will make all of the
822 * EGLConfigs with destination alpha get blended by the
823 * compositor. This is probably not what the application
824 * wants... especially on drivers that only have 32-bit RGBA
825 * EGLConfigs! */
826 if (d.data->depth == 24 || d.data->depth == 30) {
827 unsigned int rgba_mask = ~(visuals[i].red_mask |
828 visuals[i].green_mask |
829 visuals[i].blue_mask);
830 rgba_shifts[3] = ffs(rgba_mask) - 1;
831 rgba_sizes[3] = util_bitcount(rgba_mask);
832 dri2_conf = dri2_add_config(disp, config, config_count + 1,
833 surface_type, config_attrs,
834 rgba_shifts, rgba_sizes);
835 if (dri2_conf)
836 if (dri2_conf->base.ConfigID == config_count + 1)
837 config_count++;
838 }
839 }
840 }
841
842 xcb_depth_next(&d);
843 }
844
845 if (!config_count) {
846 _eglLog(_EGL_WARNING, "DRI2: failed to create any config");
847 return EGL_FALSE;
848 }
849
850 return EGL_TRUE;
851 }
852
853 static EGLBoolean
854 dri2_copy_region(const _EGLDriver *drv, _EGLDisplay *disp,
855 _EGLSurface *draw, xcb_xfixes_region_t region)
856 {
857 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
858 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
859 enum xcb_dri2_attachment_t render_attachment;
860 xcb_dri2_copy_region_cookie_t cookie;
861
862 /* No-op for a pixmap or pbuffer surface */
863 if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT)
864 return EGL_TRUE;
865
866 dri2_dpy->flush->flush(dri2_surf->dri_drawable);
867
868 if (dri2_surf->have_fake_front)
869 render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT;
870 else
871 render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT;
872
873 cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
874 dri2_surf->drawable,
875 region,
876 XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
877 render_attachment);
878 free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
879
880 return EGL_TRUE;
881 }
882
883 static int64_t
884 dri2_x11_swap_buffers_msc(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
885 int64_t msc, int64_t divisor, int64_t remainder)
886 {
887 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
888 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
889 uint32_t msc_hi = msc >> 32;
890 uint32_t msc_lo = msc & 0xffffffff;
891 uint32_t divisor_hi = divisor >> 32;
892 uint32_t divisor_lo = divisor & 0xffffffff;
893 uint32_t remainder_hi = remainder >> 32;
894 uint32_t remainder_lo = remainder & 0xffffffff;
895 xcb_dri2_swap_buffers_cookie_t cookie;
896 xcb_dri2_swap_buffers_reply_t *reply;
897 int64_t swap_count = -1;
898
899 if (draw->SwapBehavior == EGL_BUFFER_PRESERVED || !dri2_dpy->swap_available) {
900 swap_count = dri2_copy_region(drv, disp, draw, dri2_surf->region) ? 0 : -1;
901 } else {
902 dri2_flush_drawable_for_swapbuffers(disp, draw);
903
904 cookie = xcb_dri2_swap_buffers_unchecked(dri2_dpy->conn,
905 dri2_surf->drawable, msc_hi,
906 msc_lo, divisor_hi, divisor_lo,
907 remainder_hi, remainder_lo);
908
909 reply = xcb_dri2_swap_buffers_reply(dri2_dpy->conn, cookie, NULL);
910
911 if (reply) {
912 swap_count = combine_u32_into_u64(reply->swap_hi, reply->swap_lo);
913 free(reply);
914 }
915 }
916
917 /* Since we aren't watching for the server's invalidate events like we're
918 * supposed to (due to XCB providing no mechanism for filtering the events
919 * the way xlib does), and SwapBuffers is a common cause of invalidate
920 * events, just shove one down to the driver, even though we haven't told
921 * the driver that we're the kind of loader that provides reliable
922 * invalidate events. This causes the driver to request buffers again at
923 * its next draw, so that we get the correct buffers if a pageflip
924 * happened. The driver should still be using the viewport hack to catch
925 * window resizes.
926 */
927 if (dri2_dpy->flush->base.version >= 3 && dri2_dpy->flush->invalidate)
928 dri2_dpy->flush->invalidate(dri2_surf->dri_drawable);
929
930 return swap_count;
931 }
932
933 static EGLBoolean
934 dri2_x11_swap_buffers(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
935 {
936 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
937 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
938
939 if (!dri2_dpy->flush) {
940 dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
941 return EGL_TRUE;
942 }
943
944 if (dri2_x11_swap_buffers_msc(drv, disp, draw, 0, 0, 0) == -1) {
945 /* Swap failed with a window drawable. */
946 return _eglError(EGL_BAD_NATIVE_WINDOW, __func__);
947 }
948 return EGL_TRUE;
949 }
950
951 static EGLBoolean
952 dri2_x11_swap_buffers_region(const _EGLDriver *drv, _EGLDisplay *disp,
953 _EGLSurface *draw,
954 EGLint numRects, const EGLint *rects)
955 {
956 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
957 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
958 EGLBoolean ret;
959 xcb_xfixes_region_t region;
960 xcb_rectangle_t rectangles[16];
961
962 if (numRects > (int)ARRAY_SIZE(rectangles))
963 return dri2_copy_region(drv, disp, draw, dri2_surf->region);
964
965 for (int i = 0; i < numRects; i++) {
966 rectangles[i].x = rects[i * 4];
967 rectangles[i].y = dri2_surf->base.Height - rects[i * 4 + 1] - rects[i * 4 + 3];
968 rectangles[i].width = rects[i * 4 + 2];
969 rectangles[i].height = rects[i * 4 + 3];
970 }
971
972 region = xcb_generate_id(dri2_dpy->conn);
973 xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
974 ret = dri2_copy_region(drv, disp, draw, region);
975 xcb_xfixes_destroy_region(dri2_dpy->conn, region);
976
977 return ret;
978 }
979
980 static EGLBoolean
981 dri2_x11_post_sub_buffer(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
982 EGLint x, EGLint y, EGLint width, EGLint height)
983 {
984 const EGLint rect[4] = { x, y, width, height };
985
986 if (x < 0 || y < 0 || width < 0 || height < 0)
987 _eglError(EGL_BAD_PARAMETER, "eglPostSubBufferNV");
988
989 return dri2_x11_swap_buffers_region(drv, disp, draw, 1, rect);
990 }
991
992 static EGLBoolean
993 dri2_x11_swap_interval(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
994 EGLint interval)
995 {
996 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
997 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
998
999 if (dri2_dpy->swap_available)
1000 xcb_dri2_swap_interval(dri2_dpy->conn, dri2_surf->drawable, interval);
1001
1002 return EGL_TRUE;
1003 }
1004
1005 static EGLBoolean
1006 dri2_x11_copy_buffers(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1007 void *native_pixmap_target)
1008 {
1009 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1010 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1011 xcb_gcontext_t gc;
1012 xcb_pixmap_t target;
1013
1014 STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_pixmap_target));
1015 target = (uintptr_t) native_pixmap_target;
1016
1017 (void) drv;
1018
1019 dri2_dpy->flush->flush(dri2_surf->dri_drawable);
1020
1021 gc = xcb_generate_id(dri2_dpy->conn);
1022 xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
1023 xcb_copy_area(dri2_dpy->conn,
1024 dri2_surf->drawable,
1025 target,
1026 gc,
1027 0, 0,
1028 0, 0,
1029 dri2_surf->base.Width,
1030 dri2_surf->base.Height);
1031 xcb_free_gc(dri2_dpy->conn, gc);
1032
1033 return EGL_TRUE;
1034 }
1035
1036 uint32_t
1037 dri2_format_for_depth(struct dri2_egl_display *dri2_dpy, uint32_t depth)
1038 {
1039 switch (depth) {
1040 case 16:
1041 return __DRI_IMAGE_FORMAT_RGB565;
1042 case 24:
1043 return __DRI_IMAGE_FORMAT_XRGB8888;
1044 case 30:
1045 /* Different preferred formats for different hw */
1046 if (dri2_x11_get_red_mask_for_depth(dri2_dpy, 30) == 0x3ff)
1047 return __DRI_IMAGE_FORMAT_XBGR2101010;
1048 else
1049 return __DRI_IMAGE_FORMAT_XRGB2101010;
1050 case 32:
1051 return __DRI_IMAGE_FORMAT_ARGB8888;
1052 default:
1053 return __DRI_IMAGE_FORMAT_NONE;
1054 }
1055 }
1056
1057 static _EGLImage *
1058 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
1059 EGLClientBuffer buffer, const EGLint *attr_list)
1060 {
1061 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1062 struct dri2_egl_image *dri2_img;
1063 unsigned int attachments[1];
1064 xcb_drawable_t drawable;
1065 xcb_dri2_get_buffers_cookie_t buffers_cookie;
1066 xcb_dri2_get_buffers_reply_t *buffers_reply;
1067 xcb_dri2_dri2_buffer_t *buffers;
1068 xcb_get_geometry_cookie_t geometry_cookie;
1069 xcb_get_geometry_reply_t *geometry_reply;
1070 xcb_generic_error_t *error;
1071 int stride, format;
1072
1073 (void) ctx;
1074
1075 drawable = (xcb_drawable_t) (uintptr_t) buffer;
1076 xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
1077 attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
1078 buffers_cookie =
1079 xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
1080 drawable, 1, 1, attachments);
1081 geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
1082 buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
1083 buffers_cookie, NULL);
1084 if (buffers_reply == NULL)
1085 return NULL;
1086
1087 buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
1088 if (buffers == NULL) {
1089 return NULL;
1090 }
1091
1092 geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
1093 geometry_cookie, &error);
1094 if (geometry_reply == NULL || error != NULL) {
1095 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1096 free(error);
1097 free(buffers_reply);
1098 return NULL;
1099 }
1100
1101 format = dri2_format_for_depth(dri2_dpy, geometry_reply->depth);
1102 if (format == __DRI_IMAGE_FORMAT_NONE) {
1103 _eglError(EGL_BAD_PARAMETER,
1104 "dri2_create_image_khr: unsupported pixmap depth");
1105 free(buffers_reply);
1106 free(geometry_reply);
1107 return NULL;
1108 }
1109
1110 dri2_img = malloc(sizeof *dri2_img);
1111 if (!dri2_img) {
1112 free(buffers_reply);
1113 free(geometry_reply);
1114 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1115 return EGL_NO_IMAGE_KHR;
1116 }
1117
1118 _eglInitImage(&dri2_img->base, disp);
1119
1120 stride = buffers[0].pitch / buffers[0].cpp;
1121 dri2_img->dri_image =
1122 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
1123 buffers_reply->width,
1124 buffers_reply->height,
1125 format,
1126 buffers[0].name,
1127 stride,
1128 dri2_img);
1129
1130 free(buffers_reply);
1131 free(geometry_reply);
1132
1133 return &dri2_img->base;
1134 }
1135
1136 static _EGLImage *
1137 dri2_x11_create_image_khr(const _EGLDriver *drv, _EGLDisplay *disp,
1138 _EGLContext *ctx, EGLenum target,
1139 EGLClientBuffer buffer, const EGLint *attr_list)
1140 {
1141 (void) drv;
1142
1143 switch (target) {
1144 case EGL_NATIVE_PIXMAP_KHR:
1145 return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
1146 default:
1147 return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
1148 }
1149 }
1150
1151 static EGLBoolean
1152 dri2_x11_get_sync_values(_EGLDisplay *display, _EGLSurface *surface,
1153 EGLuint64KHR *ust, EGLuint64KHR *msc,
1154 EGLuint64KHR *sbc)
1155 {
1156 struct dri2_egl_display *dri2_dpy = dri2_egl_display(display);
1157 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
1158 xcb_dri2_get_msc_cookie_t cookie;
1159 xcb_dri2_get_msc_reply_t *reply;
1160
1161 cookie = xcb_dri2_get_msc(dri2_dpy->conn, dri2_surf->drawable);
1162 reply = xcb_dri2_get_msc_reply(dri2_dpy->conn, cookie, NULL);
1163
1164 if (!reply)
1165 return _eglError(EGL_BAD_ACCESS, __func__);
1166
1167 *ust = ((EGLuint64KHR) reply->ust_hi << 32) | reply->ust_lo;
1168 *msc = ((EGLuint64KHR) reply->msc_hi << 32) | reply->msc_lo;
1169 *sbc = ((EGLuint64KHR) reply->sbc_hi << 32) | reply->sbc_lo;
1170 free(reply);
1171
1172 return EGL_TRUE;
1173 }
1174
1175 static const struct dri2_egl_display_vtbl dri2_x11_swrast_display_vtbl = {
1176 .authenticate = NULL,
1177 .create_window_surface = dri2_x11_create_window_surface,
1178 .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1179 .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1180 .destroy_surface = dri2_x11_destroy_surface,
1181 .create_image = dri2_create_image_khr,
1182 .swap_buffers = dri2_x11_swap_buffers,
1183 /* XXX: should really implement this since X11 has pixmaps */
1184 .query_surface = dri2_query_surface,
1185 .get_dri_drawable = dri2_surface_get_dri_drawable,
1186 };
1187
1188 static const struct dri2_egl_display_vtbl dri2_x11_display_vtbl = {
1189 .authenticate = dri2_x11_authenticate,
1190 .create_window_surface = dri2_x11_create_window_surface,
1191 .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1192 .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1193 .destroy_surface = dri2_x11_destroy_surface,
1194 .create_image = dri2_x11_create_image_khr,
1195 .swap_interval = dri2_x11_swap_interval,
1196 .swap_buffers = dri2_x11_swap_buffers,
1197 .swap_buffers_region = dri2_x11_swap_buffers_region,
1198 .post_sub_buffer = dri2_x11_post_sub_buffer,
1199 .copy_buffers = dri2_x11_copy_buffers,
1200 .query_surface = dri2_query_surface,
1201 .get_sync_values = dri2_x11_get_sync_values,
1202 .get_dri_drawable = dri2_surface_get_dri_drawable,
1203 };
1204
1205 static const __DRIswrastLoaderExtension swrast_loader_extension = {
1206 .base = { __DRI_SWRAST_LOADER, 1 },
1207
1208 .getDrawableInfo = swrastGetDrawableInfo,
1209 .putImage = swrastPutImage,
1210 .getImage = swrastGetImage,
1211 };
1212
1213 static const __DRIextension *swrast_loader_extensions[] = {
1214 &swrast_loader_extension.base,
1215 &image_lookup_extension.base,
1216 NULL,
1217 };
1218
1219 static int
1220 dri2_find_screen_for_display(const _EGLDisplay *disp, int fallback_screen)
1221 {
1222 const EGLAttrib *attr;
1223
1224 for (attr = disp->Options.Attribs; attr; attr += 2) {
1225 if (attr[0] == EGL_PLATFORM_X11_SCREEN_EXT)
1226 return attr[1];
1227 }
1228
1229 return fallback_screen;
1230 }
1231
1232 static EGLBoolean
1233 dri2_get_xcb_connection(const _EGLDriver *drv, _EGLDisplay *disp,
1234 struct dri2_egl_display *dri2_dpy)
1235 {
1236 xcb_screen_iterator_t s;
1237 int screen;
1238 const char *msg;
1239
1240 disp->DriverData = (void *) dri2_dpy;
1241 if (disp->PlatformDisplay == NULL) {
1242 dri2_dpy->conn = xcb_connect(NULL, &screen);
1243 dri2_dpy->own_device = true;
1244 screen = dri2_find_screen_for_display(disp, screen);
1245 } else {
1246 Display *dpy = disp->PlatformDisplay;
1247 dri2_dpy->conn = XGetXCBConnection(dpy);
1248 screen = DefaultScreen(dpy);
1249 }
1250
1251 if (!dri2_dpy->conn || xcb_connection_has_error(dri2_dpy->conn)) {
1252 msg = "xcb_connect failed";
1253 goto disconnect;
1254 }
1255
1256 s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
1257 dri2_dpy->screen = get_xcb_screen(s, screen);
1258 if (!dri2_dpy->screen) {
1259 msg = "failed to get xcb screen";
1260 goto disconnect;
1261 }
1262
1263 return EGL_TRUE;
1264 disconnect:
1265 if (disp->PlatformDisplay == NULL)
1266 xcb_disconnect(dri2_dpy->conn);
1267
1268 return _eglError(EGL_BAD_ALLOC, msg);
1269 }
1270
1271 static EGLBoolean
1272 dri2_initialize_x11_swrast(const _EGLDriver *drv, _EGLDisplay *disp)
1273 {
1274 _EGLDevice *dev;
1275 struct dri2_egl_display *dri2_dpy;
1276
1277 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1278 if (!dri2_dpy)
1279 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1280
1281 dri2_dpy->fd = -1;
1282 if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1283 goto cleanup;
1284
1285 dev = _eglAddDevice(dri2_dpy->fd, true);
1286 if (!dev) {
1287 _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1288 goto cleanup;
1289 }
1290
1291 disp->Device = dev;
1292
1293 /*
1294 * Every hardware driver_name is set using strdup. Doing the same in
1295 * here will allow is to simply free the memory at dri2_terminate().
1296 */
1297 dri2_dpy->driver_name = strdup("swrast");
1298 if (!dri2_load_driver_swrast(disp))
1299 goto cleanup;
1300
1301 dri2_dpy->loader_extensions = swrast_loader_extensions;
1302
1303 if (!dri2_create_screen(disp))
1304 goto cleanup;
1305
1306 if (!dri2_setup_extensions(disp))
1307 goto cleanup;
1308
1309 dri2_setup_screen(disp);
1310
1311 if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, true))
1312 goto cleanup;
1313
1314 /* Fill vtbl last to prevent accidentally calling virtual function during
1315 * initialization.
1316 */
1317 dri2_dpy->vtbl = &dri2_x11_swrast_display_vtbl;
1318
1319 return EGL_TRUE;
1320
1321 cleanup:
1322 dri2_display_destroy(disp);
1323 return EGL_FALSE;
1324 }
1325
1326 static void
1327 dri2_x11_setup_swap_interval(_EGLDisplay *disp)
1328 {
1329 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1330 int arbitrary_max_interval = 1000;
1331
1332 /* default behavior for no SwapBuffers support: no vblank syncing
1333 * either.
1334 */
1335 dri2_dpy->min_swap_interval = 0;
1336 dri2_dpy->max_swap_interval = 0;
1337 dri2_dpy->default_swap_interval = 0;
1338
1339 if (!dri2_dpy->swap_available)
1340 return;
1341
1342 /* If we do have swapbuffers, then we can support pretty much any swap
1343 * interval.
1344 */
1345 dri2_setup_swap_interval(disp, arbitrary_max_interval);
1346 }
1347
1348 #ifdef HAVE_DRI3
1349
1350 static const __DRIextension *dri3_image_loader_extensions[] = {
1351 &dri3_image_loader_extension.base,
1352 &image_lookup_extension.base,
1353 &use_invalidate.base,
1354 &background_callable_extension.base,
1355 NULL,
1356 };
1357
1358 static EGLBoolean
1359 dri2_initialize_x11_dri3(const _EGLDriver *drv, _EGLDisplay *disp)
1360 {
1361 _EGLDevice *dev;
1362 struct dri2_egl_display *dri2_dpy;
1363
1364 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1365 if (!dri2_dpy)
1366 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1367
1368 dri2_dpy->fd = -1;
1369 if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1370 goto cleanup;
1371
1372 if (!dri3_x11_connect(dri2_dpy))
1373 goto cleanup;
1374
1375 dev = _eglAddDevice(dri2_dpy->fd, false);
1376 if (!dev) {
1377 _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1378 goto cleanup;
1379 }
1380
1381 disp->Device = dev;
1382
1383 if (!dri2_load_driver_dri3(disp))
1384 goto cleanup;
1385
1386 dri2_dpy->loader_extensions = dri3_image_loader_extensions;
1387
1388 dri2_dpy->swap_available = true;
1389 dri2_dpy->invalidate_available = true;
1390
1391 if (!dri2_create_screen(disp))
1392 goto cleanup;
1393
1394 if (!dri2_setup_extensions(disp))
1395 goto cleanup;
1396
1397 dri2_setup_screen(disp);
1398
1399 dri2_x11_setup_swap_interval(disp);
1400
1401 if (!dri2_dpy->is_different_gpu)
1402 disp->Extensions.KHR_image_pixmap = EGL_TRUE;
1403 disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
1404 disp->Extensions.CHROMIUM_sync_control = EGL_TRUE;
1405 disp->Extensions.EXT_buffer_age = EGL_TRUE;
1406
1407 dri2_set_WL_bind_wayland_display(drv, disp);
1408
1409 if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, false))
1410 goto cleanup;
1411
1412 dri2_dpy->loader_dri3_ext.core = dri2_dpy->core;
1413 dri2_dpy->loader_dri3_ext.image_driver = dri2_dpy->image_driver;
1414 dri2_dpy->loader_dri3_ext.flush = dri2_dpy->flush;
1415 dri2_dpy->loader_dri3_ext.tex_buffer = dri2_dpy->tex_buffer;
1416 dri2_dpy->loader_dri3_ext.image = dri2_dpy->image;
1417 dri2_dpy->loader_dri3_ext.config = dri2_dpy->config;
1418
1419 /* Fill vtbl last to prevent accidentally calling virtual function during
1420 * initialization.
1421 */
1422 dri2_dpy->vtbl = &dri3_x11_display_vtbl;
1423
1424 _eglLog(_EGL_INFO, "Using DRI3");
1425
1426 return EGL_TRUE;
1427
1428 cleanup:
1429 dri2_display_destroy(disp);
1430 return EGL_FALSE;
1431 }
1432 #endif
1433
1434 static const __DRIdri2LoaderExtension dri2_loader_extension_old = {
1435 .base = { __DRI_DRI2_LOADER, 2 },
1436
1437 .getBuffers = dri2_x11_get_buffers,
1438 .flushFrontBuffer = dri2_x11_flush_front_buffer,
1439 .getBuffersWithFormat = NULL,
1440 };
1441
1442 static const __DRIdri2LoaderExtension dri2_loader_extension = {
1443 .base = { __DRI_DRI2_LOADER, 3 },
1444
1445 .getBuffers = dri2_x11_get_buffers,
1446 .flushFrontBuffer = dri2_x11_flush_front_buffer,
1447 .getBuffersWithFormat = dri2_x11_get_buffers_with_format,
1448 };
1449
1450 static const __DRIextension *dri2_loader_extensions_old[] = {
1451 &dri2_loader_extension_old.base,
1452 &image_lookup_extension.base,
1453 &background_callable_extension.base,
1454 NULL,
1455 };
1456
1457 static const __DRIextension *dri2_loader_extensions[] = {
1458 &dri2_loader_extension.base,
1459 &image_lookup_extension.base,
1460 &use_invalidate.base,
1461 &background_callable_extension.base,
1462 NULL,
1463 };
1464
1465 static EGLBoolean
1466 dri2_initialize_x11_dri2(const _EGLDriver *drv, _EGLDisplay *disp)
1467 {
1468 _EGLDevice *dev;
1469 struct dri2_egl_display *dri2_dpy;
1470
1471 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1472 if (!dri2_dpy)
1473 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1474
1475 dri2_dpy->fd = -1;
1476 if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1477 goto cleanup;
1478
1479 if (!dri2_x11_connect(dri2_dpy))
1480 goto cleanup;
1481
1482 dev = _eglAddDevice(dri2_dpy->fd, false);
1483 if (!dev) {
1484 _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1485 goto cleanup;
1486 }
1487
1488 disp->Device = dev;
1489
1490 if (!dri2_load_driver(disp))
1491 goto cleanup;
1492
1493 if (dri2_dpy->dri2_minor >= 1)
1494 dri2_dpy->loader_extensions = dri2_loader_extensions;
1495 else
1496 dri2_dpy->loader_extensions = dri2_loader_extensions_old;
1497
1498 dri2_dpy->swap_available = (dri2_dpy->dri2_minor >= 2);
1499 dri2_dpy->invalidate_available = (dri2_dpy->dri2_minor >= 3);
1500
1501 if (!dri2_create_screen(disp))
1502 goto cleanup;
1503
1504 if (!dri2_setup_extensions(disp))
1505 goto cleanup;
1506
1507 dri2_setup_screen(disp);
1508
1509 dri2_x11_setup_swap_interval(disp);
1510
1511 disp->Extensions.KHR_image_pixmap = EGL_TRUE;
1512 disp->Extensions.NOK_swap_region = EGL_TRUE;
1513 disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
1514 disp->Extensions.NV_post_sub_buffer = EGL_TRUE;
1515 disp->Extensions.CHROMIUM_sync_control = EGL_TRUE;
1516
1517 dri2_set_WL_bind_wayland_display(drv, disp);
1518
1519 if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, true))
1520 goto cleanup;
1521
1522 /* Fill vtbl last to prevent accidentally calling virtual function during
1523 * initialization.
1524 */
1525 dri2_dpy->vtbl = &dri2_x11_display_vtbl;
1526
1527 _eglLog(_EGL_INFO, "Using DRI2");
1528
1529 return EGL_TRUE;
1530
1531 cleanup:
1532 dri2_display_destroy(disp);
1533 return EGL_FALSE;
1534 }
1535
1536 EGLBoolean
1537 dri2_initialize_x11(const _EGLDriver *drv, _EGLDisplay *disp)
1538 {
1539 EGLBoolean initialized = EGL_FALSE;
1540
1541 if (!disp->Options.ForceSoftware) {
1542 #ifdef HAVE_DRI3
1543 if (!env_var_as_boolean("LIBGL_DRI3_DISABLE", false))
1544 initialized = dri2_initialize_x11_dri3(drv, disp);
1545 #endif
1546
1547 if (!initialized)
1548 initialized = dri2_initialize_x11_dri2(drv, disp);
1549 }
1550
1551 if (!initialized)
1552 initialized = dri2_initialize_x11_swrast(drv, disp);
1553
1554 return initialized;
1555 }
1556
1557 void
1558 dri2_teardown_x11(struct dri2_egl_display *dri2_dpy)
1559 {
1560 if (dri2_dpy->own_device)
1561 xcb_disconnect(dri2_dpy->conn);
1562 }