projects / mesa.git / blob
? search:


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