src/gallium/state_trackers/dri/drm/dri2.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.9
   4  *
   5  * Copyright 2009, VMware, Inc.
   6  * All Rights Reserved.
   7  * Copyright (C) 2010 LunarG Inc.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  * Authors:
  27  *    Keith Whitwell <keithw@vmware.com>
  28  *    Jakob Bornecrantz <wallbraker@gmail.com>
  29  *    Chia-I Wu <olv@lunarg.com>
  30  */
  31
  32 #include "util/u_memory.h"
  33 #include "util/u_inlines.h"
  34 #include "util/u_format.h"
  35 #include "util/u_debug.h"
  36 #include "state_tracker/drm_driver.h"
  37
  38 #include "dri_screen.h"
  39 #include "dri_context.h"
  40 #include "dri_drawable.h"
  41 #include "dri2_buffer.h"
  42
  43 /**
  44  * DRI2 flush extension.
  45  */
  46 static void
  47 dri2_flush_drawable(__DRIdrawable *dPriv)
  48 {
  49    struct dri_context *ctx = dri_get_current(dPriv->driScreenPriv);
  50    struct dri_drawable *drawable = dri_drawable(dPriv);
  51
  52    struct pipe_resource *ptex = drawable->textures[ST_ATTACHMENT_BACK_LEFT];
  53
  54    if (ctx) {
  55       if (ptex && ctx->pp && drawable->textures[ST_ATTACHMENT_DEPTH_STENCIL])
  56          pp_run(ctx->pp, ptex, ptex, drawable->textures[ST_ATTACHMENT_DEPTH_STENCIL]);
  57
  58       ctx->st->flush(ctx->st, 0, NULL);
  59    }
  60 }
  61
  62 static void
  63 dri2_invalidate_drawable(__DRIdrawable *dPriv)
  64 {
  65    struct dri_drawable *drawable = dri_drawable(dPriv);
  66
  67    dri2InvalidateDrawable(dPriv);
  68    drawable->dPriv->lastStamp = *drawable->dPriv->pStamp;
  69
  70    p_atomic_inc(&drawable->base.stamp);
  71 }
  72
  73 static const __DRI2flushExtension dri2FlushExtension = {
  74     { __DRI2_FLUSH, __DRI2_FLUSH_VERSION },
  75     dri2_flush_drawable,
  76     dri2_invalidate_drawable,
  77 };
  78
  79 /**
  80  * Retrieve __DRIbuffer from the DRI loader.
  81  */
  82 static __DRIbuffer *
  83 dri2_drawable_get_buffers(struct dri_drawable *drawable,
  84                           const enum st_attachment_type *statts,
  85                           unsigned *count)
  86 {
  87    __DRIdrawable *dri_drawable = drawable->dPriv;
  88    struct __DRIdri2LoaderExtensionRec *loader = drawable->sPriv->dri2.loader;
  89    boolean with_format;
  90    __DRIbuffer *buffers;
  91    int num_buffers;
  92    unsigned attachments[10];
  93    unsigned num_attachments, i;
  94
  95    assert(loader);
  96    with_format = dri_with_format(drawable->sPriv);
  97
  98    num_attachments = 0;
  99
 100    /* for Xserver 1.6.0 (DRI2 version 1) we always need to ask for the front */
 101    if (!with_format)
 102       attachments[num_attachments++] = __DRI_BUFFER_FRONT_LEFT;
 103
 104    for (i = 0; i < *count; i++) {
 105       enum pipe_format format;
 106       unsigned bind;
 107       int att, bpp;
 108
 109       dri_drawable_get_format(drawable, statts[i], &format, &bind);
 110       if (format == PIPE_FORMAT_NONE)
 111          continue;
 112
 113       switch (statts[i]) {
 114       case ST_ATTACHMENT_FRONT_LEFT:
 115          /* already added */
 116          if (!with_format)
 117             continue;
 118          att = __DRI_BUFFER_FRONT_LEFT;
 119          break;
 120       case ST_ATTACHMENT_BACK_LEFT:
 121          att = __DRI_BUFFER_BACK_LEFT;
 122          break;
 123       case ST_ATTACHMENT_FRONT_RIGHT:
 124          att = __DRI_BUFFER_FRONT_RIGHT;
 125          break;
 126       case ST_ATTACHMENT_BACK_RIGHT:
 127          att = __DRI_BUFFER_BACK_RIGHT;
 128          break;
 129       case ST_ATTACHMENT_DEPTH_STENCIL:
 130          att = __DRI_BUFFER_DEPTH_STENCIL;
 131          break;
 132       default:
 133          att = -1;
 134          break;
 135       }
 136
 137       bpp = util_format_get_blocksizebits(format);
 138
 139       if (att >= 0) {
 140          attachments[num_attachments++] = att;
 141          if (with_format) {
 142             attachments[num_attachments++] = bpp;
 143          }
 144       }
 145    }
 146
 147    if (with_format) {
 148       num_attachments /= 2;
 149       buffers = loader->getBuffersWithFormat(dri_drawable,
 150             &dri_drawable->w, &dri_drawable->h,
 151             attachments, num_attachments,
 152             &num_buffers, dri_drawable->loaderPrivate);
 153    }
 154    else {
 155       buffers = loader->getBuffers(dri_drawable,
 156             &dri_drawable->w, &dri_drawable->h,
 157             attachments, num_attachments,
 158             &num_buffers, dri_drawable->loaderPrivate);
 159    }
 160
 161    if (buffers) {
 162       /* set one cliprect to cover the whole dri_drawable */
 163       dri_drawable->x = 0;
 164       dri_drawable->y = 0;
 165       dri_drawable->backX = 0;
 166       dri_drawable->backY = 0;
 167       dri_drawable->numClipRects = 1;
 168       dri_drawable->pClipRects[0].x1 = 0;
 169       dri_drawable->pClipRects[0].y1 = 0;
 170       dri_drawable->pClipRects[0].x2 = dri_drawable->w;
 171       dri_drawable->pClipRects[0].y2 = dri_drawable->h;
 172       dri_drawable->numBackClipRects = 1;
 173       dri_drawable->pBackClipRects[0].x1 = 0;
 174       dri_drawable->pBackClipRects[0].y1 = 0;
 175       dri_drawable->pBackClipRects[0].x2 = dri_drawable->w;
 176       dri_drawable->pBackClipRects[0].y2 = dri_drawable->h;
 177
 178       *count = num_buffers;
 179    }
 180
 181    return buffers;
 182 }
 183
 184 /**
 185  * Process __DRIbuffer and convert them into pipe_resources.
 186  */
 187 static void
 188 dri2_drawable_process_buffers(struct dri_drawable *drawable,
 189                               __DRIbuffer *buffers, unsigned count)
 190 {
 191    struct dri_screen *screen = dri_screen(drawable->sPriv);
 192    __DRIdrawable *dri_drawable = drawable->dPriv;
 193    struct pipe_resource templ;
 194    struct winsys_handle whandle;
 195    boolean have_depth = FALSE;
 196    unsigned i, bind;
 197
 198    if (drawable->old_num == count &&
 199        drawable->old_w == dri_drawable->w &&
 200        drawable->old_h == dri_drawable->h &&
 201        memcmp(drawable->old, buffers, sizeof(__DRIbuffer) * count) == 0)
 202       return;
 203
 204    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
 205       pipe_resource_reference(&drawable->textures[i], NULL);
 206
 207    memset(&templ, 0, sizeof(templ));
 208    templ.target = screen->target;
 209    templ.last_level = 0;
 210    templ.width0 = dri_drawable->w;
 211    templ.height0 = dri_drawable->h;
 212    templ.depth0 = 1;
 213    templ.array_size = 1;
 214
 215    memset(&whandle, 0, sizeof(whandle));
 216
 217    for (i = 0; i < count; i++) {
 218       __DRIbuffer *buf = &buffers[i];
 219       enum st_attachment_type statt;
 220       enum pipe_format format;
 221
 222       switch (buf->attachment) {
 223       case __DRI_BUFFER_FRONT_LEFT:
 224          if (!screen->auto_fake_front) {
 225             statt = ST_ATTACHMENT_INVALID;
 226             break;
 227          }
 228          /* fallthrough */
 229       case __DRI_BUFFER_FAKE_FRONT_LEFT:
 230          statt = ST_ATTACHMENT_FRONT_LEFT;
 231          break;
 232       case __DRI_BUFFER_BACK_LEFT:
 233          statt = ST_ATTACHMENT_BACK_LEFT;
 234          break;
 235       case __DRI_BUFFER_DEPTH:
 236       case __DRI_BUFFER_DEPTH_STENCIL:
 237       case __DRI_BUFFER_STENCIL:
 238          /* use only the first depth/stencil buffer */
 239          if (!have_depth) {
 240             have_depth = TRUE;
 241             statt = ST_ATTACHMENT_DEPTH_STENCIL;
 242          }
 243          else {
 244             statt = ST_ATTACHMENT_INVALID;
 245          }
 246          break;
 247       default:
 248          statt = ST_ATTACHMENT_INVALID;
 249          break;
 250       }
 251
 252       dri_drawable_get_format(drawable, statt, &format, &bind);
 253       if (statt == ST_ATTACHMENT_INVALID || format == PIPE_FORMAT_NONE)
 254          continue;
 255
 256       templ.format = format;
 257       templ.bind = bind;
 258       whandle.handle = buf->name;
 259       whandle.stride = buf->pitch;
 260
 261       drawable->textures[statt] =
 262          screen->base.screen->resource_from_handle(screen->base.screen,
 263                &templ, &whandle);
 264    }
 265
 266    drawable->old_num = count;
 267    drawable->old_w = dri_drawable->w;
 268    drawable->old_h = dri_drawable->h;
 269    memcpy(drawable->old, buffers, sizeof(__DRIbuffer) * count);
 270 }
 271
 272 static __DRIbuffer *
 273 dri2_allocate_buffer(__DRIscreen *sPriv,
 274                      unsigned attachment, unsigned format,
 275                      int width, int height)
 276 {
 277    struct dri_screen *screen = dri_screen(sPriv);
 278    struct dri2_buffer *buffer;
 279    struct pipe_resource templ;
 280    enum pipe_format pf;
 281    unsigned bind = 0;
 282    struct winsys_handle whandle;
 283
 284    switch (attachment) {
 285       case __DRI_BUFFER_FRONT_LEFT:
 286       case __DRI_BUFFER_FAKE_FRONT_LEFT:
 287          bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 288          break;
 289       case __DRI_BUFFER_BACK_LEFT:
 290          bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 291          break;
 292       case __DRI_BUFFER_DEPTH:
 293       case __DRI_BUFFER_DEPTH_STENCIL:
 294       case __DRI_BUFFER_STENCIL:
 295             bind = PIPE_BIND_DEPTH_STENCIL; /* XXX sampler? */
 296          break;
 297    }
 298
 299    switch (format) {
 300       case 32:
 301          pf = PIPE_FORMAT_B8G8R8X8_UNORM;
 302          break;
 303       case 16:
 304          pf = PIPE_FORMAT_Z16_UNORM;
 305          break;
 306       default:
 307          return NULL;
 308    }
 309
 310    buffer = CALLOC_STRUCT(dri2_buffer);
 311    if (!buffer)
 312       return NULL;
 313
 314    memset(&templ, 0, sizeof(templ));
 315    templ.bind = bind;
 316    templ.format = pf;
 317    templ.target = PIPE_TEXTURE_2D;
 318    templ.last_level = 0;
 319    templ.width0 = width;
 320    templ.height0 = height;
 321    templ.depth0 = 1;
 322    templ.array_size = 1;
 323
 324    buffer->resource =
 325       screen->base.screen->resource_create(screen->base.screen, &templ);
 326    if (!buffer->resource)
 327       return NULL;
 328
 329    memset(&whandle, 0, sizeof(whandle));
 330    whandle.type = DRM_API_HANDLE_TYPE_SHARED;
 331    screen->base.screen->resource_get_handle(screen->base.screen,
 332          buffer->resource, &whandle);
 333
 334    buffer->base.attachment = attachment;
 335    buffer->base.name = whandle.handle;
 336    buffer->base.cpp = util_format_get_blocksize(pf);
 337    buffer->base.pitch = whandle.stride;
 338
 339    return &buffer->base;
 340 }
 341
 342 static void
 343 dri2_release_buffer(__DRIscreen *sPriv, __DRIbuffer *bPriv)
 344 {
 345    struct dri2_buffer *buffer = dri2_buffer(bPriv);
 346
 347    pipe_resource_reference(&buffer->resource, NULL);
 348    FREE(buffer);
 349 }
 350
 351 /*
 352  * Backend functions for st_framebuffer interface.
 353  */
 354
 355 static void
 356 dri2_allocate_textures(struct dri_drawable *drawable,
 357                        const enum st_attachment_type *statts,
 358                        unsigned count)
 359 {
 360    __DRIbuffer *buffers;
 361    unsigned num_buffers = count;
 362
 363    buffers = dri2_drawable_get_buffers(drawable, statts, &num_buffers);
 364    if (buffers)
 365       dri2_drawable_process_buffers(drawable, buffers, num_buffers);
 366 }
 367
 368 static void
 369 dri2_flush_frontbuffer(struct dri_drawable *drawable,
 370                        enum st_attachment_type statt)
 371 {
 372    __DRIdrawable *dri_drawable = drawable->dPriv;
 373    struct __DRIdri2LoaderExtensionRec *loader = drawable->sPriv->dri2.loader;
 374
 375    if (loader->flushFrontBuffer == NULL)
 376       return;
 377
 378    if (statt == ST_ATTACHMENT_FRONT_LEFT) {
 379       loader->flushFrontBuffer(dri_drawable, dri_drawable->loaderPrivate);
 380    }
 381 }
 382
 383 static void
 384 dri2_update_tex_buffer(struct dri_drawable *drawable,
 385                        struct dri_context *ctx,
 386                        struct pipe_resource *res)
 387 {
 388    /* no-op */
 389 }
 390
 391 static __DRIimage *
 392 dri2_lookup_egl_image(struct dri_screen *screen, void *handle)
 393 {
 394    __DRIimageLookupExtension *loader = screen->sPriv->dri2.image;
 395    __DRIimage *img;
 396
 397    if (!loader->lookupEGLImage)
 398       return NULL;
 399
 400    img = loader->lookupEGLImage(screen->sPriv,
 401                                 handle, screen->sPriv->loaderPrivate);
 402
 403    return img;
 404 }
 405
 406 static __DRIimage *
 407 dri2_create_image_from_name(__DRIscreen *_screen,
 408                             int width, int height, int format,
 409                             int name, int pitch, void *loaderPrivate)
 410 {
 411    struct dri_screen *screen = dri_screen(_screen);
 412    __DRIimage *img;
 413    struct pipe_resource templ;
 414    struct winsys_handle whandle;
 415    unsigned tex_usage;
 416    enum pipe_format pf;
 417
 418    tex_usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 419
 420    switch (format) {
 421    case __DRI_IMAGE_FORMAT_RGB565:
 422       pf = PIPE_FORMAT_B5G6R5_UNORM;
 423       break;
 424    case __DRI_IMAGE_FORMAT_XRGB8888:
 425       pf = PIPE_FORMAT_B8G8R8X8_UNORM;
 426       break;
 427    case __DRI_IMAGE_FORMAT_ARGB8888:
 428       pf = PIPE_FORMAT_B8G8R8A8_UNORM;
 429       break;
 430    case __DRI_IMAGE_FORMAT_ABGR8888:
 431       pf = PIPE_FORMAT_R8G8B8A8_UNORM;
 432       break;
 433    default:
 434       pf = PIPE_FORMAT_NONE;
 435       break;
 436    }
 437    if (pf == PIPE_FORMAT_NONE)
 438       return NULL;
 439
 440    img = CALLOC_STRUCT(__DRIimageRec);
 441    if (!img)
 442       return NULL;
 443
 444    memset(&templ, 0, sizeof(templ));
 445    templ.bind = tex_usage;
 446    templ.format = pf;
 447    templ.target = screen->target;
 448    templ.last_level = 0;
 449    templ.width0 = width;
 450    templ.height0 = height;
 451    templ.depth0 = 1;
 452    templ.array_size = 1;
 453
 454    memset(&whandle, 0, sizeof(whandle));
 455    whandle.handle = name;
 456    whandle.stride = pitch * util_format_get_blocksize(pf);
 457
 458    img->texture = screen->base.screen->resource_from_handle(screen->base.screen,
 459          &templ, &whandle);
 460    if (!img->texture) {
 461       FREE(img);
 462       return NULL;
 463    }
 464
 465    img->level = 0;
 466    img->layer = 0;
 467    img->loader_private = loaderPrivate;
 468
 469    return img;
 470 }
 471
 472 static __DRIimage *
 473 dri2_create_image_from_renderbuffer(__DRIcontext *context,
 474                                     int renderbuffer, void *loaderPrivate)
 475 {
 476    struct dri_context *ctx = dri_context(context);
 477
 478    if (!ctx->st->get_resource_for_egl_image)
 479       return NULL;
 480
 481    /* TODO */
 482    return NULL;
 483 }
 484
 485 static __DRIimage *
 486 dri2_create_image(__DRIscreen *_screen,
 487                    int width, int height, int format,
 488                    unsigned int use, void *loaderPrivate)
 489 {
 490    struct dri_screen *screen = dri_screen(_screen);
 491    __DRIimage *img;
 492    struct pipe_resource templ;
 493    unsigned tex_usage;
 494    enum pipe_format pf;
 495
 496    tex_usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 497    if (use & __DRI_IMAGE_USE_SCANOUT)
 498       tex_usage |= PIPE_BIND_SCANOUT;
 499    if (use & __DRI_IMAGE_USE_SHARE)
 500       tex_usage |= PIPE_BIND_SHARED;
 501    if (use & __DRI_IMAGE_USE_CURSOR) {
 502       if (width != 64 || height != 64)
 503          return NULL;
 504       tex_usage |= PIPE_BIND_CURSOR;
 505    }
 506
 507    switch (format) {
 508    case __DRI_IMAGE_FORMAT_RGB565:
 509       pf = PIPE_FORMAT_B5G6R5_UNORM;
 510       break;
 511    case __DRI_IMAGE_FORMAT_XRGB8888:
 512       pf = PIPE_FORMAT_B8G8R8X8_UNORM;
 513       break;
 514    case __DRI_IMAGE_FORMAT_ARGB8888:
 515       pf = PIPE_FORMAT_B8G8R8A8_UNORM;
 516       break;
 517    case __DRI_IMAGE_FORMAT_ABGR8888:
 518       pf = PIPE_FORMAT_R8G8B8A8_UNORM;
 519       break;
 520    default:
 521       pf = PIPE_FORMAT_NONE;
 522       break;
 523    }
 524    if (pf == PIPE_FORMAT_NONE)
 525       return NULL;
 526
 527    img = CALLOC_STRUCT(__DRIimageRec);
 528    if (!img)
 529       return NULL;
 530
 531    memset(&templ, 0, sizeof(templ));
 532    templ.bind = tex_usage;
 533    templ.format = pf;
 534    templ.target = PIPE_TEXTURE_2D;
 535    templ.last_level = 0;
 536    templ.width0 = width;
 537    templ.height0 = height;
 538    templ.depth0 = 1;
 539    templ.array_size = 1;
 540
 541    img->texture = screen->base.screen->resource_create(screen->base.screen, &templ);
 542    if (!img->texture) {
 543       FREE(img);
 544       return NULL;
 545    }
 546
 547    img->level = 0;
 548    img->layer = 0;
 549
 550    img->loader_private = loaderPrivate;
 551    return img;
 552 }
 553
 554 static GLboolean
 555 dri2_query_image(__DRIimage *image, int attrib, int *value)
 556 {
 557    struct winsys_handle whandle;
 558    memset(&whandle, 0, sizeof(whandle));
 559
 560    switch (attrib) {
 561    case __DRI_IMAGE_ATTRIB_STRIDE:
 562       image->texture->screen->resource_get_handle(image->texture->screen,
 563             image->texture, &whandle);
 564       *value = whandle.stride;
 565       return GL_TRUE;
 566    case __DRI_IMAGE_ATTRIB_HANDLE:
 567       whandle.type = DRM_API_HANDLE_TYPE_KMS;
 568       image->texture->screen->resource_get_handle(image->texture->screen,
 569          image->texture, &whandle);
 570       *value = whandle.handle;
 571       return GL_TRUE;
 572    case __DRI_IMAGE_ATTRIB_NAME:
 573       whandle.type = DRM_API_HANDLE_TYPE_SHARED;
 574       image->texture->screen->resource_get_handle(image->texture->screen,
 575          image->texture, &whandle);
 576       *value = whandle.handle;
 577       return GL_TRUE;
 578    default:
 579       return GL_FALSE;
 580    }
 581 }
 582
 583 static __DRIimage *
 584 dri2_dup_image(__DRIimage *image, void *loaderPrivate)
 585 {
 586    __DRIimage *img;
 587
 588    img = CALLOC_STRUCT(__DRIimageRec);
 589    if (!img)
 590       return NULL;
 591
 592    img->texture = NULL;
 593    pipe_resource_reference(&img->texture, image->texture);
 594    img->level = image->level;
 595    img->layer = image->layer;
 596    img->loader_private = loaderPrivate;
 597
 598    return img;
 599 }
 600
 601 static void
 602 dri2_destroy_image(__DRIimage *img)
 603 {
 604    pipe_resource_reference(&img->texture, NULL);
 605    FREE(img);
 606 }
 607
 608 static struct __DRIimageExtensionRec dri2ImageExtension = {
 609     { __DRI_IMAGE, __DRI_IMAGE_VERSION },
 610     dri2_create_image_from_name,
 611     dri2_create_image_from_renderbuffer,
 612     dri2_destroy_image,
 613     dri2_create_image,
 614     dri2_query_image,
 615     dri2_dup_image,
 616 };
 617
 618 /*
 619  * Backend function init_screen.
 620  */
 621
 622 static const __DRIextension *dri_screen_extensions[] = {
 623    &driTexBufferExtension.base,
 624    &dri2FlushExtension.base,
 625    &dri2ImageExtension.base,
 626    &dri2ConfigQueryExtension.base,
 627    NULL
 628 };
 629
 630 static const __DRIextension *dri_screen_extensions_throttle[] = {
 631    &driTexBufferExtension.base,
 632    &dri2FlushExtension.base,
 633    &dri2ImageExtension.base,
 634    &dri2ConfigQueryExtension.base,
 635    &dri2ThrottleExtension.base,
 636    NULL
 637 };
 638
 639 /**
 640  * This is the driver specific part of the createNewScreen entry point.
 641  *
 642  * Returns the struct gl_config supported by this driver.
 643  */
 644 static const __DRIconfig **
 645 dri2_init_screen(__DRIscreen * sPriv)
 646 {
 647    const __DRIconfig **configs;
 648    struct dri_screen *screen;
 649    struct pipe_screen *pscreen;
 650    const struct drm_conf_ret *throttle_ret = NULL;
 651
 652    screen = CALLOC_STRUCT(dri_screen);
 653    if (!screen)
 654       return NULL;
 655
 656    screen->sPriv = sPriv;
 657    screen->fd = sPriv->fd;
 658
 659    sPriv->private = (void *)screen;
 660
 661    pscreen = driver_descriptor.create_screen(screen->fd);
 662    if (driver_descriptor.configuration)
 663       throttle_ret = driver_descriptor.configuration(DRM_CONF_THROTTLE);
 664
 665    if (throttle_ret && throttle_ret->val.val_int != -1) {
 666       sPriv->extensions = dri_screen_extensions_throttle;
 667       screen->default_throttle_frames = throttle_ret->val.val_int;
 668    } else
 669       sPriv->extensions = dri_screen_extensions;
 670
 671    /* dri_init_screen_helper checks pscreen for us */
 672
 673    configs = dri_init_screen_helper(screen, pscreen, 32);
 674    if (!configs)
 675       goto fail;
 676
 677    sPriv->api_mask = 0;
 678    if (screen->st_api->profile_mask & ST_PROFILE_DEFAULT_MASK)
 679       sPriv->api_mask |= 1 << __DRI_API_OPENGL;
 680    if (screen->st_api->profile_mask & ST_PROFILE_OPENGL_ES1_MASK)
 681       sPriv->api_mask |= 1 << __DRI_API_GLES;
 682    if (screen->st_api->profile_mask & ST_PROFILE_OPENGL_ES2_MASK)
 683       sPriv->api_mask |= 1 << __DRI_API_GLES2;
 684
 685    screen->auto_fake_front = dri_with_format(sPriv);
 686    screen->broken_invalidate = !sPriv->dri2.useInvalidate;
 687    screen->lookup_egl_image = dri2_lookup_egl_image;
 688
 689    return configs;
 690 fail:
 691    dri_destroy_screen_helper(screen);
 692    FREE(screen);
 693    return NULL;
 694 }
 695
 696 static boolean
 697 dri2_create_buffer(__DRIscreen * sPriv,
 698                    __DRIdrawable * dPriv,
 699                    const struct gl_config * visual, boolean isPixmap)
 700 {
 701    struct dri_drawable *drawable = NULL;
 702
 703    if (!dri_create_buffer(sPriv, dPriv, visual, isPixmap))
 704       return FALSE;
 705
 706    drawable = dPriv->driverPrivate;
 707
 708    drawable->allocate_textures = dri2_allocate_textures;
 709    drawable->flush_frontbuffer = dri2_flush_frontbuffer;
 710    drawable->update_tex_buffer = dri2_update_tex_buffer;
 711
 712    return TRUE;
 713 }
 714
 715 /**
 716  * DRI driver virtual function table.
 717  *
 718  * DRI versions differ in their implementation of init_screen and swap_buffers.
 719  */
 720 const struct __DriverAPIRec driDriverAPI = {
 721    .InitScreen = NULL,
 722    .InitScreen2 = dri2_init_screen,
 723    .DestroyScreen = dri_destroy_screen,
 724    .CreateContext = dri_create_context,
 725    .DestroyContext = dri_destroy_context,
 726    .CreateBuffer = dri2_create_buffer,
 727    .DestroyBuffer = dri_destroy_buffer,
 728    .MakeCurrent = dri_make_current,
 729    .UnbindContext = dri_unbind_context,
 730
 731    .GetSwapInfo = NULL,
 732    .GetDrawableMSC = NULL,
 733    .WaitForMSC = NULL,
 734
 735    .SwapBuffers = NULL,
 736    .CopySubBuffer = NULL,
 737
 738    .AllocateBuffer = dri2_allocate_buffer,
 739    .ReleaseBuffer  = dri2_release_buffer,
 740 };
 741
 742 /* This is the table of extensions that the loader will dlsym() for. */
 743 PUBLIC const __DRIextension *__driDriverExtensions[] = {
 744     &driCoreExtension.base,
 745     &driDRI2Extension.base,
 746     NULL
 747 };
 748
 749 /* vim: set sw=3 ts=8 sts=3 expandtab: */