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 *draw)
  48 {
  49 }
  50
  51 static void
  52 dri2_invalidate_drawable(__DRIdrawable *dPriv)
  53 {
  54    struct dri_drawable *drawable = dri_drawable(dPriv);
  55    struct dri_context *ctx = dri_context(dPriv->driContextPriv);
  56
  57    dri2InvalidateDrawable(dPriv);
  58    drawable->dPriv->lastStamp = *drawable->dPriv->pStamp;
  59
  60    if (ctx)
  61       ctx->st->notify_invalid_framebuffer(ctx->st, &drawable->base);
  62 }
  63
  64 static const __DRI2flushExtension dri2FlushExtension = {
  65     { __DRI2_FLUSH, __DRI2_FLUSH_VERSION },
  66     dri2_flush_drawable,
  67     dri2_invalidate_drawable,
  68 };
  69
  70 /**
  71  * Retrieve __DRIbuffer from the DRI loader.
  72  */
  73 static __DRIbuffer *
  74 dri2_drawable_get_buffers(struct dri_drawable *drawable,
  75                           const enum st_attachment_type *statts,
  76                           unsigned *count)
  77 {
  78    __DRIdrawable *dri_drawable = drawable->dPriv;
  79    struct __DRIdri2LoaderExtensionRec *loader = drawable->sPriv->dri2.loader;
  80    boolean with_format;
  81    __DRIbuffer *buffers;
  82    int num_buffers;
  83    unsigned attachments[10];
  84    unsigned num_attachments, i;
  85
  86    assert(loader);
  87    with_format = dri_with_format(drawable->sPriv);
  88
  89    num_attachments = 0;
  90
  91    /* for Xserver 1.6.0 (DRI2 version 1) we always need to ask for the front */
  92    if (!with_format)
  93       attachments[num_attachments++] = __DRI_BUFFER_FRONT_LEFT;
  94
  95    for (i = 0; i < *count; i++) {
  96       enum pipe_format format;
  97       unsigned bind;
  98       int att, bpp;
  99
 100       dri_drawable_get_format(drawable, statts[i], &format, &bind);
 101       if (format == PIPE_FORMAT_NONE)
 102          continue;
 103
 104       switch (statts[i]) {
 105       case ST_ATTACHMENT_FRONT_LEFT:
 106          /* already added */
 107          if (!with_format)
 108             continue;
 109          att = __DRI_BUFFER_FRONT_LEFT;
 110          break;
 111       case ST_ATTACHMENT_BACK_LEFT:
 112          att = __DRI_BUFFER_BACK_LEFT;
 113          break;
 114       case ST_ATTACHMENT_FRONT_RIGHT:
 115          att = __DRI_BUFFER_FRONT_RIGHT;
 116          break;
 117       case ST_ATTACHMENT_BACK_RIGHT:
 118          att = __DRI_BUFFER_BACK_RIGHT;
 119          break;
 120       case ST_ATTACHMENT_DEPTH_STENCIL:
 121          att = __DRI_BUFFER_DEPTH_STENCIL;
 122          break;
 123       default:
 124          att = -1;
 125          break;
 126       }
 127
 128       bpp = util_format_get_blocksizebits(format);
 129
 130       if (att >= 0) {
 131          attachments[num_attachments++] = att;
 132          if (with_format) {
 133             attachments[num_attachments++] = bpp;
 134          }
 135       }
 136    }
 137
 138    if (with_format) {
 139       num_attachments /= 2;
 140       buffers = loader->getBuffersWithFormat(dri_drawable,
 141             &dri_drawable->w, &dri_drawable->h,
 142             attachments, num_attachments,
 143             &num_buffers, dri_drawable->loaderPrivate);
 144    }
 145    else {
 146       buffers = loader->getBuffers(dri_drawable,
 147             &dri_drawable->w, &dri_drawable->h,
 148             attachments, num_attachments,
 149             &num_buffers, dri_drawable->loaderPrivate);
 150    }
 151
 152    if (buffers) {
 153       /* set one cliprect to cover the whole dri_drawable */
 154       dri_drawable->x = 0;
 155       dri_drawable->y = 0;
 156       dri_drawable->backX = 0;
 157       dri_drawable->backY = 0;
 158       dri_drawable->numClipRects = 1;
 159       dri_drawable->pClipRects[0].x1 = 0;
 160       dri_drawable->pClipRects[0].y1 = 0;
 161       dri_drawable->pClipRects[0].x2 = dri_drawable->w;
 162       dri_drawable->pClipRects[0].y2 = dri_drawable->h;
 163       dri_drawable->numBackClipRects = 1;
 164       dri_drawable->pBackClipRects[0].x1 = 0;
 165       dri_drawable->pBackClipRects[0].y1 = 0;
 166       dri_drawable->pBackClipRects[0].x2 = dri_drawable->w;
 167       dri_drawable->pBackClipRects[0].y2 = dri_drawable->h;
 168
 169       *count = num_buffers;
 170    }
 171
 172    return buffers;
 173 }
 174
 175 /**
 176  * Process __DRIbuffer and convert them into pipe_resources.
 177  */
 178 static void
 179 dri2_drawable_process_buffers(struct dri_drawable *drawable,
 180                               __DRIbuffer *buffers, unsigned count)
 181 {
 182    struct dri_screen *screen = dri_screen(drawable->sPriv);
 183    __DRIdrawable *dri_drawable = drawable->dPriv;
 184    struct pipe_resource templ;
 185    struct winsys_handle whandle;
 186    boolean have_depth = FALSE;
 187    unsigned i, bind;
 188
 189    if (drawable->old_num == count &&
 190        drawable->old_w == dri_drawable->w &&
 191        drawable->old_h == dri_drawable->h &&
 192        memcmp(drawable->old, buffers, sizeof(__DRIbuffer) * count) == 0)
 193       return;
 194
 195    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
 196       pipe_resource_reference(&drawable->textures[i], NULL);
 197
 198    memset(&templ, 0, sizeof(templ));
 199    templ.target = screen->target;
 200    templ.last_level = 0;
 201    templ.width0 = dri_drawable->w;
 202    templ.height0 = dri_drawable->h;
 203    templ.depth0 = 1;
 204    templ.array_size = 1;
 205
 206    memset(&whandle, 0, sizeof(whandle));
 207
 208    for (i = 0; i < count; i++) {
 209       __DRIbuffer *buf = &buffers[i];
 210       enum st_attachment_type statt;
 211       enum pipe_format format;
 212
 213       switch (buf->attachment) {
 214       case __DRI_BUFFER_FRONT_LEFT:
 215          if (!screen->auto_fake_front) {
 216             statt = ST_ATTACHMENT_INVALID;
 217             break;
 218          }
 219          /* fallthrough */
 220       case __DRI_BUFFER_FAKE_FRONT_LEFT:
 221          statt = ST_ATTACHMENT_FRONT_LEFT;
 222          break;
 223       case __DRI_BUFFER_BACK_LEFT:
 224          statt = ST_ATTACHMENT_BACK_LEFT;
 225          break;
 226       case __DRI_BUFFER_DEPTH:
 227       case __DRI_BUFFER_DEPTH_STENCIL:
 228       case __DRI_BUFFER_STENCIL:
 229          /* use only the first depth/stencil buffer */
 230          if (!have_depth) {
 231             have_depth = TRUE;
 232             statt = ST_ATTACHMENT_DEPTH_STENCIL;
 233          }
 234          else {
 235             statt = ST_ATTACHMENT_INVALID;
 236          }
 237          break;
 238       default:
 239          statt = ST_ATTACHMENT_INVALID;
 240          break;
 241       }
 242
 243       dri_drawable_get_format(drawable, statt, &format, &bind);
 244       if (statt == ST_ATTACHMENT_INVALID || format == PIPE_FORMAT_NONE)
 245          continue;
 246
 247       templ.format = format;
 248       templ.bind = bind;
 249       whandle.handle = buf->name;
 250       whandle.stride = buf->pitch;
 251
 252       drawable->textures[statt] =
 253          screen->base.screen->resource_from_handle(screen->base.screen,
 254                &templ, &whandle);
 255    }
 256
 257    drawable->old_num = count;
 258    drawable->old_w = dri_drawable->w;
 259    drawable->old_h = dri_drawable->h;
 260    memcpy(drawable->old, buffers, sizeof(__DRIbuffer) * count);
 261 }
 262
 263 static __DRIbuffer *
 264 dri2_allocate_buffer(__DRIscreen *sPriv,
 265                      unsigned attachment, unsigned format,
 266                      int width, int height)
 267 {
 268    struct dri_screen *screen = dri_screen(sPriv);
 269    struct dri2_buffer *buffer;
 270    struct pipe_resource templ;
 271    enum st_attachment_type statt;
 272    enum pipe_format pf;
 273    unsigned bind;
 274    struct winsys_handle whandle;
 275
 276    switch (attachment) {
 277       case __DRI_BUFFER_FRONT_LEFT:
 278       case __DRI_BUFFER_FAKE_FRONT_LEFT:
 279          statt = ST_ATTACHMENT_FRONT_LEFT;
 280          bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 281          break;
 282       case __DRI_BUFFER_BACK_LEFT:
 283          statt = ST_ATTACHMENT_BACK_LEFT;
 284          bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 285          break;
 286       case __DRI_BUFFER_DEPTH:
 287       case __DRI_BUFFER_DEPTH_STENCIL:
 288       case __DRI_BUFFER_STENCIL:
 289             statt = ST_ATTACHMENT_DEPTH_STENCIL;
 290             bind = PIPE_BIND_DEPTH_STENCIL; /* XXX sampler? */
 291          break;
 292       default:
 293          statt = ST_ATTACHMENT_INVALID;
 294          break;
 295    }
 296
 297    switch (format) {
 298       case 32:
 299          pf = PIPE_FORMAT_B8G8R8X8_UNORM;
 300          break;
 301       case 16:
 302          pf = PIPE_FORMAT_Z16_UNORM;
 303          break;
 304       default:
 305          return NULL;
 306    }
 307
 308    buffer = CALLOC_STRUCT(dri2_buffer);
 309    if (!buffer)
 310       return NULL;
 311
 312    memset(&templ, 0, sizeof(templ));
 313    templ.bind = bind;
 314    templ.format = pf;
 315    templ.target = PIPE_TEXTURE_2D;
 316    templ.last_level = 0;
 317    templ.width0 = width;
 318    templ.height0 = height;
 319    templ.depth0 = 1;
 320
 321    buffer->resource =
 322       screen->base.screen->resource_create(screen->base.screen, &templ);
 323    if (!buffer->resource)
 324       return NULL;
 325
 326    memset(&whandle, 0, sizeof(whandle));
 327    whandle.type = DRM_API_HANDLE_TYPE_SHARED;
 328    screen->base.screen->resource_get_handle(screen->base.screen,
 329          buffer->resource, &whandle);
 330
 331    buffer->base.attachment = attachment;
 332    buffer->base.name = whandle.handle;
 333    buffer->base.cpp = util_format_get_blocksize(pf);
 334    buffer->base.pitch = whandle.stride;
 335
 336    return &buffer->base;
 337 }
 338
 339 static void
 340 dri2_release_buffer(__DRIscreen *sPriv, __DRIbuffer *bPriv)
 341 {
 342    struct dri2_buffer *buffer = dri2_buffer(bPriv);
 343
 344    pipe_resource_reference(&buffer->resource, NULL);
 345    FREE(buffer);
 346 }
 347
 348 /*
 349  * Backend functions for st_framebuffer interface.
 350  */
 351
 352 static void
 353 dri2_allocate_textures(struct dri_drawable *drawable,
 354                        const enum st_attachment_type *statts,
 355                        unsigned count)
 356 {
 357    __DRIbuffer *buffers;
 358    unsigned num_buffers = count;
 359
 360    buffers = dri2_drawable_get_buffers(drawable, statts, &num_buffers);
 361    if (buffers)
 362       dri2_drawable_process_buffers(drawable, buffers, num_buffers);
 363 }
 364
 365 static void
 366 dri2_flush_frontbuffer(struct dri_drawable *drawable,
 367                        enum st_attachment_type statt)
 368 {
 369    __DRIdrawable *dri_drawable = drawable->dPriv;
 370    struct __DRIdri2LoaderExtensionRec *loader = drawable->sPriv->dri2.loader;
 371
 372    if (loader->flushFrontBuffer == NULL)
 373       return;
 374
 375    if (statt == ST_ATTACHMENT_FRONT_LEFT) {
 376       loader->flushFrontBuffer(dri_drawable, dri_drawable->loaderPrivate);
 377    }
 378 }
 379
 380 static __DRIimage *
 381 dri2_lookup_egl_image(struct dri_screen *screen, void *handle)
 382 {
 383    __DRIimageLookupExtension *loader = screen->sPriv->dri2.image;
 384    __DRIimage *img;
 385
 386    if (!loader->lookupEGLImage)
 387       return NULL;
 388
 389    img = loader->lookupEGLImage(screen->sPriv,
 390                                 handle, screen->sPriv->loaderPrivate);
 391
 392    return img;
 393 }
 394
 395 static __DRIimage *
 396 dri2_create_image_from_name(__DRIscreen *_screen,
 397                             int width, int height, int format,
 398                             int name, int pitch, void *loaderPrivate)
 399 {
 400    struct dri_screen *screen = dri_screen(_screen);
 401    __DRIimage *img;
 402    struct pipe_resource templ;
 403    struct winsys_handle whandle;
 404    unsigned tex_usage;
 405    enum pipe_format pf;
 406
 407    tex_usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 408
 409    switch (format) {
 410    case __DRI_IMAGE_FORMAT_RGB565:
 411       pf = PIPE_FORMAT_B5G6R5_UNORM;
 412       break;
 413    case __DRI_IMAGE_FORMAT_XRGB8888:
 414       pf = PIPE_FORMAT_B8G8R8X8_UNORM;
 415       break;
 416    case __DRI_IMAGE_FORMAT_ARGB8888:
 417       pf = PIPE_FORMAT_B8G8R8A8_UNORM;
 418       break;
 419    default:
 420       pf = PIPE_FORMAT_NONE;
 421       break;
 422    }
 423    if (pf == PIPE_FORMAT_NONE)
 424       return NULL;
 425
 426    img = CALLOC_STRUCT(__DRIimageRec);
 427    if (!img)
 428       return NULL;
 429
 430    memset(&templ, 0, sizeof(templ));
 431    templ.bind = tex_usage;
 432    templ.format = pf;
 433    templ.target = screen->target;
 434    templ.last_level = 0;
 435    templ.width0 = width;
 436    templ.height0 = height;
 437    templ.depth0 = 1;
 438    templ.array_size = 1;
 439
 440    memset(&whandle, 0, sizeof(whandle));
 441    whandle.handle = name;
 442    whandle.stride = pitch * util_format_get_blocksize(pf);
 443
 444    img->texture = screen->base.screen->resource_from_handle(screen->base.screen,
 445          &templ, &whandle);
 446    if (!img->texture) {
 447       FREE(img);
 448       return NULL;
 449    }
 450
 451    img->level = 0;
 452    img->layer = 0;
 453    img->loader_private = loaderPrivate;
 454
 455    return img;
 456 }
 457
 458 static __DRIimage *
 459 dri2_create_image_from_renderbuffer(__DRIcontext *context,
 460                                     int renderbuffer, void *loaderPrivate)
 461 {
 462    struct dri_context *ctx = dri_context(context);
 463
 464    if (!ctx->st->get_resource_for_egl_image)
 465       return NULL;
 466
 467    /* TODO */
 468    return NULL;
 469 }
 470
 471 static __DRIimage *
 472 dri2_create_image(__DRIscreen *_screen,
 473                    int width, int height, int format,
 474                    unsigned int use, void *loaderPrivate)
 475 {
 476    struct dri_screen *screen = dri_screen(_screen);
 477    __DRIimage *img;
 478    struct pipe_resource templ;
 479    unsigned tex_usage;
 480    enum pipe_format pf;
 481
 482    tex_usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 483
 484    switch (format) {
 485    case __DRI_IMAGE_FORMAT_RGB565:
 486       pf = PIPE_FORMAT_B5G6R5_UNORM;
 487       break;
 488    case __DRI_IMAGE_FORMAT_XRGB8888:
 489       pf = PIPE_FORMAT_B8G8R8X8_UNORM;
 490       break;
 491    case __DRI_IMAGE_FORMAT_ARGB8888:
 492       pf = PIPE_FORMAT_B8G8R8A8_UNORM;
 493       break;
 494    default:
 495       pf = PIPE_FORMAT_NONE;
 496       break;
 497    }
 498    if (pf == PIPE_FORMAT_NONE)
 499       return NULL;
 500
 501    img = CALLOC_STRUCT(__DRIimageRec);
 502    if (!img)
 503       return NULL;
 504
 505    memset(&templ, 0, sizeof(templ));
 506    templ.bind = tex_usage;
 507    templ.format = pf;
 508    templ.target = PIPE_TEXTURE_2D;
 509    templ.last_level = 0;
 510    templ.width0 = width;
 511    templ.height0 = height;
 512    templ.depth0 = 1;
 513
 514    img->texture = screen->base.screen->resource_create(screen->base.screen, &templ);
 515    if (!img->texture) {
 516       FREE(img);
 517       return NULL;
 518    }
 519
 520    img->level = 0;
 521    img->layer = 0;
 522
 523    img->loader_private = loaderPrivate;
 524    return img;
 525 }
 526
 527 static GLboolean
 528 dri2_query_image(__DRIimage *image, int attrib, int *value)
 529 {
 530    struct winsys_handle whandle;
 531    memset(&whandle, 0, sizeof(whandle));
 532
 533    switch (attrib) {
 534    case __DRI_IMAGE_ATTRIB_STRIDE:
 535       image->texture->screen->resource_get_handle(image->texture->screen,
 536             image->texture, &whandle);
 537       *value = whandle.stride;
 538       return GL_TRUE;
 539    case __DRI_IMAGE_ATTRIB_HANDLE:
 540       whandle.type = DRM_API_HANDLE_TYPE_KMS;
 541       image->texture->screen->resource_get_handle(image->texture->screen,
 542          image->texture, &whandle);
 543       *value = whandle.handle;
 544       return GL_TRUE;
 545    case __DRI_IMAGE_ATTRIB_NAME:
 546       whandle.type = DRM_API_HANDLE_TYPE_SHARED;
 547       image->texture->screen->resource_get_handle(image->texture->screen,
 548          image->texture, &whandle);
 549       *value = whandle.handle;
 550       return GL_TRUE;
 551    default:
 552       return GL_FALSE;
 553    }
 554 }
 555
 556 static void
 557 dri2_destroy_image(__DRIimage *img)
 558 {
 559    pipe_resource_reference(&img->texture, NULL);
 560    FREE(img);
 561 }
 562
 563 static struct __DRIimageExtensionRec dri2ImageExtension = {
 564     { __DRI_IMAGE, __DRI_IMAGE_VERSION },
 565     dri2_create_image_from_name,
 566     dri2_create_image_from_renderbuffer,
 567     dri2_destroy_image,
 568     dri2_create_image,
 569     dri2_query_image,
 570 };
 571
 572 /*
 573  * Backend function init_screen.
 574  */
 575
 576 static const __DRIextension *dri_screen_extensions[] = {
 577    &driReadDrawableExtension,
 578    &driCopySubBufferExtension.base,
 579    &driSwapControlExtension.base,
 580    &driMediaStreamCounterExtension.base,
 581    &driTexBufferExtension.base,
 582    &dri2FlushExtension.base,
 583    &dri2ImageExtension.base,
 584    &dri2ConfigQueryExtension.base,
 585    NULL
 586 };
 587
 588 /**
 589  * This is the driver specific part of the createNewScreen entry point.
 590  *
 591  * Returns the struct gl_config supported by this driver.
 592  */
 593 static const __DRIconfig **
 594 dri2_init_screen(__DRIscreen * sPriv)
 595 {
 596    const __DRIconfig **configs;
 597    struct dri_screen *screen;
 598    struct pipe_screen *pscreen;
 599
 600    screen = CALLOC_STRUCT(dri_screen);
 601    if (!screen)
 602       return NULL;
 603
 604    screen->sPriv = sPriv;
 605    screen->fd = sPriv->fd;
 606
 607    sPriv->private = (void *)screen;
 608    sPriv->extensions = dri_screen_extensions;
 609
 610    pscreen = driver_descriptor.create_screen(screen->fd);
 611    /* dri_init_screen_helper checks pscreen for us */
 612
 613    configs = dri_init_screen_helper(screen, pscreen, 32);
 614    if (!configs)
 615       goto fail;
 616
 617    sPriv->api_mask = 0;
 618    if (screen->st_api->profile_mask & ST_PROFILE_DEFAULT_MASK)
 619       sPriv->api_mask |= 1 << __DRI_API_OPENGL;
 620    if (screen->st_api->profile_mask & ST_PROFILE_OPENGL_ES1_MASK)
 621       sPriv->api_mask |= 1 << __DRI_API_GLES;
 622    if (screen->st_api->profile_mask & ST_PROFILE_OPENGL_ES2_MASK)
 623       sPriv->api_mask |= 1 << __DRI_API_GLES2;
 624
 625    screen->auto_fake_front = dri_with_format(sPriv);
 626    screen->broken_invalidate = !sPriv->dri2.useInvalidate;
 627    screen->lookup_egl_image = dri2_lookup_egl_image;
 628
 629    return configs;
 630 fail:
 631    dri_destroy_screen_helper(screen);
 632    FREE(screen);
 633    return NULL;
 634 }
 635
 636 static boolean
 637 dri2_create_context(gl_api api, const struct gl_config * visual,
 638                     __DRIcontext * cPriv, void *sharedContextPrivate)
 639 {
 640    struct dri_context *ctx = NULL;
 641
 642    if (!dri_create_context(api, visual, cPriv, sharedContextPrivate))
 643       return FALSE;
 644
 645    ctx = cPriv->driverPrivate;
 646
 647    return TRUE;
 648 }
 649
 650 static boolean
 651 dri2_create_buffer(__DRIscreen * sPriv,
 652                    __DRIdrawable * dPriv,
 653                    const struct gl_config * visual, boolean isPixmap)
 654 {
 655    struct dri_drawable *drawable = NULL;
 656
 657    if (!dri_create_buffer(sPriv, dPriv, visual, isPixmap))
 658       return FALSE;
 659
 660    drawable = dPriv->driverPrivate;
 661
 662    drawable->allocate_textures = dri2_allocate_textures;
 663    drawable->flush_frontbuffer = dri2_flush_frontbuffer;
 664
 665    return TRUE;
 666 }
 667
 668 /**
 669  * DRI driver virtual function table.
 670  *
 671  * DRI versions differ in their implementation of init_screen and swap_buffers.
 672  */
 673 const struct __DriverAPIRec driDriverAPI = {
 674    .InitScreen = NULL,
 675    .InitScreen2 = dri2_init_screen,
 676    .DestroyScreen = dri_destroy_screen,
 677    .CreateContext = dri2_create_context,
 678    .DestroyContext = dri_destroy_context,
 679    .CreateBuffer = dri2_create_buffer,
 680    .DestroyBuffer = dri_destroy_buffer,
 681    .MakeCurrent = dri_make_current,
 682    .UnbindContext = dri_unbind_context,
 683
 684    .GetSwapInfo = NULL,
 685    .GetDrawableMSC = NULL,
 686    .WaitForMSC = NULL,
 687
 688    .SwapBuffers = NULL,
 689    .CopySubBuffer = NULL,
 690
 691    .AllocateBuffer = dri2_allocate_buffer,
 692    .ReleaseBuffer  = dri2_release_buffer,
 693 };
 694
 695 /* This is the table of extensions that the loader will dlsym() for. */
 696 PUBLIC const __DRIextension *__driDriverExtensions[] = {
 697     &driCoreExtension.base,
 698     &driLegacyExtension.base,
 699     &driDRI2Extension.base,
 700     NULL
 701 };
 702
 703 /* vim: set sw=3 ts=8 sts=3 expandtab: */