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