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 = _eglGetConfigKey(conf, EGL_BUFFER_SIZE);
 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 bool
 759 dri2_x11_config_match_attrib(struct dri2_egl_display *dri2_dpy,
 760                              const __DRIconfig *config,
 761                              unsigned int attrib,
 762                              unsigned int value)
 763 {
 764    uint32_t config_val;
 765    if (!dri2_dpy->core->getConfigAttrib(config, attrib, &config_val))
 766       return false;
 767    return config_val == value;
 768 }
 769
 770 /**
 771  * See if the X server can export a pixmap with the given color depth.
 772  *
 773  * Glamor in xorg-server 1.20 can't export pixmaps which have a different
 774  * color depth than the root window as a DRI image.  This makes it impossible
 775  * to expose pbuffer-only visuals with, say, 16bpp on a 24bpp X display.
 776  */
 777 static bool
 778 x11_can_export_pixmap_with_bpp(struct dri2_egl_display *dri2_dpy, int bpp)
 779 {
 780    bool supported = false;
 781
 782 #ifdef HAVE_DRI3
 783    xcb_dri3_buffer_from_pixmap_cookie_t cookie;
 784    xcb_dri3_buffer_from_pixmap_reply_t *reply;
 785
 786    xcb_pixmap_t pixmap = xcb_generate_id(dri2_dpy->conn);
 787    xcb_create_pixmap(dri2_dpy->conn, bpp, pixmap, dri2_dpy->screen->root, 1, 1);
 788    cookie = xcb_dri3_buffer_from_pixmap(dri2_dpy->conn, pixmap);
 789    reply = xcb_dri3_buffer_from_pixmap_reply(dri2_dpy->conn, cookie, NULL);
 790
 791    if (reply) {
 792       int *fds = xcb_dri3_buffer_from_pixmap_reply_fds(dri2_dpy->conn, reply);
 793
 794       for (int i = 0; i < reply->nfd; i++) {
 795          close(fds[i]);
 796       }
 797
 798       supported = true;
 799
 800       free(reply);
 801    }
 802
 803    xcb_free_pixmap(dri2_dpy->conn, pixmap);
 804 #endif
 805
 806    return supported;
 807 }
 808
 809 static EGLBoolean
 810 dri2_x11_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
 811                                  _EGLDisplay *disp, bool supports_preserved,
 812                                  bool add_pbuffer_configs)
 813 {
 814    xcb_depth_iterator_t d;
 815    xcb_visualtype_t *visuals;
 816    int config_count = 0;
 817    EGLint surface_type;
 818
 819    d = xcb_screen_allowed_depths_iterator(dri2_dpy->screen);
 820
 821    surface_type =
 822       EGL_WINDOW_BIT |
 823       EGL_PIXMAP_BIT |
 824       EGL_PBUFFER_BIT;
 825
 826    if (supports_preserved)
 827       surface_type |= EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
 828
 829    while (d.rem > 0) {
 830       EGLBoolean class_added[6] = { 0, };
 831
 832       visuals = xcb_depth_visuals(d.data);
 833
 834       for (int i = 0; i < xcb_depth_visuals_length(d.data); i++) {
 835          if (class_added[visuals[i]._class])
 836             continue;
 837
 838          class_added[visuals[i]._class] = EGL_TRUE;
 839
 840          for (int j = 0; dri2_dpy->driver_configs[j]; j++) {
 841             struct dri2_egl_config *dri2_conf;
 842             const __DRIconfig *config = dri2_dpy->driver_configs[j];
 843
 844             const EGLint config_attrs[] = {
 845                     EGL_NATIVE_VISUAL_ID,    visuals[i].visual_id,
 846                     EGL_NATIVE_VISUAL_TYPE,  visuals[i]._class,
 847                     EGL_NONE
 848             };
 849
 850             int rgba_shifts[4] = {
 851                ffs(visuals[i].red_mask) - 1,
 852                ffs(visuals[i].green_mask) - 1,
 853                ffs(visuals[i].blue_mask) - 1,
 854                -1,
 855             };
 856
 857             unsigned int rgba_sizes[4] = {
 858                util_bitcount(visuals[i].red_mask),
 859                util_bitcount(visuals[i].green_mask),
 860                util_bitcount(visuals[i].blue_mask),
 861                0,
 862             };
 863
 864             dri2_conf = dri2_add_config(disp, config, config_count + 1,
 865                                         surface_type, config_attrs,
 866                                         rgba_shifts, rgba_sizes);
 867             if (dri2_conf)
 868                if (dri2_conf->base.ConfigID == config_count + 1)
 869                   config_count++;
 870
 871             /* Allow a 24-bit RGB visual to match a 32-bit RGBA EGLConfig.
 872              * Ditto for 30-bit RGB visuals to match a 32-bit RGBA EGLConfig.
 873              * Otherwise it will only match a 32-bit RGBA visual.  On a
 874              * composited window manager on X11, this will make all of the
 875              * EGLConfigs with destination alpha get blended by the
 876              * compositor.  This is probably not what the application
 877              * wants... especially on drivers that only have 32-bit RGBA
 878              * EGLConfigs! */
 879             if (d.data->depth == 24 || d.data->depth == 30) {
 880                unsigned int rgba_mask = ~(visuals[i].red_mask |
 881                                           visuals[i].green_mask |
 882                                           visuals[i].blue_mask);
 883                rgba_shifts[3] = ffs(rgba_mask) - 1;
 884                rgba_sizes[3] = util_bitcount(rgba_mask);
 885                dri2_conf = dri2_add_config(disp, config, config_count + 1,
 886                                            surface_type, config_attrs,
 887                                            rgba_shifts, rgba_sizes);
 888                if (dri2_conf)
 889                   if (dri2_conf->base.ConfigID == config_count + 1)
 890                      config_count++;
 891             }
 892          }
 893       }
 894
 895       xcb_depth_next(&d);
 896    }
 897
 898    /* Add a 565-no-depth-no-stencil pbuffer-only config.  If X11 is depth 24,
 899     * we wouldn't have 565 available, which the CTS demands.
 900     */
 901    if (add_pbuffer_configs && x11_can_export_pixmap_with_bpp(dri2_dpy, 16)) {
 902       for (int j = 0; dri2_dpy->driver_configs[j]; j++) {
 903          const __DRIconfig *config = dri2_dpy->driver_configs[j];
 904          const EGLint config_attrs[] = {
 905             EGL_NATIVE_VISUAL_ID,    0,
 906             EGL_NATIVE_VISUAL_TYPE,  EGL_NONE,
 907             EGL_NONE
 908          };
 909          EGLint surface_type = EGL_PBUFFER_BIT;
 910          int rgba_shifts[4] = { 11, 5, 0, -1 };
 911          unsigned int rgba_sizes[4] = { 5, 6, 5, 0 };
 912
 913          /* Check that we've found single-sample, no depth, no stencil,
 914           * and single-buffered.
 915           */
 916          if (!dri2_x11_config_match_attrib(dri2_dpy, config,
 917                                            __DRI_ATTRIB_DEPTH_SIZE, 0) ||
 918              !dri2_x11_config_match_attrib(dri2_dpy, config,
 919                                            __DRI_ATTRIB_STENCIL_SIZE, 0) ||
 920              !dri2_x11_config_match_attrib(dri2_dpy, config,
 921                                            __DRI_ATTRIB_SAMPLES, 0) ||
 922              !dri2_x11_config_match_attrib(dri2_dpy, config,
 923                                            __DRI_ATTRIB_DOUBLE_BUFFER, 0)) {
 924             continue;
 925          }
 926
 927          if (dri2_add_config(disp, config, config_count + 1, surface_type,
 928                              config_attrs, rgba_shifts, rgba_sizes)) {
 929             config_count++;
 930             break;
 931          }
 932       }
 933    }
 934
 935    if (!config_count) {
 936       _eglLog(_EGL_WARNING, "DRI2: failed to create any config");
 937       return EGL_FALSE;
 938    }
 939
 940    return EGL_TRUE;
 941 }
 942
 943 static EGLBoolean
 944 dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp,
 945                  _EGLSurface *draw, xcb_xfixes_region_t region)
 946 {
 947    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 948    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 949    enum xcb_dri2_attachment_t render_attachment;
 950    xcb_dri2_copy_region_cookie_t cookie;
 951
 952    /* No-op for a pixmap or pbuffer surface */
 953    if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT)
 954       return EGL_TRUE;
 955
 956    dri2_dpy->flush->flush(dri2_surf->dri_drawable);
 957
 958    if (dri2_surf->have_fake_front)
 959       render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT;
 960    else
 961       render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT;
 962
 963    cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
 964                                            dri2_surf->drawable,
 965                                            region,
 966                                            XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
 967                                            render_attachment);
 968    free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
 969
 970    return EGL_TRUE;
 971 }
 972
 973 static int64_t
 974 dri2_x11_swap_buffers_msc(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
 975                           int64_t msc, int64_t divisor, int64_t remainder)
 976 {
 977    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 978    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 979    uint32_t msc_hi = msc >> 32;
 980    uint32_t msc_lo = msc & 0xffffffff;
 981    uint32_t divisor_hi = divisor >> 32;
 982    uint32_t divisor_lo = divisor & 0xffffffff;
 983    uint32_t remainder_hi = remainder >> 32;
 984    uint32_t remainder_lo = remainder & 0xffffffff;
 985    xcb_dri2_swap_buffers_cookie_t cookie;
 986    xcb_dri2_swap_buffers_reply_t *reply;
 987    int64_t swap_count = -1;
 988
 989    if (draw->SwapBehavior == EGL_BUFFER_PRESERVED || !dri2_dpy->swap_available) {
 990       swap_count = dri2_copy_region(drv, disp, draw, dri2_surf->region) ? 0 : -1;
 991    } else {
 992       dri2_flush_drawable_for_swapbuffers(disp, draw);
 993
 994       cookie = xcb_dri2_swap_buffers_unchecked(dri2_dpy->conn,
 995                                                dri2_surf->drawable, msc_hi,
 996                                                msc_lo, divisor_hi, divisor_lo,
 997                                                remainder_hi, remainder_lo);
 998
 999       reply = xcb_dri2_swap_buffers_reply(dri2_dpy->conn, cookie, NULL);
1000
1001       if (reply) {
1002          swap_count = combine_u32_into_u64(reply->swap_hi, reply->swap_lo);
1003          free(reply);
1004       }
1005    }
1006
1007    /* Since we aren't watching for the server's invalidate events like we're
1008     * supposed to (due to XCB providing no mechanism for filtering the events
1009     * the way xlib does), and SwapBuffers is a common cause of invalidate
1010     * events, just shove one down to the driver, even though we haven't told
1011     * the driver that we're the kind of loader that provides reliable
1012     * invalidate events.  This causes the driver to request buffers again at
1013     * its next draw, so that we get the correct buffers if a pageflip
1014     * happened.  The driver should still be using the viewport hack to catch
1015     * window resizes.
1016     */
1017    if (dri2_dpy->flush->base.version >= 3 && dri2_dpy->flush->invalidate)
1018       dri2_dpy->flush->invalidate(dri2_surf->dri_drawable);
1019
1020    return swap_count;
1021 }
1022
1023 static EGLBoolean
1024 dri2_x11_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
1025 {
1026    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1027    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1028
1029    if (!dri2_dpy->flush) {
1030       dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
1031       return EGL_TRUE;
1032    }
1033
1034    if (dri2_x11_swap_buffers_msc(drv, disp, draw, 0, 0, 0) == -1) {
1035       /* Swap failed with a window drawable. */
1036       return _eglError(EGL_BAD_NATIVE_WINDOW, __func__);
1037    }
1038    return EGL_TRUE;
1039 }
1040
1041 static EGLBoolean
1042 dri2_x11_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp,
1043                              _EGLSurface *draw,
1044                              EGLint numRects, const EGLint *rects)
1045 {
1046    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1047    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1048    EGLBoolean ret;
1049    xcb_xfixes_region_t region;
1050    xcb_rectangle_t rectangles[16];
1051
1052    if (numRects > (int)ARRAY_SIZE(rectangles))
1053       return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1054
1055    for (int i = 0; i < numRects; i++) {
1056       rectangles[i].x = rects[i * 4];
1057       rectangles[i].y = dri2_surf->base.Height - rects[i * 4 + 1] - rects[i * 4 + 3];
1058       rectangles[i].width = rects[i * 4 + 2];
1059       rectangles[i].height = rects[i * 4 + 3];
1060    }
1061
1062    region = xcb_generate_id(dri2_dpy->conn);
1063    xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
1064    ret = dri2_copy_region(drv, disp, draw, region);
1065    xcb_xfixes_destroy_region(dri2_dpy->conn, region);
1066
1067    return ret;
1068 }
1069
1070 static EGLBoolean
1071 dri2_x11_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
1072                      EGLint x, EGLint y, EGLint width, EGLint height)
1073 {
1074    const EGLint rect[4] = { x, y, width, height };
1075
1076    if (x < 0 || y < 0 || width < 0 || height < 0)
1077       _eglError(EGL_BAD_PARAMETER, "eglPostSubBufferNV");
1078
1079    return dri2_x11_swap_buffers_region(drv, disp, draw, 1, rect);
1080 }
1081
1082 static EGLBoolean
1083 dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1084                        EGLint interval)
1085 {
1086    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1087    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1088
1089    if (dri2_dpy->swap_available)
1090       xcb_dri2_swap_interval(dri2_dpy->conn, dri2_surf->drawable, interval);
1091
1092    return EGL_TRUE;
1093 }
1094
1095 static EGLBoolean
1096 dri2_x11_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1097                       void *native_pixmap_target)
1098 {
1099    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1100    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1101    xcb_gcontext_t gc;
1102    xcb_pixmap_t target;
1103
1104    STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_pixmap_target));
1105    target = (uintptr_t) native_pixmap_target;
1106
1107    (void) drv;
1108
1109    dri2_dpy->flush->flush(dri2_surf->dri_drawable);
1110
1111    gc = xcb_generate_id(dri2_dpy->conn);
1112    xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
1113    xcb_copy_area(dri2_dpy->conn,
1114                   dri2_surf->drawable,
1115                   target,
1116                   gc,
1117                   0, 0,
1118                   0, 0,
1119                   dri2_surf->base.Width,
1120                   dri2_surf->base.Height);
1121    xcb_free_gc(dri2_dpy->conn, gc);
1122
1123    return EGL_TRUE;
1124 }
1125
1126 uint32_t
1127 dri2_format_for_depth(struct dri2_egl_display *dri2_dpy, uint32_t depth)
1128 {
1129    switch (depth) {
1130    case 16:
1131       return __DRI_IMAGE_FORMAT_RGB565;
1132    case 24:
1133       return __DRI_IMAGE_FORMAT_XRGB8888;
1134    case 30:
1135       /* Different preferred formats for different hw */
1136       if (dri2_x11_get_red_mask_for_depth(dri2_dpy, 30) == 0x3ff)
1137          return __DRI_IMAGE_FORMAT_XBGR2101010;
1138       else
1139          return __DRI_IMAGE_FORMAT_XRGB2101010;
1140    case 32:
1141       return __DRI_IMAGE_FORMAT_ARGB8888;
1142    default:
1143       return __DRI_IMAGE_FORMAT_NONE;
1144    }
1145 }
1146
1147 static _EGLImage *
1148 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
1149                              EGLClientBuffer buffer, const EGLint *attr_list)
1150 {
1151    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1152    struct dri2_egl_image *dri2_img;
1153    unsigned int attachments[1];
1154    xcb_drawable_t drawable;
1155    xcb_dri2_get_buffers_cookie_t buffers_cookie;
1156    xcb_dri2_get_buffers_reply_t *buffers_reply;
1157    xcb_dri2_dri2_buffer_t *buffers;
1158    xcb_get_geometry_cookie_t geometry_cookie;
1159    xcb_get_geometry_reply_t *geometry_reply;
1160    xcb_generic_error_t *error;
1161    int stride, format;
1162
1163    (void) ctx;
1164
1165    drawable = (xcb_drawable_t) (uintptr_t) buffer;
1166    xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
1167    attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
1168    buffers_cookie =
1169       xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
1170                                       drawable, 1, 1, attachments);
1171    geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
1172    buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
1173                                                buffers_cookie, NULL);
1174    if (buffers_reply == NULL)
1175      return NULL;
1176
1177    buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
1178    if (buffers == NULL) {
1179       return NULL;
1180    }
1181
1182    geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
1183                                             geometry_cookie, &error);
1184    if (geometry_reply == NULL || error != NULL) {
1185       _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1186       free(error);
1187       free(buffers_reply);
1188       return NULL;
1189    }
1190
1191    format = dri2_format_for_depth(dri2_dpy, geometry_reply->depth);
1192    if (format == __DRI_IMAGE_FORMAT_NONE) {
1193       _eglError(EGL_BAD_PARAMETER,
1194                 "dri2_create_image_khr: unsupported pixmap depth");
1195       free(buffers_reply);
1196       free(geometry_reply);
1197       return NULL;
1198    }
1199
1200    dri2_img = malloc(sizeof *dri2_img);
1201    if (!dri2_img) {
1202       free(buffers_reply);
1203       free(geometry_reply);
1204       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1205       return EGL_NO_IMAGE_KHR;
1206    }
1207
1208    _eglInitImage(&dri2_img->base, disp);
1209
1210    stride = buffers[0].pitch / buffers[0].cpp;
1211    dri2_img->dri_image =
1212       dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
1213                                            buffers_reply->width,
1214                                            buffers_reply->height,
1215                                            format,
1216                                            buffers[0].name,
1217                                            stride,
1218                                            dri2_img);
1219
1220    free(buffers_reply);
1221    free(geometry_reply);
1222
1223    return &dri2_img->base;
1224 }
1225
1226 static _EGLImage *
1227 dri2_x11_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
1228                           _EGLContext *ctx, EGLenum target,
1229                           EGLClientBuffer buffer, const EGLint *attr_list)
1230 {
1231    (void) drv;
1232
1233    switch (target) {
1234    case EGL_NATIVE_PIXMAP_KHR:
1235       return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
1236    default:
1237       return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
1238    }
1239 }
1240
1241 static EGLBoolean
1242 dri2_x11_get_sync_values(_EGLDisplay *display, _EGLSurface *surface,
1243                          EGLuint64KHR *ust, EGLuint64KHR *msc,
1244                          EGLuint64KHR *sbc)
1245 {
1246    struct dri2_egl_display *dri2_dpy = dri2_egl_display(display);
1247    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
1248    xcb_dri2_get_msc_cookie_t cookie;
1249    xcb_dri2_get_msc_reply_t *reply;
1250
1251    cookie = xcb_dri2_get_msc(dri2_dpy->conn, dri2_surf->drawable);
1252    reply = xcb_dri2_get_msc_reply(dri2_dpy->conn, cookie, NULL);
1253
1254    if (!reply)
1255       return _eglError(EGL_BAD_ACCESS, __func__);
1256
1257    *ust = ((EGLuint64KHR) reply->ust_hi << 32) | reply->ust_lo;
1258    *msc = ((EGLuint64KHR) reply->msc_hi << 32) | reply->msc_lo;
1259    *sbc = ((EGLuint64KHR) reply->sbc_hi << 32) | reply->sbc_lo;
1260    free(reply);
1261
1262    return EGL_TRUE;
1263 }
1264
1265 static const struct dri2_egl_display_vtbl dri2_x11_swrast_display_vtbl = {
1266    .authenticate = NULL,
1267    .create_window_surface = dri2_x11_create_window_surface,
1268    .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1269    .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1270    .destroy_surface = dri2_x11_destroy_surface,
1271    .create_image = dri2_create_image_khr,
1272    .swap_buffers = dri2_x11_swap_buffers,
1273    .swap_buffers_region = dri2_fallback_swap_buffers_region,
1274    .post_sub_buffer = dri2_fallback_post_sub_buffer,
1275    /* XXX: should really implement this since X11 has pixmaps */
1276    .copy_buffers = dri2_fallback_copy_buffers,
1277    .query_buffer_age = dri2_fallback_query_buffer_age,
1278    .query_surface = dri2_query_surface,
1279    .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1280    .get_sync_values = dri2_fallback_get_sync_values,
1281    .get_dri_drawable = dri2_surface_get_dri_drawable,
1282 };
1283
1284 static const struct dri2_egl_display_vtbl dri2_x11_display_vtbl = {
1285    .authenticate = dri2_x11_authenticate,
1286    .create_window_surface = dri2_x11_create_window_surface,
1287    .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1288    .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1289    .destroy_surface = dri2_x11_destroy_surface,
1290    .create_image = dri2_x11_create_image_khr,
1291    .swap_interval = dri2_x11_swap_interval,
1292    .swap_buffers = dri2_x11_swap_buffers,
1293    .swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage,
1294    .swap_buffers_region = dri2_x11_swap_buffers_region,
1295    .post_sub_buffer = dri2_x11_post_sub_buffer,
1296    .copy_buffers = dri2_x11_copy_buffers,
1297    .query_buffer_age = dri2_fallback_query_buffer_age,
1298    .query_surface = dri2_query_surface,
1299    .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1300    .get_sync_values = dri2_x11_get_sync_values,
1301    .get_dri_drawable = dri2_surface_get_dri_drawable,
1302 };
1303
1304 static const __DRIswrastLoaderExtension swrast_loader_extension = {
1305    .base = { __DRI_SWRAST_LOADER, 1 },
1306
1307    .getDrawableInfo = swrastGetDrawableInfo,
1308    .putImage        = swrastPutImage,
1309    .getImage        = swrastGetImage,
1310 };
1311
1312 static const __DRIextension *swrast_loader_extensions[] = {
1313    &swrast_loader_extension.base,
1314    &image_lookup_extension.base,
1315    NULL,
1316 };
1317
1318 static int
1319 dri2_find_screen_for_display(const _EGLDisplay *disp, int fallback_screen)
1320 {
1321    const EGLAttrib *attr;
1322
1323    for (attr = disp->Options.Attribs; attr; attr += 2) {
1324       if (attr[0] == EGL_PLATFORM_X11_SCREEN_EXT)
1325          return attr[1];
1326    }
1327
1328    return fallback_screen;
1329 }
1330
1331 static EGLBoolean
1332 dri2_get_xcb_connection(_EGLDriver *drv, _EGLDisplay *disp,
1333                         struct dri2_egl_display *dri2_dpy)
1334 {
1335    xcb_screen_iterator_t s;
1336    int screen;
1337    const char *msg;
1338
1339    disp->DriverData = (void *) dri2_dpy;
1340    if (disp->PlatformDisplay == NULL) {
1341       dri2_dpy->conn = xcb_connect(NULL, &screen);
1342       dri2_dpy->own_device = true;
1343       screen = dri2_find_screen_for_display(disp, screen);
1344    } else {
1345       Display *dpy = disp->PlatformDisplay;
1346       dri2_dpy->conn = XGetXCBConnection(dpy);
1347       screen = DefaultScreen(dpy);
1348    }
1349
1350    if (!dri2_dpy->conn || xcb_connection_has_error(dri2_dpy->conn)) {
1351       msg = "xcb_connect failed";
1352       goto disconnect;
1353    }
1354
1355    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
1356    dri2_dpy->screen = get_xcb_screen(s, screen);
1357    if (!dri2_dpy->screen) {
1358       msg = "failed to get xcb screen";
1359       goto disconnect;
1360    }
1361
1362    return EGL_TRUE;
1363 disconnect:
1364    if (disp->PlatformDisplay == NULL)
1365       xcb_disconnect(dri2_dpy->conn);
1366
1367    return _eglError(EGL_BAD_ALLOC, msg);
1368 }
1369
1370 static EGLBoolean
1371 dri2_initialize_x11_swrast(_EGLDriver *drv, _EGLDisplay *disp)
1372 {
1373    _EGLDevice *dev;
1374    struct dri2_egl_display *dri2_dpy;
1375
1376    dri2_dpy = calloc(1, sizeof *dri2_dpy);
1377    if (!dri2_dpy)
1378       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1379
1380    dri2_dpy->fd = -1;
1381    if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1382       goto cleanup;
1383
1384    dev = _eglAddDevice(dri2_dpy->fd, true);
1385    if (!dev) {
1386       _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1387       goto cleanup;
1388    }
1389
1390    disp->Device = dev;
1391
1392    /*
1393     * Every hardware driver_name is set using strdup. Doing the same in
1394     * here will allow is to simply free the memory at dri2_terminate().
1395     */
1396    dri2_dpy->driver_name = strdup("swrast");
1397    if (!dri2_load_driver_swrast(disp))
1398       goto cleanup;
1399
1400    dri2_dpy->loader_extensions = swrast_loader_extensions;
1401
1402    if (!dri2_create_screen(disp))
1403       goto cleanup;
1404
1405    if (!dri2_setup_extensions(disp))
1406       goto cleanup;
1407
1408    dri2_setup_screen(disp);
1409
1410    if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, true, false))
1411       goto cleanup;
1412
1413    /* Fill vtbl last to prevent accidentally calling virtual function during
1414     * initialization.
1415     */
1416    dri2_dpy->vtbl = &dri2_x11_swrast_display_vtbl;
1417
1418    return EGL_TRUE;
1419
1420  cleanup:
1421    dri2_display_destroy(disp);
1422    return EGL_FALSE;
1423 }
1424
1425 static void
1426 dri2_x11_setup_swap_interval(_EGLDisplay *disp)
1427 {
1428    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1429    int arbitrary_max_interval = 1000;
1430
1431    /* default behavior for no SwapBuffers support: no vblank syncing
1432     * either.
1433     */
1434    dri2_dpy->min_swap_interval = 0;
1435    dri2_dpy->max_swap_interval = 0;
1436    dri2_dpy->default_swap_interval = 0;
1437
1438    if (!dri2_dpy->swap_available)
1439       return;
1440
1441    /* If we do have swapbuffers, then we can support pretty much any swap
1442     * interval.
1443     */
1444    dri2_setup_swap_interval(disp, arbitrary_max_interval);
1445 }
1446
1447 #ifdef HAVE_DRI3
1448
1449 static const __DRIextension *dri3_image_loader_extensions[] = {
1450    &dri3_image_loader_extension.base,
1451    &image_lookup_extension.base,
1452    &use_invalidate.base,
1453    &background_callable_extension.base,
1454    NULL,
1455 };
1456
1457 static EGLBoolean
1458 dri2_initialize_x11_dri3(_EGLDriver *drv, _EGLDisplay *disp)
1459 {
1460    _EGLDevice *dev;
1461    struct dri2_egl_display *dri2_dpy;
1462
1463    dri2_dpy = calloc(1, sizeof *dri2_dpy);
1464    if (!dri2_dpy)
1465       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1466
1467    dri2_dpy->fd = -1;
1468    if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1469       goto cleanup;
1470
1471    if (!dri3_x11_connect(dri2_dpy))
1472       goto cleanup;
1473
1474    dev = _eglAddDevice(dri2_dpy->fd, false);
1475    if (!dev) {
1476       _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1477       goto cleanup;
1478    }
1479
1480    disp->Device = dev;
1481
1482    if (!dri2_load_driver_dri3(disp))
1483       goto cleanup;
1484
1485    dri2_dpy->loader_extensions = dri3_image_loader_extensions;
1486
1487    dri2_dpy->swap_available = true;
1488    dri2_dpy->invalidate_available = true;
1489
1490    if (!dri2_create_screen(disp))
1491       goto cleanup;
1492
1493    if (!dri2_setup_extensions(disp))
1494       goto cleanup;
1495
1496    dri2_setup_screen(disp);
1497
1498    dri2_x11_setup_swap_interval(disp);
1499
1500    if (!dri2_dpy->is_different_gpu)
1501       disp->Extensions.KHR_image_pixmap = EGL_TRUE;
1502    disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
1503    disp->Extensions.CHROMIUM_sync_control = EGL_TRUE;
1504    disp->Extensions.EXT_buffer_age = EGL_TRUE;
1505
1506    dri2_set_WL_bind_wayland_display(drv, disp);
1507
1508    if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, false, true))
1509       goto cleanup;
1510
1511    dri2_dpy->loader_dri3_ext.core = dri2_dpy->core;
1512    dri2_dpy->loader_dri3_ext.image_driver = dri2_dpy->image_driver;
1513    dri2_dpy->loader_dri3_ext.flush = dri2_dpy->flush;
1514    dri2_dpy->loader_dri3_ext.tex_buffer = dri2_dpy->tex_buffer;
1515    dri2_dpy->loader_dri3_ext.image = dri2_dpy->image;
1516    dri2_dpy->loader_dri3_ext.config = dri2_dpy->config;
1517
1518    /* Fill vtbl last to prevent accidentally calling virtual function during
1519     * initialization.
1520     */
1521    dri2_dpy->vtbl = &dri3_x11_display_vtbl;
1522
1523    _eglLog(_EGL_INFO, "Using DRI3");
1524
1525    return EGL_TRUE;
1526
1527  cleanup:
1528    dri2_display_destroy(disp);
1529    return EGL_FALSE;
1530 }
1531 #endif
1532
1533 static const __DRIdri2LoaderExtension dri2_loader_extension_old = {
1534    .base = { __DRI_DRI2_LOADER, 2 },
1535
1536    .getBuffers           = dri2_x11_get_buffers,
1537    .flushFrontBuffer     = dri2_x11_flush_front_buffer,
1538    .getBuffersWithFormat = NULL,
1539 };
1540
1541 static const __DRIdri2LoaderExtension dri2_loader_extension = {
1542    .base = { __DRI_DRI2_LOADER, 3 },
1543
1544    .getBuffers           = dri2_x11_get_buffers,
1545    .flushFrontBuffer     = dri2_x11_flush_front_buffer,
1546    .getBuffersWithFormat = dri2_x11_get_buffers_with_format,
1547 };
1548
1549 static const __DRIextension *dri2_loader_extensions_old[] = {
1550    &dri2_loader_extension_old.base,
1551    &image_lookup_extension.base,
1552    &background_callable_extension.base,
1553    NULL,
1554 };
1555
1556 static const __DRIextension *dri2_loader_extensions[] = {
1557    &dri2_loader_extension.base,
1558    &image_lookup_extension.base,
1559    &use_invalidate.base,
1560    &background_callable_extension.base,
1561    NULL,
1562 };
1563
1564 static EGLBoolean
1565 dri2_initialize_x11_dri2(_EGLDriver *drv, _EGLDisplay *disp)
1566 {
1567    _EGLDevice *dev;
1568    struct dri2_egl_display *dri2_dpy;
1569
1570    dri2_dpy = calloc(1, sizeof *dri2_dpy);
1571    if (!dri2_dpy)
1572       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1573
1574    dri2_dpy->fd = -1;
1575    if (!dri2_get_xcb_connection(drv, disp, dri2_dpy))
1576       goto cleanup;
1577
1578    if (!dri2_x11_connect(dri2_dpy))
1579       goto cleanup;
1580
1581    dev = _eglAddDevice(dri2_dpy->fd, false);
1582    if (!dev) {
1583       _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice");
1584       goto cleanup;
1585    }
1586
1587    disp->Device = dev;
1588
1589    if (!dri2_load_driver(disp))
1590       goto cleanup;
1591
1592    if (dri2_dpy->dri2_minor >= 1)
1593       dri2_dpy->loader_extensions = dri2_loader_extensions;
1594    else
1595       dri2_dpy->loader_extensions = dri2_loader_extensions_old;
1596
1597    dri2_dpy->swap_available = (dri2_dpy->dri2_minor >= 2);
1598    dri2_dpy->invalidate_available = (dri2_dpy->dri2_minor >= 3);
1599
1600    if (!dri2_create_screen(disp))
1601       goto cleanup;
1602
1603    if (!dri2_setup_extensions(disp))
1604       goto cleanup;
1605
1606    dri2_setup_screen(disp);
1607
1608    dri2_x11_setup_swap_interval(disp);
1609
1610    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
1611    disp->Extensions.NOK_swap_region = EGL_TRUE;
1612    disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
1613    disp->Extensions.NV_post_sub_buffer = EGL_TRUE;
1614    disp->Extensions.CHROMIUM_sync_control = EGL_TRUE;
1615
1616    dri2_set_WL_bind_wayland_display(drv, disp);
1617
1618    if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, true, false))
1619       goto cleanup;
1620
1621    /* Fill vtbl last to prevent accidentally calling virtual function during
1622     * initialization.
1623     */
1624    dri2_dpy->vtbl = &dri2_x11_display_vtbl;
1625
1626    _eglLog(_EGL_INFO, "Using DRI2");
1627
1628    return EGL_TRUE;
1629
1630  cleanup:
1631    dri2_display_destroy(disp);
1632    return EGL_FALSE;
1633 }
1634
1635 EGLBoolean
1636 dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp)
1637 {
1638    EGLBoolean initialized = EGL_FALSE;
1639
1640    if (!disp->Options.ForceSoftware) {
1641 #ifdef HAVE_DRI3
1642       if (!env_var_as_boolean("LIBGL_DRI3_DISABLE", false))
1643          initialized = dri2_initialize_x11_dri3(drv, disp);
1644 #endif
1645
1646       if (!initialized)
1647          initialized = dri2_initialize_x11_dri2(drv, disp);
1648    }
1649
1650    if (!initialized)
1651       initialized = dri2_initialize_x11_swrast(drv, disp);
1652
1653    return initialized;
1654 }
1655
1656 void
1657 dri2_teardown_x11(struct dri2_egl_display *dri2_dpy)
1658 {
1659    if (dri2_dpy->own_device)
1660       xcb_disconnect(dri2_dpy->conn);
1661 }