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