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