src/egl/drivers/dri2/egl_dri2.c

   1 /*
   2  * Copyright © 2010 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 <stdlib.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <limits.h>
  32 #include <dlfcn.h>
  33 #include <fcntl.h>
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <xf86drm.h>
  37 #include <GL/gl.h>
  38 #include <GL/internal/dri_interface.h>
  39 #include <xcb/xcb.h>
  40 #include <xcb/dri2.h>
  41 #include <xcb/xfixes.h>
  42 #include <X11/Xlib-xcb.h>
  43
  44 #include <glapi/glapi.h>
  45 #include "eglconfig.h"
  46 #include "eglcontext.h"
  47 #include "egldisplay.h"
  48 #include "egldriver.h"
  49 #include "eglcurrent.h"
  50 #include "egllog.h"
  51 #include "eglsurface.h"
  52 #include "eglimage.h"
  53
  54 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  55
  56 struct dri2_egl_driver
  57 {
  58    _EGLDriver base;
  59
  60    void (*glFlush)(void);
  61 };
  62
  63 struct dri2_egl_display
  64 {
  65    xcb_connection_t         *conn;
  66    int                       dri2_major;
  67    int                       dri2_minor;
  68    __DRIscreen              *dri_screen;
  69    const __DRIconfig       **driver_configs;
  70    void                     *driver;
  71    __DRIcoreExtension       *core;
  72    __DRIdri2Extension       *dri2;
  73    __DRI2flushExtension     *flush;
  74    __DRItexBufferExtension  *tex_buffer;
  75    __DRIimageExtension      *image;
  76    int                       fd;
  77
  78    char                     *device_name;
  79    char                     *driver_name;
  80
  81    __DRIdri2LoaderExtension  loader_extension;
  82    __DRIimageLookupExtension image_lookup_extension;
  83    const __DRIextension     *extensions[3];
  84 };
  85
  86 struct dri2_egl_context
  87 {
  88    _EGLContext   base;
  89    __DRIcontext *dri_context;
  90 };
  91
  92 struct dri2_egl_surface
  93 {
  94    _EGLSurface          base;
  95    __DRIdrawable       *dri_drawable;
  96    xcb_drawable_t       drawable;
  97    __DRIbuffer          buffers[5];
  98    int                  buffer_count;
  99    xcb_xfixes_region_t  region;
 100    int                  have_fake_front;
 101    int                  swap_interval;
 102 };
 103
 104 struct dri2_egl_config
 105 {
 106    _EGLConfig         base;
 107    const __DRIconfig *dri_config;
 108 };
 109
 110 struct dri2_egl_image
 111 {
 112    _EGLImage   base;
 113    __DRIimage *dri_image;
 114 };
 115
 116 /* standard typecasts */
 117 _EGL_DRIVER_STANDARD_TYPECASTS(dri2_egl)
 118 _EGL_DRIVER_TYPECAST(dri2_egl_image, _EGLImage, obj)
 119
 120 EGLint dri2_to_egl_attribute_map[] = {
 121    0,
 122    EGL_BUFFER_SIZE,             /* __DRI_ATTRIB_BUFFER_SIZE */
 123    EGL_LEVEL,                   /* __DRI_ATTRIB_LEVEL */
 124    EGL_RED_SIZE,                /* __DRI_ATTRIB_RED_SIZE */
 125    EGL_GREEN_SIZE,              /* __DRI_ATTRIB_GREEN_SIZE */
 126    EGL_BLUE_SIZE,               /* __DRI_ATTRIB_BLUE_SIZE */
 127    EGL_LUMINANCE_SIZE,          /* __DRI_ATTRIB_LUMINANCE_SIZE */
 128    EGL_ALPHA_SIZE,              /* __DRI_ATTRIB_ALPHA_SIZE */
 129    0,                           /* __DRI_ATTRIB_ALPHA_MASK_SIZE */
 130    EGL_DEPTH_SIZE,              /* __DRI_ATTRIB_DEPTH_SIZE */
 131    EGL_STENCIL_SIZE,            /* __DRI_ATTRIB_STENCIL_SIZE */
 132    0,                           /* __DRI_ATTRIB_ACCUM_RED_SIZE */
 133    0,                           /* __DRI_ATTRIB_ACCUM_GREEN_SIZE */
 134    0,                           /* __DRI_ATTRIB_ACCUM_BLUE_SIZE */
 135    0,                           /* __DRI_ATTRIB_ACCUM_ALPHA_SIZE */
 136    EGL_SAMPLE_BUFFERS,          /* __DRI_ATTRIB_SAMPLE_BUFFERS */
 137    EGL_SAMPLES,                 /* __DRI_ATTRIB_SAMPLES */
 138    0,                           /* __DRI_ATTRIB_RENDER_TYPE, */
 139    0,                           /* __DRI_ATTRIB_CONFIG_CAVEAT */
 140    0,                           /* __DRI_ATTRIB_CONFORMANT */
 141    0,                           /* __DRI_ATTRIB_DOUBLE_BUFFER */
 142    0,                           /* __DRI_ATTRIB_STEREO */
 143    0,                           /* __DRI_ATTRIB_AUX_BUFFERS */
 144    0,                           /* __DRI_ATTRIB_TRANSPARENT_TYPE */
 145    0,                           /* __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE */
 146    0,                           /* __DRI_ATTRIB_TRANSPARENT_RED_VALUE */
 147    0,                           /* __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE */
 148    0,                           /* __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE */
 149    0,                           /* __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE */
 150    0,                           /* __DRI_ATTRIB_FLOAT_MODE */
 151    0,                           /* __DRI_ATTRIB_RED_MASK */
 152    0,                           /* __DRI_ATTRIB_GREEN_MASK */
 153    0,                           /* __DRI_ATTRIB_BLUE_MASK */
 154    0,                           /* __DRI_ATTRIB_ALPHA_MASK */
 155    EGL_MAX_PBUFFER_WIDTH,       /* __DRI_ATTRIB_MAX_PBUFFER_WIDTH */
 156    EGL_MAX_PBUFFER_HEIGHT,      /* __DRI_ATTRIB_MAX_PBUFFER_HEIGHT */
 157    EGL_MAX_PBUFFER_PIXELS,      /* __DRI_ATTRIB_MAX_PBUFFER_PIXELS */
 158    0,                           /* __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH */
 159    0,                           /* __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT */
 160    0,                           /* __DRI_ATTRIB_VISUAL_SELECT_GROUP */
 161    0,                           /* __DRI_ATTRIB_SWAP_METHOD */
 162    EGL_MAX_SWAP_INTERVAL,       /* __DRI_ATTRIB_MAX_SWAP_INTERVAL */
 163    EGL_MIN_SWAP_INTERVAL,       /* __DRI_ATTRIB_MIN_SWAP_INTERVAL */
 164    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGB */
 165    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA */
 166    0,                           /* __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE */
 167    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */
 168    0,                           /* __DRI_ATTRIB_YINVERTED */
 169 };
 170
 171 static void
 172 dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
 173                 int depth, xcb_visualtype_t *visual)
 174 {
 175    struct dri2_egl_config *conf;
 176    struct dri2_egl_display *dri2_dpy;
 177    _EGLConfig base;
 178    unsigned int attrib, value, double_buffer;
 179    EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
 180    int i;
 181
 182    dri2_dpy = disp->DriverData;
 183    _eglInitConfig(&base, disp, id);
 184
 185    i = 0;
 186    while (dri2_dpy->core->indexConfigAttrib(dri_config, i++, &attrib, &value)) {
 187       switch (attrib) {
 188       case __DRI_ATTRIB_RENDER_TYPE:
 189          if (value & __DRI_ATTRIB_RGBA_BIT)
 190             value = EGL_RGB_BUFFER;
 191          else if (value & __DRI_ATTRIB_LUMINANCE_BIT)
 192             value = EGL_LUMINANCE_BUFFER;
 193          else
 194             /* not valid */;
 195          _eglSetConfigKey(&base, EGL_COLOR_BUFFER_TYPE, value);
 196          break;
 197
 198       case __DRI_ATTRIB_CONFIG_CAVEAT:
 199          if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
 200             value = EGL_NON_CONFORMANT_CONFIG;
 201          else if (value & __DRI_ATTRIB_SLOW_BIT)
 202             value = EGL_SLOW_CONFIG;
 203          else
 204             value = EGL_NONE;
 205          _eglSetConfigKey(&base, EGL_CONFIG_CAVEAT, value);
 206          break;
 207
 208       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB:
 209          bind_to_texture_rgb = value;
 210          break;
 211
 212       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA:
 213          bind_to_texture_rgba = value;
 214          break;
 215
 216       case __DRI_ATTRIB_DOUBLE_BUFFER:
 217          double_buffer = value;
 218          break;
 219
 220       default:
 221          key = dri2_to_egl_attribute_map[attrib];
 222          if (key != 0)
 223             _eglSetConfigKey(&base, key, value);
 224          break;
 225       }
 226    }
 227
 228    /* In EGL, double buffer or not isn't a config attribute.  Pixmaps
 229     * surfaces are always single buffered, pbuffer surfaces are always
 230     * back buffers and windows can be either, selected by passing an
 231     * attribute at window surface construction time.  To support this
 232     * we ignore all double buffer configs and manipulate the buffer we
 233     * return in the getBuffer callback to get the behaviour we want. */
 234
 235    if (double_buffer)
 236       return;
 237
 238    if (visual != NULL) {
 239       if (depth != _eglGetConfigKey(&base, EGL_BUFFER_SIZE))
 240          return;
 241
 242       _eglSetConfigKey(&base, EGL_SURFACE_TYPE,
 243                        EGL_WINDOW_BIT | EGL_PIXMAP_BIT | EGL_PBUFFER_BIT |
 244                        EGL_SWAP_BEHAVIOR_PRESERVED_BIT);
 245
 246       _eglSetConfigKey(&base, EGL_NATIVE_VISUAL_ID, visual->visual_id);
 247       _eglSetConfigKey(&base, EGL_NATIVE_VISUAL_TYPE, visual->_class);
 248    } else {
 249       _eglSetConfigKey(&base, EGL_SURFACE_TYPE,
 250                        EGL_PIXMAP_BIT | EGL_PBUFFER_BIT);
 251    }
 252
 253    _eglSetConfigKey(&base, EGL_NATIVE_RENDERABLE, EGL_TRUE);
 254    _eglSetConfigKey(&base, EGL_BIND_TO_TEXTURE_RGB, bind_to_texture_rgb);
 255    if (_eglGetConfigKey(&base, EGL_ALPHA_SIZE) > 0)
 256       _eglSetConfigKey(&base,
 257                        EGL_BIND_TO_TEXTURE_RGBA, bind_to_texture_rgba);
 258
 259    _eglSetConfigKey(&base, EGL_RENDERABLE_TYPE, disp->ClientAPIsMask);
 260    _eglSetConfigKey(&base, EGL_CONFORMANT, disp->ClientAPIsMask);
 261
 262    if (!_eglValidateConfig(&base, EGL_FALSE)) {
 263       _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
 264       return;
 265    }
 266
 267    conf = malloc(sizeof *conf);
 268    if (conf != NULL) {
 269       memcpy(&conf->base, &base, sizeof base);
 270       conf->dri_config = dri_config;
 271       _eglAddConfig(disp, &conf->base);
 272    }
 273 }
 274
 275 /**
 276  * Process list of buffer received from the server
 277  *
 278  * Processes the list of buffers received in a reply from the server to either
 279  * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
 280  */
 281 static void
 282 dri2_process_buffers(struct dri2_egl_surface *dri2_surf,
 283                      xcb_dri2_dri2_buffer_t *buffers, unsigned count)
 284 {
 285    struct dri2_egl_display *dri2_dpy =
 286       dri2_egl_display(dri2_surf->base.Resource.Display);
 287    xcb_rectangle_t rectangle;
 288    int i;
 289
 290    dri2_surf->buffer_count = count;
 291    dri2_surf->have_fake_front = 0;
 292
 293    /* This assumes the DRI2 buffer attachment tokens matches the
 294     * __DRIbuffer tokens. */
 295    for (i = 0; i < count; i++) {
 296       dri2_surf->buffers[i].attachment = buffers[i].attachment;
 297       dri2_surf->buffers[i].name = buffers[i].name;
 298       dri2_surf->buffers[i].pitch = buffers[i].pitch;
 299       dri2_surf->buffers[i].cpp = buffers[i].cpp;
 300       dri2_surf->buffers[i].flags = buffers[i].flags;
 301
 302       /* We only use the DRI drivers single buffer configs.  This
 303        * means that if we try to render to a window, DRI2 will give us
 304        * the fake front buffer, which we'll use as a back buffer.
 305        * Note that EGL doesn't require that several clients rendering
 306        * to the same window must see the same aux buffers. */
 307       if (dri2_surf->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
 308          dri2_surf->have_fake_front = 1;
 309    }
 310
 311    if (dri2_surf->region != XCB_NONE)
 312       xcb_xfixes_destroy_region(dri2_dpy->conn, dri2_surf->region);
 313
 314    rectangle.x = 0;
 315    rectangle.y = 0;
 316    rectangle.width = dri2_surf->base.Width;
 317    rectangle.height = dri2_surf->base.Height;
 318    dri2_surf->region = xcb_generate_id(dri2_dpy->conn);
 319    xcb_xfixes_create_region(dri2_dpy->conn, dri2_surf->region, 1, &rectangle);
 320 }
 321
 322 static __DRIbuffer *
 323 dri2_get_buffers(__DRIdrawable * driDrawable,
 324                 int *width, int *height,
 325                 unsigned int *attachments, int count,
 326                 int *out_count, void *loaderPrivate)
 327 {
 328    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 329    struct dri2_egl_display *dri2_dpy =
 330       dri2_egl_display(dri2_surf->base.Resource.Display);
 331    xcb_dri2_dri2_buffer_t *buffers;
 332    xcb_dri2_get_buffers_reply_t *reply;
 333    xcb_dri2_get_buffers_cookie_t cookie;
 334
 335    cookie = xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
 336                                             dri2_surf->drawable,
 337                                             count, count, attachments);
 338    reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn, cookie, NULL);
 339    buffers = xcb_dri2_get_buffers_buffers (reply);
 340    if (buffers == NULL)
 341       return NULL;
 342
 343    *out_count = reply->count;
 344    dri2_surf->base.Width = *width = reply->width;
 345    dri2_surf->base.Height = *height = reply->height;
 346    dri2_process_buffers(dri2_surf, buffers, *out_count);
 347
 348    free(reply);
 349
 350    return dri2_surf->buffers;
 351 }
 352
 353 static void
 354 dri2_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 355 {
 356    /* FIXME: Does EGL support front buffer rendering at all? */
 357
 358 #if 0
 359    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 360
 361    dri2WaitGL(dri2_surf);
 362 #endif
 363 }
 364
 365 static __DRIimage *
 366 dri2_lookup_egl_image(__DRIcontext *context, void *image, void *data)
 367 {
 368    struct dri2_egl_context *dri2_ctx = data;
 369    _EGLDisplay *disp = dri2_ctx->base.Resource.Display;
 370    struct dri2_egl_image *dri2_img;
 371    _EGLImage *img;
 372
 373    img = _eglLookupImage(image, disp);
 374    if (img == NULL) {
 375       _eglError(EGL_BAD_PARAMETER, "dri2_lookup_egl_image");
 376       return NULL;
 377    }
 378
 379    dri2_img = dri2_egl_image(image);
 380
 381    return dri2_img->dri_image;
 382 }
 383
 384 static __DRIbuffer *
 385 dri2_get_buffers_with_format(__DRIdrawable * driDrawable,
 386                              int *width, int *height,
 387                              unsigned int *attachments, int count,
 388                              int *out_count, void *loaderPrivate)
 389 {
 390    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 391    struct dri2_egl_display *dri2_dpy =
 392       dri2_egl_display(dri2_surf->base.Resource.Display);
 393    xcb_dri2_dri2_buffer_t *buffers;
 394    xcb_dri2_get_buffers_with_format_reply_t *reply;
 395    xcb_dri2_get_buffers_with_format_cookie_t cookie;
 396    xcb_dri2_attach_format_t *format_attachments;
 397
 398    format_attachments = (xcb_dri2_attach_format_t *) attachments;
 399    cookie = xcb_dri2_get_buffers_with_format_unchecked (dri2_dpy->conn,
 400                                                         dri2_surf->drawable,
 401                                                         count, count,
 402                                                         format_attachments);
 403
 404    reply = xcb_dri2_get_buffers_with_format_reply (dri2_dpy->conn,
 405                                                    cookie, NULL);
 406    if (reply == NULL)
 407       return NULL;
 408
 409    buffers = xcb_dri2_get_buffers_with_format_buffers (reply);
 410    dri2_surf->base.Width = *width = reply->width;
 411    dri2_surf->base.Height = *height = reply->height;
 412    *out_count = reply->count;
 413    dri2_process_buffers(dri2_surf, buffers, *out_count);
 414
 415    free(reply);
 416
 417    return dri2_surf->buffers;
 418 }
 419
 420 #ifdef GLX_USE_TLS
 421 static const char dri_driver_format[] = "%.*s/tls/%s_dri.so";
 422 #else
 423 static const char dri_driver_format[] = "%.*s/%s_dri.so";
 424 #endif
 425
 426 static const char dri_driver_path[] = DEFAULT_DRIVER_DIR;
 427
 428 struct dri2_extension_match {
 429    const char *name;
 430    int version;
 431    int offset;
 432 };
 433
 434 static struct dri2_extension_match dri2_driver_extensions[] = {
 435    { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
 436    { __DRI_DRI2, 1, offsetof(struct dri2_egl_display, dri2) },
 437    { NULL }
 438 };
 439
 440 static struct dri2_extension_match dri2_core_extensions[] = {
 441    { __DRI2_FLUSH, 1, offsetof(struct dri2_egl_display, flush) },
 442    { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
 443    { __DRI_IMAGE, 1, offsetof(struct dri2_egl_display, image) },
 444    { NULL }
 445 };
 446
 447 static EGLBoolean
 448 dri2_bind_extensions(struct dri2_egl_display *dri2_dpy,
 449                      struct dri2_extension_match *matches,
 450                      const __DRIextension **extensions)
 451 {
 452    int i, j, ret = EGL_TRUE;
 453    void *field;
 454
 455    for (i = 0; extensions[i]; i++) {
 456       _eglLog(_EGL_DEBUG, "DRI2: found extension `%s'", extensions[i]->name);
 457       for (j = 0; matches[j].name; j++) {
 458          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 459              extensions[i]->version >= matches[j].version) {
 460             field = ((char *) dri2_dpy + matches[j].offset);
 461             *(const __DRIextension **) field = extensions[i];
 462             _eglLog(_EGL_INFO, "DRI2: found extension %s version %d",
 463                     extensions[i]->name, extensions[i]->version);
 464          }
 465       }
 466    }
 467
 468    for (j = 0; matches[j].name; j++) {
 469       field = ((char *) dri2_dpy + matches[j].offset);
 470       if (*(const __DRIextension **) field == NULL) {
 471          _eglLog(_EGL_FATAL, "DRI2: did not find extension %s version %d",
 472                  matches[j].name, matches[j].version);
 473          ret = EGL_FALSE;
 474       }
 475    }
 476
 477    return ret;
 478 }
 479
 480 static char *
 481 dri2_strndup(const char *s, int length)
 482 {
 483    char *d;
 484
 485    d = malloc(length + 1);
 486    if (d == NULL)
 487       return NULL;
 488
 489    memcpy(d, s, length);
 490    d[length] = '\0';
 491
 492    return d;
 493 }
 494
 495 static EGLBoolean
 496 dri2_connect(struct dri2_egl_display *dri2_dpy)
 497 {
 498    xcb_xfixes_query_version_reply_t *xfixes_query;
 499    xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
 500    xcb_dri2_query_version_reply_t *dri2_query;
 501    xcb_dri2_query_version_cookie_t dri2_query_cookie;
 502    xcb_dri2_connect_reply_t *connect;
 503    xcb_dri2_connect_cookie_t connect_cookie;
 504    xcb_generic_error_t *error;
 505    xcb_screen_iterator_t s;
 506
 507    xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
 508    xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
 509
 510    xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
 511                                                   XCB_XFIXES_MAJOR_VERSION,
 512                                                   XCB_XFIXES_MINOR_VERSION);
 513
 514    dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
 515                                                XCB_DRI2_MAJOR_VERSION,
 516                                                XCB_DRI2_MINOR_VERSION);
 517
 518    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 519    connect_cookie = xcb_dri2_connect_unchecked (dri2_dpy->conn,
 520                                                 s.data->root,
 521                                                 XCB_DRI2_DRIVER_TYPE_DRI);
 522
 523    xfixes_query =
 524       xcb_xfixes_query_version_reply (dri2_dpy->conn,
 525                                       xfixes_query_cookie, &error);
 526    if (xfixes_query == NULL ||
 527        error != NULL || xfixes_query->major_version < 2) {
 528       _eglLog(_EGL_FATAL, "DRI2: failed to query xfixes version");
 529       free(error);
 530       return EGL_FALSE;
 531    }
 532    free(xfixes_query);
 533
 534    dri2_query =
 535       xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
 536    if (dri2_query == NULL || error != NULL) {
 537       _eglLog(_EGL_FATAL, "DRI2: failed to query version");
 538       free(error);
 539       return EGL_FALSE;
 540    }
 541    dri2_dpy->dri2_major = dri2_query->major_version;
 542    dri2_dpy->dri2_minor = dri2_query->minor_version;
 543    free(dri2_query);
 544
 545    connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
 546    if (connect == NULL ||
 547        connect->driver_name_length + connect->device_name_length == 0) {
 548       _eglLog(_EGL_FATAL, "DRI2: failed to authenticate");
 549       return EGL_FALSE;
 550    }
 551
 552    dri2_dpy->device_name =
 553       dri2_strndup(xcb_dri2_connect_device_name (connect),
 554                    xcb_dri2_connect_device_name_length (connect));
 555
 556    dri2_dpy->driver_name =
 557       dri2_strndup(xcb_dri2_connect_driver_name (connect),
 558                    xcb_dri2_connect_driver_name_length (connect));
 559
 560    if (dri2_dpy->device_name == NULL || dri2_dpy->driver_name == NULL) {
 561       free(dri2_dpy->device_name);
 562       free(dri2_dpy->driver_name);
 563       free(connect);
 564       return EGL_FALSE;
 565    }
 566    free(connect);
 567
 568    return EGL_TRUE;
 569 }
 570
 571 static EGLBoolean
 572 dri2_authenticate(struct dri2_egl_display *dri2_dpy)
 573 {
 574    xcb_dri2_authenticate_reply_t *authenticate;
 575    xcb_dri2_authenticate_cookie_t authenticate_cookie;
 576    xcb_screen_iterator_t s;
 577    drm_magic_t magic;
 578
 579    if (drmGetMagic(dri2_dpy->fd, &magic)) {
 580       _eglLog(_EGL_FATAL, "DRI2: failed to get drm magic");
 581       return EGL_FALSE;
 582    }
 583
 584    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 585    authenticate_cookie =
 586       xcb_dri2_authenticate_unchecked(dri2_dpy->conn, s.data->root, magic);
 587    authenticate =
 588       xcb_dri2_authenticate_reply(dri2_dpy->conn, authenticate_cookie, NULL);
 589    if (authenticate == NULL || !authenticate->authenticated) {
 590       _eglLog(_EGL_FATAL, "DRI2: failed to authenticate");
 591       free(authenticate);
 592       return EGL_FALSE;
 593    }
 594
 595    free(authenticate);
 596
 597    return EGL_TRUE;
 598 }
 599
 600 static EGLBoolean
 601 dri2_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
 602                              _EGLDisplay *disp)
 603 {
 604    xcb_screen_iterator_t s;
 605    xcb_depth_iterator_t d;
 606    xcb_visualtype_t *visuals;
 607    int i, j, id;
 608
 609    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 610    d = xcb_screen_allowed_depths_iterator(s.data);
 611    id = 1;
 612    while (d.rem > 0) {
 613       EGLBoolean class_added[6] = { 0, };
 614
 615       visuals = xcb_depth_visuals(d.data);
 616       for (i = 0; i < xcb_depth_visuals_length(d.data); i++) {
 617          if (class_added[visuals[i]._class])
 618             continue;
 619
 620          class_added[visuals[i]._class] = EGL_TRUE;
 621          for (j = 0; dri2_dpy->driver_configs[j]; j++)
 622             dri2_add_config(disp, dri2_dpy->driver_configs[j],
 623                             id++, d.data->depth, &visuals[i]);
 624       }
 625
 626       xcb_depth_next(&d);
 627    }
 628
 629    if (!disp->NumConfigs) {
 630       _eglLog(_EGL_WARNING, "DRI2: failed to create any config");
 631       return EGL_FALSE;
 632    }
 633
 634    return EGL_TRUE;
 635 }
 636
 637 /**
 638  * Called via eglInitialize(), GLX_drv->API.Initialize().
 639  */
 640 static EGLBoolean
 641 dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp,
 642                 EGLint *major, EGLint *minor)
 643 {
 644    const __DRIextension **extensions;
 645    struct dri2_egl_display *dri2_dpy;
 646    char path[PATH_MAX], *search_paths, *p, *next, *end;
 647    unsigned int api_mask;
 648
 649    dri2_dpy = malloc(sizeof *dri2_dpy);
 650    if (!dri2_dpy)
 651       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 652
 653    disp->DriverData = (void *) dri2_dpy;
 654    if (disp->NativeDisplay == NULL) {
 655       dri2_dpy->conn = xcb_connect(0, 0);
 656       if (!dri2_dpy->conn) {
 657          _eglLog(_EGL_WARNING, "DRI2: xcb_connect failed");
 658          goto cleanup_dpy;
 659       }
 660    } else {
 661       dri2_dpy->conn = XGetXCBConnection(disp->NativeDisplay);
 662    }
 663
 664    if (dri2_dpy->conn == NULL)
 665       goto cleanup_conn;
 666
 667    if (dri2_dpy->conn) {
 668       if (!dri2_connect(dri2_dpy))
 669          goto cleanup_conn;
 670    }
 671
 672    search_paths = NULL;
 673    if (geteuid() == getuid()) {
 674       /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
 675       search_paths = getenv("LIBGL_DRIVERS_PATH");
 676    }
 677    if (search_paths == NULL)
 678       search_paths = DEFAULT_DRIVER_DIR;
 679
 680    dri2_dpy->driver = NULL;
 681    end = search_paths + strlen(search_paths);
 682    for (p = search_paths; p < end && dri2_dpy->driver == NULL; p = next + 1) {
 683       next = strchr(p, ':');
 684       if (next == NULL)
 685          next = end;
 686
 687       snprintf(path, sizeof path,
 688                dri_driver_format, (int) (next - p), p, dri2_dpy->driver_name);
 689       dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 690       if (dri2_dpy->driver == NULL)
 691          _eglLog(_EGL_DEBUG, "failed to open %s: %s\n", path, dlerror());
 692    }
 693
 694    if (dri2_dpy->driver == NULL) {
 695       _eglLog(_EGL_WARNING,
 696               "DRI2: failed to open any driver (search paths %s)",
 697               search_paths);
 698       goto cleanup_conn;
 699    }
 700
 701    _eglLog(_EGL_DEBUG, "DRI2: dlopen(%s)", path);
 702    extensions = dlsym(dri2_dpy->driver, __DRI_DRIVER_EXTENSIONS);
 703    if (extensions == NULL) {
 704       _eglLog(_EGL_WARNING,
 705               "DRI2: driver exports no extensions (%s)", dlerror());
 706       goto cleanup_driver;
 707    }
 708
 709    if (!dri2_bind_extensions(dri2_dpy, dri2_driver_extensions, extensions))
 710       goto cleanup_driver;
 711
 712    dri2_dpy->fd = open(dri2_dpy->device_name, O_RDWR);
 713    if (dri2_dpy->fd == -1) {
 714       _eglLog(_EGL_WARNING,
 715               "DRI2: could not open %s (%s)", dri2_dpy->device_name,
 716               strerror(errno));
 717       goto cleanup_driver;
 718    }
 719
 720    if (dri2_dpy->conn) {
 721       if (!dri2_authenticate(dri2_dpy))
 722          goto cleanup_fd;
 723    }
 724
 725    if (dri2_dpy->dri2_minor >= 1) {
 726       dri2_dpy->loader_extension.base.name = __DRI_DRI2_LOADER;
 727       dri2_dpy->loader_extension.base.version = 3;
 728       dri2_dpy->loader_extension.getBuffers = dri2_get_buffers;
 729       dri2_dpy->loader_extension.flushFrontBuffer = dri2_flush_front_buffer;
 730       dri2_dpy->loader_extension.getBuffersWithFormat =
 731          dri2_get_buffers_with_format;
 732    } else {
 733       dri2_dpy->loader_extension.base.name = __DRI_DRI2_LOADER;
 734       dri2_dpy->loader_extension.base.version = 2;
 735       dri2_dpy->loader_extension.getBuffers = dri2_get_buffers;
 736       dri2_dpy->loader_extension.flushFrontBuffer = dri2_flush_front_buffer;
 737       dri2_dpy->loader_extension.getBuffersWithFormat = NULL;
 738    }
 739
 740    dri2_dpy->image_lookup_extension.base.name = __DRI_IMAGE_LOOKUP;
 741    dri2_dpy->image_lookup_extension.base.version = 1;
 742    dri2_dpy->image_lookup_extension.lookupEGLImage = dri2_lookup_egl_image;
 743
 744    dri2_dpy->extensions[0] = &dri2_dpy->loader_extension.base;
 745    dri2_dpy->extensions[1] = &dri2_dpy->image_lookup_extension.base;
 746    dri2_dpy->extensions[2] = NULL;
 747
 748    dri2_dpy->dri_screen =
 749       dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd, dri2_dpy->extensions,
 750                                       &dri2_dpy->driver_configs, dri2_dpy);
 751
 752    if (dri2_dpy->dri_screen == NULL) {
 753       _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
 754       goto cleanup_fd;
 755    }
 756
 757    extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
 758    if (!dri2_bind_extensions(dri2_dpy, dri2_core_extensions, extensions))
 759       goto cleanup_dri_screen;
 760
 761    if (dri2_dpy->dri2->base.version >= 2)
 762       api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
 763    else
 764       api_mask = __DRI_API_OPENGL;
 765
 766    disp->ClientAPIsMask = 0;
 767    if (api_mask & (1 <<__DRI_API_OPENGL))
 768       disp->ClientAPIsMask |= EGL_OPENGL_BIT;
 769    if (api_mask & (1 <<__DRI_API_GLES))
 770       disp->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
 771    if (api_mask & (1 << __DRI_API_GLES2))
 772       disp->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
 773
 774    if (dri2_dpy->conn) {
 775       if (!dri2_add_configs_for_visuals(dri2_dpy, disp))
 776          goto cleanup_configs;
 777    }
 778
 779    disp->Extensions.KHR_image_base = EGL_TRUE;
 780    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
 781    disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
 782    disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
 783    disp->Extensions.NOK_swap_region = EGL_TRUE;
 784
 785    /* we're supporting EGL 1.4 */
 786    *major = 1;
 787    *minor = 4;
 788
 789    return EGL_TRUE;
 790
 791  cleanup_configs:
 792    _eglCleanupDisplay(disp);
 793  cleanup_dri_screen:
 794    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 795  cleanup_fd:
 796    close(dri2_dpy->fd);
 797  cleanup_driver:
 798    dlclose(dri2_dpy->driver);
 799  cleanup_conn:
 800    if (disp->NativeDisplay == NULL)
 801       xcb_disconnect(dri2_dpy->conn);
 802  cleanup_dpy:
 803    free(dri2_dpy);
 804
 805    return EGL_FALSE;
 806 }
 807
 808 /**
 809  * Called via eglTerminate(), drv->API.Terminate().
 810  */
 811 static EGLBoolean
 812 dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
 813 {
 814    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 815
 816    _eglReleaseDisplayResources(drv, disp);
 817    _eglCleanupDisplay(disp);
 818
 819    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 820    close(dri2_dpy->fd);
 821    dlclose(dri2_dpy->driver);
 822    if (disp->NativeDisplay == NULL)
 823       xcb_disconnect(dri2_dpy->conn);
 824    free(dri2_dpy);
 825    disp->DriverData = NULL;
 826
 827    return EGL_TRUE;
 828 }
 829
 830
 831 /**
 832  * Called via eglCreateContext(), drv->API.CreateContext().
 833  */
 834 static _EGLContext *
 835 dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
 836                     _EGLContext *share_list, const EGLint *attrib_list)
 837 {
 838    struct dri2_egl_context *dri2_ctx;
 839    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 840    struct dri2_egl_context *dri2_ctx_shared = dri2_egl_context(share_list);
 841    struct dri2_egl_config *dri2_config = dri2_egl_config(conf);
 842    int api;
 843
 844    dri2_ctx = malloc(sizeof *dri2_ctx);
 845    if (!dri2_ctx) {
 846       _eglError(EGL_BAD_ALLOC, "eglCreateContext");
 847       return NULL;
 848    }
 849
 850    if (!_eglInitContext(&dri2_ctx->base, disp, conf, attrib_list))
 851       goto cleanup;
 852
 853    switch (dri2_ctx->base.ClientAPI) {
 854    case EGL_OPENGL_ES_API:
 855       switch (dri2_ctx->base.ClientVersion) {
 856       case 1:
 857          api = __DRI_API_GLES;
 858          break;
 859       case 2:
 860          api = __DRI_API_GLES2;
 861          break;
 862       default:
 863          _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
 864          return NULL;
 865       }
 866       break;
 867    case EGL_OPENGL_API:
 868       api = __DRI_API_OPENGL;
 869       break;
 870    default:
 871       _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
 872       return NULL;
 873    }
 874
 875    if (dri2_dpy->dri2->base.version >= 2) {
 876       dri2_ctx->dri_context =
 877          dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
 878                                                 api,
 879                                                 dri2_config->dri_config,
 880                                                 dri2_ctx_shared ?
 881                                                 dri2_ctx_shared->dri_context : NULL,
 882                                                 dri2_ctx);
 883    } else if (api == __DRI_API_OPENGL) {
 884       dri2_ctx->dri_context =
 885          dri2_dpy->dri2->createNewContext(dri2_dpy->dri_screen,
 886                                           dri2_config->dri_config,
 887                                           dri2_ctx_shared ?
 888                                           dri2_ctx_shared->dri_context : NULL,
 889                                           dri2_ctx);
 890    } else {
 891       /* fail */
 892    }
 893
 894    if (!dri2_ctx->dri_context)
 895       goto cleanup;
 896
 897    return &dri2_ctx->base;
 898
 899  cleanup:
 900    free(dri2_ctx);
 901    return NULL;
 902 }
 903
 904 static EGLBoolean
 905 dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 906 {
 907    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 908    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 909
 910    if (_eglIsSurfaceBound(surf))
 911       return EGL_TRUE;
 912
 913    (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
 914
 915    xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable);
 916
 917    if (surf->Type == EGL_PBUFFER_BIT)
 918       xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable);
 919
 920    free(surf);
 921
 922    return EGL_TRUE;
 923 }
 924
 925 /**
 926  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
 927  */
 928 static EGLBoolean
 929 dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
 930                   _EGLSurface *rsurf, _EGLContext *ctx)
 931 {
 932    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
 933    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 934    struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
 935    struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
 936    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
 937    __DRIdrawable *ddraw, *rdraw;
 938    __DRIcontext *cctx;
 939
 940    /* bind the new context and return the "orphaned" one */
 941    if (!_eglBindContext(&ctx, &dsurf, &rsurf))
 942       return EGL_FALSE;
 943
 944    /* flush before context switch */
 945    if (ctx && dri2_drv->glFlush)
 946       dri2_drv->glFlush();
 947
 948    ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
 949    rdraw = (dri2_rsurf) ? dri2_rsurf->dri_drawable : NULL;
 950    cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
 951
 952    if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
 953        dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
 954       if (dsurf && !_eglIsSurfaceLinked(dsurf))
 955          dri2_destroy_surface(drv, disp, dsurf);
 956       if (rsurf && rsurf != dsurf && !_eglIsSurfaceLinked(dsurf))
 957          dri2_destroy_surface(drv, disp, rsurf);
 958       if (ctx != NULL && !_eglIsContextLinked(ctx))
 959          dri2_dpy->core->unbindContext(dri2_egl_context(ctx)->dri_context);
 960
 961       return EGL_TRUE;
 962    } else {
 963       _eglBindContext(&ctx, &dsurf, &rsurf);
 964
 965       return EGL_FALSE;
 966    }
 967 }
 968
 969 /**
 970  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
 971  */
 972 static _EGLSurface *
 973 dri2_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
 974                     _EGLConfig *conf, EGLNativeWindowType window,
 975                     const EGLint *attrib_list)
 976 {
 977    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 978    struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
 979    struct dri2_egl_surface *dri2_surf;
 980    xcb_get_geometry_cookie_t cookie;
 981    xcb_get_geometry_reply_t *reply;
 982    xcb_screen_iterator_t s;
 983    xcb_generic_error_t *error;
 984
 985    dri2_surf = malloc(sizeof *dri2_surf);
 986    if (!dri2_surf) {
 987       _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
 988       return NULL;
 989    }
 990
 991    if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
 992       goto cleanup_surf;
 993
 994    dri2_surf->region = XCB_NONE;
 995    if (type == EGL_PBUFFER_BIT) {
 996       dri2_surf->drawable = xcb_generate_id(dri2_dpy->conn);
 997       s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 998       xcb_create_pixmap(dri2_dpy->conn,
 999                         _eglGetConfigKey(conf, EGL_BUFFER_SIZE),
1000                         dri2_surf->drawable, s.data->root,
1001                         dri2_surf->base.Width, dri2_surf->base.Height);
1002    } else {
1003       dri2_surf->drawable = window;
1004    }
1005
1006    dri2_surf->dri_drawable =
1007       (*dri2_dpy->dri2->createNewDrawable) (dri2_dpy->dri_screen,
1008                                             dri2_conf->dri_config, dri2_surf);
1009    if (dri2_surf->dri_drawable == NULL) {
1010       _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
1011       goto cleanup_pixmap;
1012    }
1013
1014    xcb_dri2_create_drawable (dri2_dpy->conn, dri2_surf->drawable);
1015
1016    if (type != EGL_PBUFFER_BIT) {
1017       cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
1018       reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
1019       if (reply == NULL || error != NULL) {
1020          _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1021          free(error);
1022          goto cleanup_dri_drawable;
1023       }
1024
1025       dri2_surf->base.Width = reply->width;
1026       dri2_surf->base.Height = reply->height;
1027       free(reply);
1028    }
1029
1030    return &dri2_surf->base;
1031
1032  cleanup_dri_drawable:
1033    dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
1034  cleanup_pixmap:
1035    if (type == EGL_PBUFFER_BIT)
1036       xcb_free_pixmap(dri2_dpy->conn, dri2_surf->drawable);
1037  cleanup_surf:
1038    free(dri2_surf);
1039
1040    return NULL;
1041 }
1042
1043 /**
1044  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1045  */
1046 static _EGLSurface *
1047 dri2_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
1048                            _EGLConfig *conf, EGLNativeWindowType window,
1049                            const EGLint *attrib_list)
1050 {
1051    return dri2_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
1052                               window, attrib_list);
1053 }
1054
1055 static _EGLSurface *
1056 dri2_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
1057                            _EGLConfig *conf, EGLNativePixmapType pixmap,
1058                            const EGLint *attrib_list)
1059 {
1060    return dri2_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
1061                               pixmap, attrib_list);
1062 }
1063
1064 static _EGLSurface *
1065 dri2_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
1066                             _EGLConfig *conf, const EGLint *attrib_list)
1067 {
1068    return dri2_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
1069                               XCB_WINDOW_NONE, attrib_list);
1070 }
1071
1072 static EGLBoolean
1073 dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp,
1074                  _EGLSurface *draw, xcb_xfixes_region_t region)
1075 {
1076    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1077    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1078    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1079    _EGLContext *ctx;
1080    xcb_dri2_copy_region_cookie_t cookie;
1081
1082    if (dri2_drv->glFlush) {
1083       ctx = _eglGetCurrentContext();
1084       if (ctx && ctx->DrawSurface == &dri2_surf->base)
1085          dri2_drv->glFlush();
1086    }
1087
1088    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1089
1090 #if 0
1091    /* FIXME: Add support for dri swapbuffers, that'll give us swap
1092     * interval and page flipping (at least for fullscreen windows) as
1093     * well as the page flip event.  Unless surface->SwapBehavior is
1094     * EGL_BUFFER_PRESERVED. */
1095 #if __DRI2_FLUSH_VERSION >= 2
1096    if (pdraw->psc->f)
1097       (*pdraw->psc->f->flushInvalidate)(pdraw->driDrawable);
1098 #endif
1099 #endif
1100
1101    if (!dri2_surf->have_fake_front)
1102       return EGL_TRUE;
1103
1104    cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
1105                                            dri2_surf->drawable,
1106                                            region,
1107                                            XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
1108                                            XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT);
1109    free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
1110
1111    return EGL_TRUE;
1112 }
1113
1114 static EGLBoolean
1115 dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
1116 {
1117    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1118
1119    return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1120 }
1121
1122 static EGLBoolean
1123 dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
1124                          EGLint numRects, const EGLint *rects)
1125 {
1126    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1127    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1128    EGLBoolean ret;
1129    xcb_xfixes_region_t region;
1130    xcb_rectangle_t rectangles[16];
1131    int i;
1132
1133    if (numRects > ARRAY_SIZE(rectangles))
1134       return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1135
1136    /* FIXME: Invert y here? */
1137    for (i = 0; i < numRects; i++) {
1138       rectangles[i].x = rects[i * 4];
1139       rectangles[i].y = rects[i * 4 + 1];
1140       rectangles[i].width = rects[i * 4 + 2];
1141       rectangles[i].height = rects[i * 4 + 3];
1142    }
1143
1144    region = xcb_generate_id(dri2_dpy->conn);
1145    xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
1146    ret = dri2_copy_region(drv, disp, draw, region);
1147    xcb_xfixes_destroy_region(dri2_dpy->conn, region);
1148
1149    return ret;
1150 }
1151
1152 /*
1153  * Called from eglGetProcAddress() via drv->API.GetProcAddress().
1154  */
1155 static _EGLProc
1156 dri2_get_proc_address(_EGLDriver *drv, const char *procname)
1157 {
1158    /* FIXME: Do we need to support lookup of EGL symbols too? */
1159
1160    return (_EGLProc) _glapi_get_proc_address(procname);
1161 }
1162
1163 static EGLBoolean
1164 dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
1165 {
1166    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1167    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(ctx->DrawSurface);
1168
1169    /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
1170     * we need to copy fake to real here.*/
1171
1172    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1173
1174    return EGL_TRUE;
1175 }
1176
1177 static EGLBoolean
1178 dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
1179 {
1180    if (engine != EGL_CORE_NATIVE_ENGINE)
1181       return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
1182    /* glXWaitX(); */
1183
1184    return EGL_TRUE;
1185 }
1186
1187 static void
1188 dri2_unload(_EGLDriver *drv)
1189 {
1190    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1191    free(dri2_drv);
1192 }
1193
1194 static EGLBoolean
1195 dri2_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1196                   EGLNativePixmapType target)
1197 {
1198    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1199    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1200    xcb_gcontext_t gc;
1201
1202    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1203
1204    gc = xcb_generate_id(dri2_dpy->conn);
1205    xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
1206    xcb_copy_area(dri2_dpy->conn,
1207                   dri2_surf->drawable,
1208                   target,
1209                   gc,
1210                   0, 0,
1211                   0, 0,
1212                   dri2_surf->base.Width,
1213                   dri2_surf->base.Height);
1214    xcb_free_gc(dri2_dpy->conn, gc);
1215
1216    return EGL_TRUE;
1217 }
1218
1219 static EGLBoolean
1220 dri2_bind_tex_image(_EGLDriver *drv,
1221                     _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1222 {
1223    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1224    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1225    struct dri2_egl_context *dri2_ctx;
1226    _EGLContext *ctx;
1227    GLint format, target;
1228
1229    ctx = _eglGetCurrentContext();
1230    dri2_ctx = dri2_egl_context(ctx);
1231
1232    if (buffer != EGL_BACK_BUFFER) {
1233       _eglError(EGL_BAD_PARAMETER, "eglBindTexImage");
1234       return EGL_FALSE;
1235    }
1236
1237    /* We allow binding pixmaps too... Not conformat, but we can do it
1238     * for free and it's useful for X compositors.  Supposedly there's
1239     * a EGL_NOKIA_texture_from_pixmap extension that allows that, but
1240     * I couldn't find it at this time. */
1241    if ((dri2_surf->base.Type & (EGL_PBUFFER_BIT | EGL_PIXMAP_BIT)) == 0) {
1242       _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
1243       return EGL_FALSE;
1244    }
1245
1246    switch (dri2_surf->base.TextureFormat) {
1247    case EGL_TEXTURE_RGB:
1248       format = __DRI_TEXTURE_FORMAT_RGB;
1249       break;
1250    case EGL_TEXTURE_RGBA:
1251       format = __DRI_TEXTURE_FORMAT_RGBA;
1252       break;
1253    default:
1254       _eglError(EGL_BAD_MATCH, "eglBindTexImage");
1255       return EGL_FALSE;
1256    }
1257
1258    switch (dri2_surf->base.TextureTarget) {
1259    case EGL_TEXTURE_2D:
1260       target = GL_TEXTURE_2D;
1261       break;
1262    default:
1263       _eglError(EGL_BAD_PARAMETER, "eglBindTexImage");
1264       return EGL_FALSE;
1265    }
1266
1267    (*dri2_dpy->tex_buffer->setTexBuffer2)(dri2_ctx->dri_context,
1268                                           target, format,
1269                                           dri2_surf->dri_drawable);
1270
1271    return dri2_surf->base.BoundToTexture = EGL_TRUE;
1272 }
1273
1274 static EGLBoolean
1275 dri2_release_tex_image(_EGLDriver *drv,
1276                        _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1277 {
1278    return EGL_TRUE;
1279 }
1280
1281 static _EGLImage *
1282 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
1283                              EGLClientBuffer buffer, const EGLint *attr_list)
1284 {
1285    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1286    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1287    struct dri2_egl_image *dri2_img;
1288    unsigned int attachments[1];
1289    xcb_drawable_t drawable;
1290    xcb_dri2_get_buffers_cookie_t buffers_cookie;
1291    xcb_dri2_get_buffers_reply_t *buffers_reply;
1292    xcb_dri2_dri2_buffer_t *buffers;
1293    xcb_get_geometry_cookie_t geometry_cookie;
1294    xcb_get_geometry_reply_t *geometry_reply;
1295    xcb_generic_error_t *error;
1296    int stride, format;
1297
1298    drawable = (xcb_drawable_t) buffer;
1299    xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
1300    attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
1301    buffers_cookie =
1302       xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
1303                                       drawable, 1, 1, attachments);
1304    geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
1305    buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
1306                                                buffers_cookie, NULL);
1307    buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
1308    if (buffers == NULL) {
1309       return NULL;
1310    }
1311
1312    geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
1313                                             geometry_cookie, &error);
1314    if (geometry_reply == NULL || error != NULL) {
1315       _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1316       free(error);
1317       free(buffers_reply);
1318    }
1319
1320    switch (geometry_reply->depth) {
1321    case 16:
1322       format = __DRI_IMAGE_FORMAT_RGB565;
1323       break;
1324    case 24:
1325       format = __DRI_IMAGE_FORMAT_XRGB8888;
1326       break;
1327    case 32:
1328       format = __DRI_IMAGE_FORMAT_ARGB8888;
1329       break;
1330    default:
1331       _eglError(EGL_BAD_PARAMETER,
1332                 "dri2_create_image_khr: unsupported pixmap depth");
1333       free(buffers_reply);
1334       free(geometry_reply);
1335       return NULL;
1336    }
1337
1338    dri2_img = malloc(sizeof *dri2_img);
1339    if (!dri2_img) {
1340       free(buffers_reply);
1341       free(geometry_reply);
1342       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1343       return EGL_NO_IMAGE_KHR;
1344    }
1345
1346    if (!_eglInitImage(&dri2_img->base, disp, attr_list)) {
1347       free(buffers_reply);
1348       free(geometry_reply);
1349       return EGL_NO_IMAGE_KHR;
1350    }
1351
1352    stride = buffers[0].pitch / buffers[0].cpp;
1353    dri2_img->dri_image =
1354       dri2_dpy->image->createImageFromName(dri2_ctx->dri_context,
1355                                            buffers_reply->width,
1356                                            buffers_reply->height,
1357                                            format,
1358                                            buffers[0].name,
1359                                            stride,
1360                                            dri2_img);
1361
1362    free(buffers_reply);
1363    free(geometry_reply);
1364
1365    return &dri2_img->base;
1366 }
1367
1368 static _EGLImage *
1369 dri2_create_image_khr_renderbuffer(_EGLDisplay *disp, _EGLContext *ctx,
1370                                    EGLClientBuffer buffer,
1371                                    const EGLint *attr_list)
1372 {
1373    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1374    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1375    struct dri2_egl_image *dri2_img;
1376    GLuint renderbuffer = (GLuint) buffer;
1377
1378    if (renderbuffer == 0) {
1379       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1380       return EGL_NO_IMAGE_KHR;
1381    }
1382
1383    dri2_img = malloc(sizeof *dri2_img);
1384    if (!dri2_img) {
1385       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1386       return EGL_NO_IMAGE_KHR;
1387    }
1388
1389    if (!_eglInitImage(&dri2_img->base, disp, attr_list))
1390       return EGL_NO_IMAGE_KHR;
1391
1392    dri2_img->dri_image =
1393       dri2_dpy->image->createImageFromRenderbuffer(dri2_ctx->dri_context,
1394                                                    renderbuffer,
1395                                                    dri2_img);
1396
1397    return &dri2_img->base;
1398 }
1399
1400 static _EGLImage *
1401 dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
1402                       _EGLContext *ctx, EGLenum target,
1403                       EGLClientBuffer buffer, const EGLint *attr_list)
1404 {
1405    switch (target) {
1406    case EGL_NATIVE_PIXMAP_KHR:
1407       return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
1408    case EGL_GL_RENDERBUFFER_KHR:
1409       return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
1410    default:
1411       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1412       return EGL_NO_IMAGE_KHR;
1413    }
1414 }
1415
1416 static EGLBoolean
1417 dri2_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
1418 {
1419    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1420    struct dri2_egl_image *dri2_img = dri2_egl_image(image);
1421
1422    dri2_dpy->image->destroyImage(dri2_img->dri_image);
1423    free(dri2_img);
1424
1425    return EGL_TRUE;
1426 }
1427
1428 /**
1429  * This is the main entrypoint into the driver, called by libEGL.
1430  * Create a new _EGLDriver object and init its dispatch table.
1431  */
1432 _EGLDriver *
1433 _eglMain(const char *args)
1434 {
1435    struct dri2_egl_driver *dri2_drv;
1436
1437    dri2_drv = malloc(sizeof *dri2_drv);
1438    if (!dri2_drv)
1439       return NULL;
1440
1441    memset(dri2_drv, 0, sizeof *dri2_drv);
1442    _eglInitDriverFallbacks(&dri2_drv->base);
1443    dri2_drv->base.API.Initialize = dri2_initialize;
1444    dri2_drv->base.API.Terminate = dri2_terminate;
1445    dri2_drv->base.API.CreateContext = dri2_create_context;
1446    dri2_drv->base.API.MakeCurrent = dri2_make_current;
1447    dri2_drv->base.API.CreateWindowSurface = dri2_create_window_surface;
1448    dri2_drv->base.API.CreatePixmapSurface = dri2_create_pixmap_surface;
1449    dri2_drv->base.API.CreatePbufferSurface = dri2_create_pbuffer_surface;
1450    dri2_drv->base.API.DestroySurface = dri2_destroy_surface;
1451    dri2_drv->base.API.SwapBuffers = dri2_swap_buffers;
1452    dri2_drv->base.API.GetProcAddress = dri2_get_proc_address;
1453    dri2_drv->base.API.WaitClient = dri2_wait_client;
1454    dri2_drv->base.API.WaitNative = dri2_wait_native;
1455    dri2_drv->base.API.CopyBuffers = dri2_copy_buffers;
1456    dri2_drv->base.API.BindTexImage = dri2_bind_tex_image;
1457    dri2_drv->base.API.ReleaseTexImage = dri2_release_tex_image;
1458    dri2_drv->base.API.CreateImageKHR = dri2_create_image_khr;
1459    dri2_drv->base.API.DestroyImageKHR = dri2_destroy_image_khr;
1460    dri2_drv->base.API.SwapBuffersRegionNOK = dri2_swap_buffers_region;
1461
1462    dri2_drv->base.Name = "DRI2";
1463    dri2_drv->base.Unload = dri2_unload;
1464
1465    dri2_drv->glFlush =
1466       (void (*)(void)) dri2_get_proc_address(&dri2_drv->base, "glFlush");
1467
1468    return &dri2_drv->base;
1469 }