src/gallium/state_trackers/egl/x11/native_dri2.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.8
   4  *
   5  * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include "util/u_memory.h"
  27 #include "util/u_math.h"
  28 #include "util/u_format.h"
  29 #include "util/u_inlines.h"
  30 #include "util/u_hash_table.h"
  31 #include "pipe/p_compiler.h"
  32 #include "pipe/p_screen.h"
  33 #include "pipe/p_context.h"
  34 #include "pipe/p_state.h"
  35 #include "state_tracker/drm_driver.h"
  36 #include "egllog.h"
  37
  38 #include "native_x11.h"
  39 #include "x11_screen.h"
  40
  41 #ifdef GLX_DIRECT_RENDERING
  42
  43 enum dri2_surface_type {
  44    DRI2_SURFACE_TYPE_WINDOW,
  45    DRI2_SURFACE_TYPE_PIXMAP,
  46 };
  47
  48 struct dri2_display {
  49    struct native_display base;
  50    Display *dpy;
  51    boolean own_dpy;
  52
  53    struct native_event_handler *event_handler;
  54
  55    struct x11_screen *xscr;
  56    int xscr_number;
  57    const char *dri_driver;
  58    int dri_major, dri_minor;
  59
  60    struct dri2_config *configs;
  61    int num_configs;
  62
  63    struct util_hash_table *surfaces;
  64 };
  65
  66 struct dri2_surface {
  67    struct native_surface base;
  68    Drawable drawable;
  69    enum dri2_surface_type type;
  70    enum pipe_format color_format;
  71    struct dri2_display *dri2dpy;
  72
  73    unsigned int server_stamp;
  74    unsigned int client_stamp;
  75    int width, height;
  76    struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
  77    uint valid_mask;
  78
  79    boolean have_back, have_fake;
  80
  81    struct x11_drawable_buffer *last_xbufs;
  82    int last_num_xbufs;
  83 };
  84
  85 struct dri2_config {
  86    struct native_config base;
  87 };
  88
  89 static INLINE struct dri2_display *
  90 dri2_display(const struct native_display *ndpy)
  91 {
  92    return (struct dri2_display *) ndpy;
  93 }
  94
  95 static INLINE struct dri2_surface *
  96 dri2_surface(const struct native_surface *nsurf)
  97 {
  98    return (struct dri2_surface *) nsurf;
  99 }
 100
 101 static INLINE struct dri2_config *
 102 dri2_config(const struct native_config *nconf)
 103 {
 104    return (struct dri2_config *) nconf;
 105 }
 106
 107 /**
 108  * Process the buffers returned by the server.
 109  */
 110 static void
 111 dri2_surface_process_drawable_buffers(struct native_surface *nsurf,
 112                                       struct x11_drawable_buffer *xbufs,
 113                                       int num_xbufs)
 114 {
 115    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 116    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
 117    struct pipe_resource templ;
 118    struct winsys_handle whandle;
 119    uint valid_mask;
 120    int i;
 121
 122    /* free the old textures */
 123    for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++)
 124       pipe_resource_reference(&dri2surf->textures[i], NULL);
 125    dri2surf->valid_mask = 0x0;
 126
 127    dri2surf->have_back = FALSE;
 128    dri2surf->have_fake = FALSE;
 129
 130    if (!xbufs)
 131       return;
 132
 133    memset(&templ, 0, sizeof(templ));
 134    templ.target = PIPE_TEXTURE_2D;
 135    templ.last_level = 0;
 136    templ.width0 = dri2surf->width;
 137    templ.height0 = dri2surf->height;
 138    templ.depth0 = 1;
 139    templ.format = dri2surf->color_format;
 140    templ.bind = PIPE_BIND_RENDER_TARGET;
 141
 142    valid_mask = 0x0;
 143    for (i = 0; i < num_xbufs; i++) {
 144       struct x11_drawable_buffer *xbuf = &xbufs[i];
 145       const char *desc;
 146       enum native_attachment natt;
 147
 148       switch (xbuf->attachment) {
 149       case DRI2BufferFrontLeft:
 150          natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 151          desc = "DRI2 Front Buffer";
 152          break;
 153       case DRI2BufferFakeFrontLeft:
 154          natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 155          desc = "DRI2 Fake Front Buffer";
 156          dri2surf->have_fake = TRUE;
 157          break;
 158       case DRI2BufferBackLeft:
 159          natt = NATIVE_ATTACHMENT_BACK_LEFT;
 160          desc = "DRI2 Back Buffer";
 161          dri2surf->have_back = TRUE;
 162          break;
 163       default:
 164          desc = NULL;
 165          break;
 166       }
 167
 168       if (!desc || dri2surf->textures[natt]) {
 169          if (!desc)
 170             _eglLog(_EGL_WARNING, "unknown buffer %d", xbuf->attachment);
 171          else
 172             _eglLog(_EGL_WARNING, "both real and fake front buffers are listed");
 173          continue;
 174       }
 175
 176       memset(&whandle, 0, sizeof(whandle));
 177       whandle.stride = xbuf->pitch;
 178       whandle.handle = xbuf->name;
 179       dri2surf->textures[natt] = dri2dpy->base.screen->resource_from_handle(
 180          dri2dpy->base.screen, &templ, &whandle);
 181       if (dri2surf->textures[natt])
 182          valid_mask |= 1 << natt;
 183    }
 184
 185    dri2surf->valid_mask = valid_mask;
 186 }
 187
 188 /**
 189  * Get the buffers from the server.
 190  */
 191 static void
 192 dri2_surface_get_buffers(struct native_surface *nsurf, uint buffer_mask)
 193 {
 194    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 195    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
 196    unsigned int dri2atts[NUM_NATIVE_ATTACHMENTS * 2];
 197    int num_ins, num_outs, att;
 198    struct x11_drawable_buffer *xbufs;
 199    uint bpp = util_format_get_blocksizebits(dri2surf->color_format);
 200    boolean with_format = FALSE; /* never ask for depth/stencil */
 201
 202    /* We must get the front on servers which doesn't support with format
 203     * due to a silly bug in core dri2. You can't copy to/from a buffer
 204     * that you haven't requested and you recive BadValue errors */
 205    if (dri2surf->dri2dpy->dri_minor < 1) {
 206       with_format = FALSE;
 207       buffer_mask |= (1 << NATIVE_ATTACHMENT_FRONT_LEFT);
 208    }
 209
 210    /* prepare the attachments */
 211    num_ins = 0;
 212    for (att = 0; att < NUM_NATIVE_ATTACHMENTS; att++) {
 213       if (native_attachment_mask_test(buffer_mask, att)) {
 214          unsigned int dri2att;
 215
 216          switch (att) {
 217          case NATIVE_ATTACHMENT_FRONT_LEFT:
 218             dri2att = DRI2BufferFrontLeft;
 219             break;
 220          case NATIVE_ATTACHMENT_BACK_LEFT:
 221             dri2att = DRI2BufferBackLeft;
 222             break;
 223          case NATIVE_ATTACHMENT_FRONT_RIGHT:
 224             dri2att = DRI2BufferFrontRight;
 225             break;
 226          case NATIVE_ATTACHMENT_BACK_RIGHT:
 227             dri2att = DRI2BufferBackRight;
 228             break;
 229          default:
 230             assert(0);
 231             dri2att = 0;
 232             break;
 233          }
 234
 235          dri2atts[num_ins++] = dri2att;
 236          if (with_format)
 237             dri2atts[num_ins++] = bpp;
 238       }
 239    }
 240    if (with_format)
 241       num_ins /= 2;
 242
 243    xbufs = x11_drawable_get_buffers(dri2dpy->xscr, dri2surf->drawable,
 244                                     &dri2surf->width, &dri2surf->height,
 245                                     dri2atts, with_format, num_ins, &num_outs);
 246
 247    /* we should be able to do better... */
 248    if (xbufs && dri2surf->last_num_xbufs == num_outs &&
 249        memcmp(dri2surf->last_xbufs, xbufs, sizeof(*xbufs) * num_outs) == 0) {
 250       FREE(xbufs);
 251       dri2surf->client_stamp = dri2surf->server_stamp;
 252       return;
 253    }
 254
 255    dri2_surface_process_drawable_buffers(&dri2surf->base, xbufs, num_outs);
 256
 257    dri2surf->server_stamp++;
 258    dri2surf->client_stamp = dri2surf->server_stamp;
 259
 260    if (dri2surf->last_xbufs)
 261       FREE(dri2surf->last_xbufs);
 262    dri2surf->last_xbufs = xbufs;
 263    dri2surf->last_num_xbufs = num_outs;
 264 }
 265
 266 /**
 267  * Update the buffers of the surface.  This is a slow function due to the
 268  * round-trip to the server.
 269  */
 270 static boolean
 271 dri2_surface_update_buffers(struct native_surface *nsurf, uint buffer_mask)
 272 {
 273    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 274
 275    dri2_surface_get_buffers(&dri2surf->base, buffer_mask);
 276
 277    return ((dri2surf->valid_mask & buffer_mask) == buffer_mask);
 278 }
 279
 280 /**
 281  * Return TRUE if the surface receives DRI2_InvalidateBuffers events.
 282  */
 283 static INLINE boolean
 284 dri2_surface_receive_events(struct native_surface *nsurf)
 285 {
 286    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 287    return (dri2surf->dri2dpy->dri_minor >= 3);
 288 }
 289
 290 static boolean
 291 dri2_surface_flush_frontbuffer(struct native_surface *nsurf)
 292 {
 293    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 294    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
 295
 296    /* copy to real front buffer */
 297    if (dri2surf->have_fake)
 298       x11_drawable_copy_buffers(dri2dpy->xscr, dri2surf->drawable,
 299             0, 0, dri2surf->width, dri2surf->height,
 300             DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
 301
 302    /* force buffers to be updated in next validation call */
 303    if (!dri2_surface_receive_events(&dri2surf->base)) {
 304       dri2surf->server_stamp++;
 305       dri2dpy->event_handler->invalid_surface(&dri2dpy->base,
 306             &dri2surf->base, dri2surf->server_stamp);
 307    }
 308
 309    return TRUE;
 310 }
 311
 312 static boolean
 313 dri2_surface_swap_buffers(struct native_surface *nsurf)
 314 {
 315    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 316    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
 317
 318    /* copy to front buffer */
 319    if (dri2surf->have_back)
 320       x11_drawable_copy_buffers(dri2dpy->xscr, dri2surf->drawable,
 321             0, 0, dri2surf->width, dri2surf->height,
 322             DRI2BufferBackLeft, DRI2BufferFrontLeft);
 323
 324    /* and update fake front buffer */
 325    if (dri2surf->have_fake)
 326       x11_drawable_copy_buffers(dri2dpy->xscr, dri2surf->drawable,
 327             0, 0, dri2surf->width, dri2surf->height,
 328             DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
 329
 330    /* force buffers to be updated in next validation call */
 331    if (!dri2_surface_receive_events(&dri2surf->base)) {
 332       dri2surf->server_stamp++;
 333       dri2dpy->event_handler->invalid_surface(&dri2dpy->base,
 334             &dri2surf->base, dri2surf->server_stamp);
 335    }
 336
 337    return TRUE;
 338 }
 339
 340 static boolean
 341 dri2_surface_validate(struct native_surface *nsurf, uint attachment_mask,
 342                       unsigned int *seq_num, struct pipe_resource **textures,
 343                       int *width, int *height)
 344 {
 345    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 346
 347    if (dri2surf->server_stamp != dri2surf->client_stamp ||
 348        (dri2surf->valid_mask & attachment_mask) != attachment_mask) {
 349       if (!dri2_surface_update_buffers(&dri2surf->base, attachment_mask))
 350          return FALSE;
 351    }
 352
 353    if (seq_num)
 354       *seq_num = dri2surf->client_stamp;
 355
 356    if (textures) {
 357       int att;
 358       for (att = 0; att < NUM_NATIVE_ATTACHMENTS; att++) {
 359          if (native_attachment_mask_test(attachment_mask, att)) {
 360             struct pipe_resource *ptex = dri2surf->textures[att];
 361
 362             textures[att] = NULL;
 363             pipe_resource_reference(&textures[att], ptex);
 364          }
 365       }
 366    }
 367
 368    if (width)
 369       *width = dri2surf->width;
 370    if (height)
 371       *height = dri2surf->height;
 372
 373    return TRUE;
 374 }
 375
 376 static void
 377 dri2_surface_wait(struct native_surface *nsurf)
 378 {
 379    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 380    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
 381
 382    if (dri2surf->have_fake) {
 383       x11_drawable_copy_buffers(dri2dpy->xscr, dri2surf->drawable,
 384             0, 0, dri2surf->width, dri2surf->height,
 385             DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
 386    }
 387 }
 388
 389 static void
 390 dri2_surface_destroy(struct native_surface *nsurf)
 391 {
 392    struct dri2_surface *dri2surf = dri2_surface(nsurf);
 393    int i;
 394
 395    if (dri2surf->last_xbufs)
 396       FREE(dri2surf->last_xbufs);
 397
 398    for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
 399       struct pipe_resource *ptex = dri2surf->textures[i];
 400       pipe_resource_reference(&ptex, NULL);
 401    }
 402
 403    if (dri2surf->drawable) {
 404       x11_drawable_enable_dri2(dri2surf->dri2dpy->xscr,
 405             dri2surf->drawable, FALSE);
 406
 407       util_hash_table_remove(dri2surf->dri2dpy->surfaces,
 408             (void *) dri2surf->drawable);
 409    }
 410    FREE(dri2surf);
 411 }
 412
 413 static struct dri2_surface *
 414 dri2_display_create_surface(struct native_display *ndpy,
 415                             enum dri2_surface_type type,
 416                             Drawable drawable,
 417                             const struct native_config *nconf)
 418 {
 419    struct dri2_display *dri2dpy = dri2_display(ndpy);
 420    struct dri2_config *dri2conf = dri2_config(nconf);
 421    struct dri2_surface *dri2surf;
 422
 423    dri2surf = CALLOC_STRUCT(dri2_surface);
 424    if (!dri2surf)
 425       return NULL;
 426
 427    dri2surf->dri2dpy = dri2dpy;
 428    dri2surf->type = type;
 429    dri2surf->drawable = drawable;
 430    dri2surf->color_format = dri2conf->base.color_format;
 431
 432    dri2surf->base.destroy = dri2_surface_destroy;
 433    dri2surf->base.swap_buffers = dri2_surface_swap_buffers;
 434    dri2surf->base.flush_frontbuffer = dri2_surface_flush_frontbuffer;
 435    dri2surf->base.validate = dri2_surface_validate;
 436    dri2surf->base.wait = dri2_surface_wait;
 437
 438    if (drawable) {
 439       x11_drawable_enable_dri2(dri2dpy->xscr, drawable, TRUE);
 440       /* initialize the geometry */
 441       dri2_surface_update_buffers(&dri2surf->base, 0x0);
 442
 443       util_hash_table_set(dri2surf->dri2dpy->surfaces,
 444             (void *) dri2surf->drawable, (void *) &dri2surf->base);
 445    }
 446
 447    return dri2surf;
 448 }
 449
 450 static struct native_surface *
 451 dri2_display_create_window_surface(struct native_display *ndpy,
 452                                    EGLNativeWindowType win,
 453                                    const struct native_config *nconf)
 454 {
 455    struct dri2_surface *dri2surf;
 456
 457    dri2surf = dri2_display_create_surface(ndpy, DRI2_SURFACE_TYPE_WINDOW,
 458          (Drawable) win, nconf);
 459    return (dri2surf) ? &dri2surf->base : NULL;
 460 }
 461
 462 static struct native_surface *
 463 dri2_display_create_pixmap_surface(struct native_display *ndpy,
 464                                    EGLNativePixmapType pix,
 465                                    const struct native_config *nconf)
 466 {
 467    struct dri2_surface *dri2surf;
 468
 469    dri2surf = dri2_display_create_surface(ndpy, DRI2_SURFACE_TYPE_PIXMAP,
 470          (Drawable) pix, nconf);
 471    return (dri2surf) ? &dri2surf->base : NULL;
 472 }
 473
 474 static int
 475 choose_color_format(const __GLcontextModes *mode, enum pipe_format formats[32])
 476 {
 477    int count = 0;
 478
 479    switch (mode->rgbBits) {
 480    case 32:
 481       formats[count++] = PIPE_FORMAT_B8G8R8A8_UNORM;
 482       formats[count++] = PIPE_FORMAT_A8R8G8B8_UNORM;
 483       break;
 484    case 24:
 485       formats[count++] = PIPE_FORMAT_B8G8R8X8_UNORM;
 486       formats[count++] = PIPE_FORMAT_X8R8G8B8_UNORM;
 487       formats[count++] = PIPE_FORMAT_B8G8R8A8_UNORM;
 488       formats[count++] = PIPE_FORMAT_A8R8G8B8_UNORM;
 489       break;
 490    case 16:
 491       formats[count++] = PIPE_FORMAT_B5G6R5_UNORM;
 492       break;
 493    default:
 494       break;
 495    }
 496
 497    return count;
 498 }
 499
 500 static boolean
 501 is_format_supported(struct pipe_screen *screen,
 502                     enum pipe_format fmt, unsigned sample_count, boolean is_color)
 503 {
 504    return screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, sample_count,
 505          (is_color) ? PIPE_BIND_RENDER_TARGET :
 506          PIPE_BIND_DEPTH_STENCIL, 0);
 507 }
 508
 509 static boolean
 510 dri2_display_convert_config(struct native_display *ndpy,
 511                             const __GLcontextModes *mode,
 512                             struct native_config *nconf)
 513 {
 514    enum pipe_format formats[32];
 515    int num_formats, i;
 516    int sample_count = 0;
 517
 518    if (!(mode->renderType & GLX_RGBA_BIT) || !mode->rgbMode)
 519       return FALSE;
 520
 521    /* skip single-buffered configs */
 522    if (!mode->doubleBufferMode)
 523       return FALSE;
 524
 525    /* only interested in native renderable configs */
 526    if (!mode->xRenderable || !mode->drawableType)
 527       return FALSE;
 528
 529    nconf->buffer_mask = 1 << NATIVE_ATTACHMENT_FRONT_LEFT;
 530    if (mode->doubleBufferMode)
 531       nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_BACK_LEFT;
 532    if (mode->stereoMode) {
 533       nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_FRONT_RIGHT;
 534       if (mode->doubleBufferMode)
 535          nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_BACK_RIGHT;
 536    }
 537
 538    /* choose color format */
 539    num_formats = choose_color_format(mode, formats);
 540    for (i = 0; i < num_formats; i++) {
 541       if (is_format_supported(ndpy->screen, formats[i], sample_count, TRUE)) {
 542          nconf->color_format = formats[i];
 543          break;
 544       }
 545    }
 546    if (nconf->color_format == PIPE_FORMAT_NONE)
 547       return FALSE;
 548
 549    if (mode->drawableType & GLX_WINDOW_BIT)
 550       nconf->window_bit = TRUE;
 551    if (mode->drawableType & GLX_PIXMAP_BIT)
 552       nconf->pixmap_bit = TRUE;
 553
 554    nconf->native_visual_id = mode->visualID;
 555    nconf->native_visual_type = mode->visualType;
 556    nconf->level = mode->level;
 557    nconf->samples = mode->samples;
 558
 559    nconf->slow_config = (mode->visualRating == GLX_SLOW_CONFIG);
 560
 561    if (mode->transparentPixel == GLX_TRANSPARENT_RGB) {
 562       nconf->transparent_rgb = TRUE;
 563       nconf->transparent_rgb_values[0] = mode->transparentRed;
 564       nconf->transparent_rgb_values[1] = mode->transparentGreen;
 565       nconf->transparent_rgb_values[2] = mode->transparentBlue;
 566    }
 567
 568    return TRUE;
 569 }
 570
 571 static const struct native_config **
 572 dri2_display_get_configs(struct native_display *ndpy, int *num_configs)
 573 {
 574    struct dri2_display *dri2dpy = dri2_display(ndpy);
 575    const struct native_config **configs;
 576    int i;
 577
 578    /* first time */
 579    if (!dri2dpy->configs) {
 580       const __GLcontextModes *modes;
 581       int num_modes, count;
 582
 583       modes = x11_screen_get_glx_configs(dri2dpy->xscr);
 584       if (!modes)
 585          return NULL;
 586       num_modes = x11_context_modes_count(modes);
 587
 588       dri2dpy->configs = CALLOC(num_modes, sizeof(*dri2dpy->configs));
 589       if (!dri2dpy->configs)
 590          return NULL;
 591
 592       count = 0;
 593       for (i = 0; i < num_modes; i++) {
 594          struct native_config *nconf = &dri2dpy->configs[count].base;
 595          if (dri2_display_convert_config(&dri2dpy->base, modes, nconf))
 596             count++;
 597          modes = modes->next;
 598       }
 599
 600       dri2dpy->num_configs = count;
 601    }
 602
 603    configs = MALLOC(dri2dpy->num_configs * sizeof(*configs));
 604    if (configs) {
 605       for (i = 0; i < dri2dpy->num_configs; i++)
 606          configs[i] = (const struct native_config *) &dri2dpy->configs[i];
 607       if (num_configs)
 608          *num_configs = dri2dpy->num_configs;
 609    }
 610
 611    return configs;
 612 }
 613
 614 static boolean
 615 dri2_display_is_pixmap_supported(struct native_display *ndpy,
 616                                  EGLNativePixmapType pix,
 617                                  const struct native_config *nconf)
 618 {
 619    struct dri2_display *dri2dpy = dri2_display(ndpy);
 620    uint depth, nconf_depth;
 621
 622    depth = x11_drawable_get_depth(dri2dpy->xscr, (Drawable) pix);
 623    nconf_depth = util_format_get_blocksizebits(nconf->color_format);
 624
 625    /* simple depth match for now */
 626    return (depth == nconf_depth || (depth == 24 && depth + 8 == nconf_depth));
 627 }
 628
 629 static int
 630 dri2_display_get_param(struct native_display *ndpy,
 631                        enum native_param_type param)
 632 {
 633    int val;
 634
 635    switch (param) {
 636    case NATIVE_PARAM_USE_NATIVE_BUFFER:
 637       /* DRI2GetBuffers use the native buffers */
 638       val = TRUE;
 639       break;
 640    default:
 641       val = 0;
 642       break;
 643    }
 644
 645    return val;
 646 }
 647
 648 static void
 649 dri2_display_destroy(struct native_display *ndpy)
 650 {
 651    struct dri2_display *dri2dpy = dri2_display(ndpy);
 652
 653    if (dri2dpy->configs)
 654       FREE(dri2dpy->configs);
 655
 656    if (dri2dpy->base.screen)
 657       dri2dpy->base.screen->destroy(dri2dpy->base.screen);
 658
 659    if (dri2dpy->surfaces)
 660       util_hash_table_destroy(dri2dpy->surfaces);
 661
 662    if (dri2dpy->xscr)
 663       x11_screen_destroy(dri2dpy->xscr);
 664    if (dri2dpy->own_dpy)
 665       XCloseDisplay(dri2dpy->dpy);
 666    FREE(dri2dpy);
 667 }
 668
 669 static void
 670 dri2_display_invalidate_buffers(struct x11_screen *xscr, Drawable drawable,
 671                                 void *user_data)
 672 {
 673    struct native_display *ndpy = (struct native_display* ) user_data;
 674    struct dri2_display *dri2dpy = dri2_display(ndpy);
 675    struct native_surface *nsurf;
 676    struct dri2_surface *dri2surf;
 677
 678    nsurf = (struct native_surface *)
 679       util_hash_table_get(dri2dpy->surfaces, (void *) drawable);
 680    if (!nsurf)
 681       return;
 682
 683    dri2surf = dri2_surface(nsurf);
 684
 685    dri2surf->server_stamp++;
 686    dri2dpy->event_handler->invalid_surface(&dri2dpy->base,
 687          &dri2surf->base, dri2surf->server_stamp);
 688 }
 689
 690 /**
 691  * Initialize DRI2 and pipe screen.
 692  */
 693 static boolean
 694 dri2_display_init_screen(struct native_display *ndpy)
 695 {
 696    struct dri2_display *dri2dpy = dri2_display(ndpy);
 697    int fd;
 698
 699    if (!x11_screen_support(dri2dpy->xscr, X11_SCREEN_EXTENSION_DRI2) ||
 700        !x11_screen_support(dri2dpy->xscr, X11_SCREEN_EXTENSION_GLX)) {
 701       _eglLog(_EGL_WARNING, "GLX/DRI2 is not supported");
 702       return FALSE;
 703    }
 704
 705    dri2dpy->dri_driver = x11_screen_probe_dri2(dri2dpy->xscr,
 706          &dri2dpy->dri_major, &dri2dpy->dri_minor);
 707
 708    fd = x11_screen_enable_dri2(dri2dpy->xscr,
 709          dri2_display_invalidate_buffers, &dri2dpy->base);
 710    if (fd < 0)
 711       return FALSE;
 712
 713    dri2dpy->base.screen =
 714       dri2dpy->event_handler->new_drm_screen(&dri2dpy->base,
 715             dri2dpy->dri_driver, fd);
 716    if (!dri2dpy->base.screen) {
 717       _eglLog(_EGL_WARNING, "failed to create DRM screen");
 718       return FALSE;
 719    }
 720
 721    return TRUE;
 722 }
 723
 724 static unsigned
 725 dri2_display_hash_table_hash(void *key)
 726 {
 727    XID drawable = pointer_to_uintptr(key);
 728    return (unsigned) drawable;
 729 }
 730
 731 static int
 732 dri2_display_hash_table_compare(void *key1, void *key2)
 733 {
 734    return (key1 - key2);
 735 }
 736
 737 struct native_display *
 738 x11_create_dri2_display(Display *dpy,
 739                         struct native_event_handler *event_handler,
 740                         void *user_data)
 741 {
 742    struct dri2_display *dri2dpy;
 743
 744    dri2dpy = CALLOC_STRUCT(dri2_display);
 745    if (!dri2dpy)
 746       return NULL;
 747
 748    dri2dpy->event_handler = event_handler;
 749    dri2dpy->base.user_data = user_data;
 750
 751    dri2dpy->dpy = dpy;
 752    if (!dri2dpy->dpy) {
 753       dri2dpy->dpy = XOpenDisplay(NULL);
 754       if (!dri2dpy->dpy) {
 755          dri2_display_destroy(&dri2dpy->base);
 756          return NULL;
 757       }
 758       dri2dpy->own_dpy = TRUE;
 759    }
 760
 761    dri2dpy->xscr_number = DefaultScreen(dri2dpy->dpy);
 762    dri2dpy->xscr = x11_screen_create(dri2dpy->dpy, dri2dpy->xscr_number);
 763    if (!dri2dpy->xscr) {
 764       dri2_display_destroy(&dri2dpy->base);
 765       return NULL;
 766    }
 767
 768    if (!dri2_display_init_screen(&dri2dpy->base)) {
 769       dri2_display_destroy(&dri2dpy->base);
 770       return NULL;
 771    }
 772
 773    dri2dpy->surfaces = util_hash_table_create(dri2_display_hash_table_hash,
 774          dri2_display_hash_table_compare);
 775    if (!dri2dpy->surfaces) {
 776       dri2_display_destroy(&dri2dpy->base);
 777       return NULL;
 778    }
 779
 780    dri2dpy->base.destroy = dri2_display_destroy;
 781    dri2dpy->base.get_param = dri2_display_get_param;
 782    dri2dpy->base.get_configs = dri2_display_get_configs;
 783    dri2dpy->base.is_pixmap_supported = dri2_display_is_pixmap_supported;
 784    dri2dpy->base.create_window_surface = dri2_display_create_window_surface;
 785    dri2dpy->base.create_pixmap_surface = dri2_display_create_pixmap_surface;
 786
 787    return &dri2dpy->base;
 788 }
 789
 790 #else /* GLX_DIRECT_RENDERING */
 791
 792 struct native_display *
 793 x11_create_dri2_display(Display *dpy,
 794                         struct native_event_handler *event_handler,
 795                         void *user_data)
 796 {
 797    return NULL;
 798 }
 799
 800 #endif /* GLX_DIRECT_RENDERING */