src/gallium/state_trackers/xorg/xorg_exa.c

   1 /*
   2  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  *
  26  * Author: Alan Hourihane <alanh@tungstengraphics.com>
  27  * Author: Jakob Bornecrantz <wallbraker@gmail.com>
  28  *
  29  */
  30
  31 #include "xorg_exa.h"
  32 #include "xorg_tracker.h"
  33 #include "xorg_composite.h"
  34 #include "xorg_exa_tgsi.h"
  35
  36 #include <xorg-server.h>
  37 #include <xf86.h>
  38 #include <picturestr.h>
  39 #include <picture.h>
  40
  41 #include "pipe/p_format.h"
  42 #include "pipe/p_context.h"
  43 #include "pipe/p_state.h"
  44 #include "pipe/p_inlines.h"
  45
  46 #include "util/u_format.h"
  47 #include "util/u_rect.h"
  48 #include "util/u_math.h"
  49 #include "util/u_debug.h"
  50
  51 #define DEBUG_PRINT 0
  52 #define ROUND_UP_TEXTURES 1
  53
  54 /*
  55  * Helper functions
  56  */
  57 struct render_format_str {
  58    int format;
  59    const char *name;
  60 };
  61 static const struct render_format_str formats_info[] =
  62 {
  63    {PICT_a8r8g8b8, "PICT_a8r8g8b8"},
  64    {PICT_x8r8g8b8, "PICT_x8r8g8b8"},
  65    {PICT_a8b8g8r8, "PICT_a8b8g8r8"},
  66    {PICT_x8b8g8r8, "PICT_x8b8g8r8"},
  67 #ifdef PICT_TYPE_BGRA
  68    {PICT_b8g8r8a8, "PICT_b8g8r8a8"},
  69    {PICT_b8g8r8x8, "PICT_b8g8r8x8"},
  70    {PICT_a2r10g10b10, "PICT_a2r10g10b10"},
  71    {PICT_x2r10g10b10, "PICT_x2r10g10b10"},
  72    {PICT_a2b10g10r10, "PICT_a2b10g10r10"},
  73    {PICT_x2b10g10r10, "PICT_x2b10g10r10"},
  74 #endif
  75    {PICT_r8g8b8, "PICT_r8g8b8"},
  76    {PICT_b8g8r8, "PICT_b8g8r8"},
  77    {PICT_r5g6b5, "PICT_r5g6b5"},
  78    {PICT_b5g6r5, "PICT_b5g6r5"},
  79    {PICT_a1r5g5b5, "PICT_a1r5g5b5"},
  80    {PICT_x1r5g5b5, "PICT_x1r5g5b5"},
  81    {PICT_a1b5g5r5, "PICT_a1b5g5r5"},
  82    {PICT_x1b5g5r5, "PICT_x1b5g5r5"},
  83    {PICT_a4r4g4b4, "PICT_a4r4g4b4"},
  84    {PICT_x4r4g4b4, "PICT_x4r4g4b4"},
  85    {PICT_a4b4g4r4, "PICT_a4b4g4r4"},
  86    {PICT_x4b4g4r4, "PICT_x4b4g4r4"},
  87    {PICT_a8, "PICT_a8"},
  88    {PICT_r3g3b2, "PICT_r3g3b2"},
  89    {PICT_b2g3r3, "PICT_b2g3r3"},
  90    {PICT_a2r2g2b2, "PICT_a2r2g2b2"},
  91    {PICT_a2b2g2r2, "PICT_a2b2g2r2"},
  92    {PICT_c8, "PICT_c8"},
  93    {PICT_g8, "PICT_g8"},
  94    {PICT_x4a4, "PICT_x4a4"},
  95    {PICT_x4c4, "PICT_x4c4"},
  96    {PICT_x4g4, "PICT_x4g4"},
  97    {PICT_a4, "PICT_a4"},
  98    {PICT_r1g2b1, "PICT_r1g2b1"},
  99    {PICT_b1g2r1, "PICT_b1g2r1"},
 100    {PICT_a1r1g1b1, "PICT_a1r1g1b1"},
 101    {PICT_a1b1g1r1, "PICT_a1b1g1r1"},
 102    {PICT_c4, "PICT_c4"},
 103    {PICT_g4, "PICT_g4"},
 104    {PICT_a1, "PICT_a1"},
 105    {PICT_g1, "PICT_g1"}
 106 };
 107 static const char *render_format_name(int format)
 108 {
 109    int i = 0;
 110    for (i = 0; i < sizeof(formats_info)/sizeof(formats_info[0]); ++i) {
 111       if (formats_info[i].format == format)
 112          return formats_info[i].name;
 113    }
 114    return NULL;
 115 }
 116
 117 static void
 118 exa_get_pipe_format(int depth, enum pipe_format *format, int *bbp, int *picture_format)
 119 {
 120     switch (depth) {
 121     case 32:
 122         *format = PIPE_FORMAT_A8R8G8B8_UNORM;
 123         *picture_format = PICT_a8r8g8b8;
 124         assert(*bbp == 32);
 125         break;
 126     case 24:
 127         *format = PIPE_FORMAT_X8R8G8B8_UNORM;
 128         *picture_format = PICT_x8r8g8b8;
 129         assert(*bbp == 32);
 130         break;
 131     case 16:
 132         *format = PIPE_FORMAT_R5G6B5_UNORM;
 133         *picture_format = PICT_r5g6b5;
 134         assert(*bbp == 16);
 135         break;
 136     case 15:
 137         *format = PIPE_FORMAT_A1R5G5B5_UNORM;
 138         *picture_format = PICT_x1r5g5b5;
 139         assert(*bbp == 16);
 140         break;
 141     case 8:
 142         *format = PIPE_FORMAT_L8_UNORM;
 143         *picture_format = PICT_a8;
 144         assert(*bbp == 8);
 145         break;
 146     case 4:
 147     case 1:
 148         *format = PIPE_FORMAT_A8R8G8B8_UNORM; /* bad bad bad */
 149         break;
 150     default:
 151         assert(0);
 152         break;
 153     }
 154 }
 155
 156
 157 /*
 158  * Static exported EXA functions
 159  */
 160
 161 static void
 162 ExaWaitMarker(ScreenPtr pScreen, int marker)
 163 {
 164    /* Nothing to do, handled in the PrepareAccess hook */
 165 }
 166
 167 static int
 168 ExaMarkSync(ScreenPtr pScreen)
 169 {
 170    return 1;
 171 }
 172
 173
 174 /***********************************************************************
 175  * Screen upload/download
 176  */
 177
 178 static Bool
 179 ExaDownloadFromScreen(PixmapPtr pPix, int x,  int y, int w,  int h, char *dst,
 180                       int dst_pitch)
 181 {
 182     ScreenPtr pScreen = pPix->drawable.pScreen;
 183     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 184     modesettingPtr ms = modesettingPTR(pScrn);
 185     struct exa_context *exa = ms->exa;
 186     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix);
 187     struct pipe_transfer *transfer;
 188
 189     if (!priv || !priv->tex)
 190         return FALSE;
 191
 192     if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
 193         PIPE_REFERENCED_FOR_WRITE)
 194         exa->pipe->flush(exa->pipe, 0, NULL);
 195
 196     transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
 197                                            PIPE_TRANSFER_READ, x, y, w, h);
 198     if (!transfer)
 199         return FALSE;
 200
 201 #if DEBUG_PRINT
 202     debug_printf("------ ExaDownloadFromScreen(%d, %d, %d, %d, %d)\n",
 203                  x, y, w, h, dst_pitch);
 204 #endif
 205
 206     util_copy_rect((unsigned char*)dst, priv->tex->format, dst_pitch, 0, 0,
 207                    w, h, exa->scrn->transfer_map(exa->scrn, transfer),
 208                    transfer->stride, 0, 0);
 209
 210     exa->scrn->transfer_unmap(exa->scrn, transfer);
 211     exa->scrn->tex_transfer_destroy(transfer);
 212
 213     return TRUE;
 214 }
 215
 216 static Bool
 217 ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src,
 218                   int src_pitch)
 219 {
 220     ScreenPtr pScreen = pPix->drawable.pScreen;
 221     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 222     modesettingPtr ms = modesettingPTR(pScrn);
 223     struct exa_context *exa = ms->exa;
 224     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix);
 225     struct pipe_transfer *transfer;
 226
 227     if (!priv || !priv->tex)
 228         return FALSE;
 229
 230     /* make sure that any pending operations are flushed to hardware */
 231     if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
 232         (PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE))
 233         xorg_exa_flush(exa, 0, NULL);
 234
 235     transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
 236                                            PIPE_TRANSFER_WRITE, x, y, w, h);
 237     if (!transfer)
 238         return FALSE;
 239
 240 #if DEBUG_PRINT
 241     debug_printf("++++++ ExaUploadToScreen(%d, %d, %d, %d, %d)\n",
 242                  x, y, w, h, src_pitch);
 243 #endif
 244
 245     util_copy_rect(exa->scrn->transfer_map(exa->scrn, transfer),
 246                    priv->tex->format, transfer->stride, 0, 0, w, h,
 247                    (unsigned char*)src, src_pitch, 0, 0);
 248
 249     exa->scrn->transfer_unmap(exa->scrn, transfer);
 250     exa->scrn->tex_transfer_destroy(transfer);
 251
 252     return TRUE;
 253 }
 254
 255 static Bool
 256 ExaPrepareAccess(PixmapPtr pPix, int index)
 257 {
 258     ScreenPtr pScreen = pPix->drawable.pScreen;
 259     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 260     modesettingPtr ms = modesettingPTR(pScrn);
 261     struct exa_context *exa = ms->exa;
 262     struct exa_pixmap_priv *priv;
 263
 264     priv = exaGetPixmapDriverPrivate(pPix);
 265
 266     if (!priv)
 267         return FALSE;
 268
 269     if (!priv->tex)
 270         return FALSE;
 271
 272     if (priv->map_count == 0)
 273     {
 274         if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
 275             PIPE_REFERENCED_FOR_WRITE)
 276             exa->pipe->flush(exa->pipe, 0, NULL);
 277
 278         assert(pPix->drawable.width <= priv->tex->width0);
 279         assert(pPix->drawable.height <= priv->tex->height0);
 280
 281         priv->map_transfer =
 282             exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
 283 #ifdef EXA_MIXED_PIXMAPS
 284                                         PIPE_TRANSFER_MAP_DIRECTLY |
 285 #endif
 286                                         PIPE_TRANSFER_READ_WRITE,
 287                                         0, 0,
 288                                         pPix->drawable.width,
 289                                         pPix->drawable.height );
 290         if (!priv->map_transfer)
 291 #ifdef EXA_MIXED_PIXMAPS
 292             return FALSE;
 293 #else
 294             FatalError("failed to create transfer\n");
 295 #endif
 296
 297         pPix->devPrivate.ptr =
 298             exa->scrn->transfer_map(exa->scrn, priv->map_transfer);
 299         pPix->devKind = priv->map_transfer->stride;
 300     }
 301
 302     priv->map_count++;
 303
 304     return TRUE;
 305 }
 306
 307 static void
 308 ExaFinishAccess(PixmapPtr pPix, int index)
 309 {
 310     ScreenPtr pScreen = pPix->drawable.pScreen;
 311     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 312     modesettingPtr ms = modesettingPTR(pScrn);
 313     struct exa_context *exa = ms->exa;
 314     struct exa_pixmap_priv *priv;
 315     priv = exaGetPixmapDriverPrivate(pPix);
 316
 317     if (!priv)
 318         return;
 319
 320     if (!priv->map_transfer)
 321         return;
 322
 323     if (--priv->map_count == 0) {
 324         assert(priv->map_transfer);
 325         exa->scrn->transfer_unmap(exa->scrn, priv->map_transfer);
 326         exa->scrn->tex_transfer_destroy(priv->map_transfer);
 327         priv->map_transfer = NULL;
 328         pPix->devPrivate.ptr = NULL;
 329     }
 330 }
 331
 332 /***********************************************************************
 333  * Solid Fills
 334  */
 335
 336 static Bool
 337 ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg)
 338 {
 339     ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
 340     modesettingPtr ms = modesettingPTR(pScrn);
 341     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 342     struct exa_context *exa = ms->exa;
 343
 344 #if DEBUG_PRINT
 345     debug_printf("ExaPrepareSolid(0x%x)\n", fg);
 346 #endif
 347     if (!exa->accel)
 348         return FALSE;
 349
 350     if (!exa->pipe)
 351         XORG_FALLBACK("accle not enabled");
 352
 353     if (!priv || !priv->tex)
 354         XORG_FALLBACK("%s", !priv ? "!priv" : "!priv->tex");
 355
 356     if (!EXA_PM_IS_SOLID(&pPixmap->drawable, planeMask))
 357         XORG_FALLBACK("planeMask is not solid");
 358
 359     if (alu != GXcopy)
 360         XORG_FALLBACK("not GXcopy");
 361
 362     if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
 363                                         priv->tex->target,
 364                                         PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
 365         XORG_FALLBACK("format %s", pf_name(priv->tex->format));
 366     }
 367
 368     return xorg_solid_bind_state(exa, priv, fg);
 369 }
 370
 371 static void
 372 ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1)
 373 {
 374     ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
 375     modesettingPtr ms = modesettingPTR(pScrn);
 376     struct exa_context *exa = ms->exa;
 377     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 378
 379 #if DEBUG_PRINT
 380     debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1);
 381 #endif
 382
 383     if (x0 == 0 && y0 == 0 &&
 384         x1 == pPixmap->drawable.width && y1 == pPixmap->drawable.height) {
 385        exa->pipe->clear(exa->pipe, PIPE_CLEAR_COLOR, exa->solid_color, 0.0, 0);
 386        return;
 387     }
 388
 389     xorg_solid(exa, priv, x0, y0, x1, y1) ;
 390 }
 391
 392
 393 static void
 394 ExaDoneSolid(PixmapPtr pPixmap)
 395 {
 396     ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
 397     modesettingPtr ms = modesettingPTR(pScrn);
 398     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 399     struct exa_context *exa = ms->exa;
 400
 401     if (!priv)
 402         return;
 403
 404     xorg_composite_done(exa);
 405 }
 406
 407 /***********************************************************************
 408  * Copy Blits
 409  */
 410
 411 static Bool
 412 ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
 413                int ydir, int alu, Pixel planeMask)
 414 {
 415     ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
 416     modesettingPtr ms = modesettingPTR(pScrn);
 417     struct exa_context *exa = ms->exa;
 418     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
 419     struct exa_pixmap_priv *src_priv = exaGetPixmapDriverPrivate(pSrcPixmap);
 420
 421 #if DEBUG_PRINT
 422     debug_printf("ExaPrepareCopy\n");
 423 #endif
 424
 425     if (!exa->accel)
 426         return FALSE;
 427
 428     if (!exa->pipe)
 429         XORG_FALLBACK("accle not enabled");
 430
 431     if (!priv || !priv->tex)
 432         XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex");
 433
 434     if (!src_priv || !src_priv->tex)
 435         XORG_FALLBACK("pSrc %s", !src_priv ? "!priv" : "!priv->tex");
 436
 437     if (!EXA_PM_IS_SOLID(&pSrcPixmap->drawable, planeMask))
 438         XORG_FALLBACK("planeMask is not solid");
 439
 440     if (alu != GXcopy)
 441         XORG_FALLBACK("alu not GXcopy");
 442
 443     if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
 444                                         priv->tex->target,
 445                                         PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))
 446         XORG_FALLBACK("pDst format %s", pf_name(priv->tex->format));
 447
 448     if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format,
 449                                         src_priv->tex->target,
 450                                         PIPE_TEXTURE_USAGE_SAMPLER, 0))
 451         XORG_FALLBACK("pSrc format %s", pf_name(src_priv->tex->format));
 452
 453     exa->copy.src = src_priv;
 454     exa->copy.dst = priv;
 455
 456     /* For same-surface copies, the pipe->surface_copy path is clearly
 457      * superior, providing it is implemented.  In other cases it's not
 458      * clear what the better path would be, and eventually we'd
 459      * probably want to gather timings and choose dynamically.
 460      */
 461     if (exa->pipe->surface_copy &&
 462         exa->copy.src == exa->copy.dst) {
 463
 464        exa->copy.use_surface_copy = TRUE;
 465
 466        exa->copy.src_surface =
 467           exa->scrn->get_tex_surface( exa->scrn,
 468                                       exa->copy.src->tex,
 469                                       0, 0, 0,
 470                                       PIPE_BUFFER_USAGE_GPU_READ);
 471
 472        exa->copy.dst_surface =
 473           exa->scrn->get_tex_surface( exa->scrn,
 474                                       exa->copy.dst->tex,
 475                                       0, 0, 0,
 476                                       PIPE_BUFFER_USAGE_GPU_WRITE );
 477     }
 478     else {
 479        exa->copy.use_surface_copy = FALSE;
 480
 481        if (exa->copy.dst == exa->copy.src)
 482           exa->copy.src_texture = renderer_clone_texture( exa->renderer,
 483                                                           exa->copy.src->tex );
 484        else
 485           pipe_texture_reference(&exa->copy.src_texture,
 486                                  exa->copy.src->tex);
 487
 488        exa->copy.dst_surface =
 489           exa->scrn->get_tex_surface(exa->scrn,
 490                                      exa->copy.dst->tex,
 491                                      0, 0, 0,
 492                                      PIPE_BUFFER_USAGE_GPU_WRITE);
 493
 494
 495        renderer_copy_prepare(exa->renderer,
 496                              exa->copy.dst_surface,
 497                              exa->copy.src_texture );
 498     }
 499
 500
 501     return TRUE;
 502 }
 503
 504 static void
 505 ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
 506         int width, int height)
 507 {
 508    ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
 509    modesettingPtr ms = modesettingPTR(pScrn);
 510    struct exa_context *exa = ms->exa;
 511    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
 512
 513 #if DEBUG_PRINT
 514    debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n",
 515                 srcX, srcY, dstX, dstY, width, height);
 516 #endif
 517
 518    debug_assert(priv == exa->copy.dst);
 519    (void) priv;
 520
 521    if (exa->copy.use_surface_copy) {
 522       /* XXX: consider exposing >1 box in surface_copy interface.
 523        */
 524       exa->pipe->surface_copy( exa->pipe,
 525                              exa->copy.dst_surface,
 526                              dstX, dstY,
 527                              exa->copy.src_surface,
 528                              srcX, srcY,
 529                              width, height );
 530    }
 531    else {
 532       renderer_copy_pixmap(exa->renderer,
 533                            dstX, dstY,
 534                            srcX, srcY,
 535                            width, height,
 536                            exa->copy.src_texture->width0,
 537                            exa->copy.src_texture->height0);
 538    }
 539 }
 540
 541 static void
 542 ExaDoneCopy(PixmapPtr pPixmap)
 543 {
 544     ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
 545     modesettingPtr ms = modesettingPTR(pScrn);
 546     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 547     struct exa_context *exa = ms->exa;
 548
 549     if (!priv)
 550         return;
 551
 552    renderer_draw_flush(exa->renderer);
 553
 554    exa->copy.src = NULL;
 555    exa->copy.dst = NULL;
 556    pipe_surface_reference(&exa->copy.src_surface, NULL);
 557    pipe_surface_reference(&exa->copy.dst_surface, NULL);
 558    pipe_texture_reference(&exa->copy.src_texture, NULL);
 559 }
 560
 561
 562
 563 static Bool
 564 picture_check_formats(struct exa_pixmap_priv *pSrc, PicturePtr pSrcPicture)
 565 {
 566    if (pSrc->picture_format == pSrcPicture->format)
 567       return TRUE;
 568
 569    if (pSrc->picture_format != PICT_a8r8g8b8)
 570       return FALSE;
 571
 572    /* pSrc->picture_format == PICT_a8r8g8b8 */
 573    switch (pSrcPicture->format) {
 574    case PICT_a8r8g8b8:
 575    case PICT_x8r8g8b8:
 576    case PICT_a8b8g8r8:
 577    case PICT_x8b8g8r8:
 578    /* just treat these two as x8... */
 579    case PICT_r8g8b8:
 580    case PICT_b8g8r8:
 581       return TRUE;
 582 #ifdef PICT_TYPE_BGRA
 583    case PICT_b8g8r8a8:
 584    case PICT_b8g8r8x8:
 585       return FALSE; /* does not support swizzleing the alpha channel yet */
 586    case PICT_a2r10g10b10:
 587    case PICT_x2r10g10b10:
 588    case PICT_a2b10g10r10:
 589    case PICT_x2b10g10r10:
 590       return FALSE;
 591 #endif
 592    default:
 593       return FALSE;
 594    }
 595    return FALSE;
 596 }
 597
 598 /***********************************************************************
 599  * Composite entrypoints
 600  */
 601
 602 static Bool
 603 ExaCheckComposite(int op,
 604                   PicturePtr pSrcPicture, PicturePtr pMaskPicture,
 605                   PicturePtr pDstPicture)
 606 {
 607    ScrnInfoPtr pScrn = xf86Screens[pDstPicture->pDrawable->pScreen->myNum];
 608    modesettingPtr ms = modesettingPTR(pScrn);
 609    struct exa_context *exa = ms->exa;
 610
 611 #if DEBUG_PRINT
 612    debug_printf("ExaCheckComposite(%d, %p, %p, %p) = %d\n",
 613                 op, pSrcPicture, pMaskPicture, pDstPicture, accelerated);
 614 #endif
 615
 616    if (!exa->accel)
 617        return FALSE;
 618
 619    return xorg_composite_accelerated(op,
 620                                      pSrcPicture,
 621                                      pMaskPicture,
 622                                      pDstPicture);
 623 }
 624
 625
 626 static Bool
 627 ExaPrepareComposite(int op, PicturePtr pSrcPicture,
 628                     PicturePtr pMaskPicture, PicturePtr pDstPicture,
 629                     PixmapPtr pSrc, PixmapPtr pMask, PixmapPtr pDst)
 630 {
 631    ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
 632    modesettingPtr ms = modesettingPTR(pScrn);
 633    struct exa_context *exa = ms->exa;
 634    struct exa_pixmap_priv *priv;
 635
 636    if (!exa->accel)
 637        return FALSE;
 638
 639 #if DEBUG_PRINT
 640    debug_printf("ExaPrepareComposite(%d, src=0x%p, mask=0x%p, dst=0x%p)\n",
 641                 op, pSrcPicture, pMaskPicture, pDstPicture);
 642    debug_printf("\tFormats: src(%s), mask(%s), dst(%s)\n",
 643                 pSrcPicture ? render_format_name(pSrcPicture->format) : "none",
 644                 pMaskPicture ? render_format_name(pMaskPicture->format) : "none",
 645                 pDstPicture ? render_format_name(pDstPicture->format) : "none");
 646 #endif
 647    if (!exa->pipe)
 648       XORG_FALLBACK("accle not enabled");
 649
 650    priv = exaGetPixmapDriverPrivate(pDst);
 651    if (!priv || !priv->tex)
 652       XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex");
 653
 654    if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
 655                                        priv->tex->target,
 656                                        PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))
 657       XORG_FALLBACK("pDst format: %s", pf_name(priv->tex->format));
 658
 659    if (priv->picture_format != pDstPicture->format)
 660       XORG_FALLBACK("pDst pic_format: %s != %s",
 661                     render_format_name(priv->picture_format),
 662                     render_format_name(pDstPicture->format));
 663
 664    if (pSrc) {
 665       priv = exaGetPixmapDriverPrivate(pSrc);
 666       if (!priv || !priv->tex)
 667          XORG_FALLBACK("pSrc %s", !priv ? "!priv" : "!priv->tex");
 668
 669       if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
 670                                           priv->tex->target,
 671                                           PIPE_TEXTURE_USAGE_SAMPLER, 0))
 672          XORG_FALLBACK("pSrc format: %s", pf_name(priv->tex->format));
 673
 674       if (!picture_check_formats(priv, pSrcPicture))
 675          XORG_FALLBACK("pSrc pic_format: %s != %s",
 676                        render_format_name(priv->picture_format),
 677                        render_format_name(pSrcPicture->format));
 678
 679    }
 680
 681    if (pMask) {
 682       priv = exaGetPixmapDriverPrivate(pMask);
 683       if (!priv || !priv->tex)
 684          XORG_FALLBACK("pMask %s", !priv ? "!priv" : "!priv->tex");
 685
 686       if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
 687                                           priv->tex->target,
 688                                           PIPE_TEXTURE_USAGE_SAMPLER, 0))
 689          XORG_FALLBACK("pMask format: %s", pf_name(priv->tex->format));
 690
 691       if (!picture_check_formats(priv, pMaskPicture))
 692          XORG_FALLBACK("pMask pic_format: %s != %s",
 693                        render_format_name(priv->picture_format),
 694                        render_format_name(pMaskPicture->format));
 695    }
 696
 697    return xorg_composite_bind_state(exa, op, pSrcPicture, pMaskPicture,
 698                                     pDstPicture,
 699                                     pSrc ? exaGetPixmapDriverPrivate(pSrc) : NULL,
 700                                     pMask ? exaGetPixmapDriverPrivate(pMask) : NULL,
 701                                     exaGetPixmapDriverPrivate(pDst));
 702 }
 703
 704 static void
 705 ExaComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY,
 706              int dstX, int dstY, int width, int height)
 707 {
 708    ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
 709    modesettingPtr ms = modesettingPTR(pScrn);
 710    struct exa_context *exa = ms->exa;
 711    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDst);
 712
 713 #if DEBUG_PRINT
 714    debug_printf("\tExaComposite(src[%d,%d], mask=[%d, %d], dst=[%d, %d], dim=[%d, %d])\n",
 715                 srcX, srcY, maskX, maskY, dstX, dstY, width, height);
 716    debug_printf("\t   Num bound samplers = %d\n",
 717                 exa->num_bound_samplers);
 718 #endif
 719
 720    xorg_composite(exa, priv, srcX, srcY, maskX, maskY,
 721                   dstX, dstY, width, height);
 722 }
 723
 724
 725
 726 static void
 727 ExaDoneComposite(PixmapPtr pPixmap)
 728 {
 729    ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
 730    modesettingPtr ms = modesettingPTR(pScrn);
 731    struct exa_context *exa = ms->exa;
 732
 733    xorg_composite_done(exa);
 734 }
 735
 736
 737 /***********************************************************************
 738  * Pixmaps
 739  */
 740
 741 static void *
 742 ExaCreatePixmap(ScreenPtr pScreen, int size, int align)
 743 {
 744     struct exa_pixmap_priv *priv;
 745
 746     priv = xcalloc(1, sizeof(struct exa_pixmap_priv));
 747     if (!priv)
 748         return NULL;
 749
 750     return priv;
 751 }
 752
 753 static void
 754 ExaDestroyPixmap(ScreenPtr pScreen, void *dPriv)
 755 {
 756     struct exa_pixmap_priv *priv = (struct exa_pixmap_priv *)dPriv;
 757
 758     if (!priv)
 759         return;
 760
 761     pipe_texture_reference(&priv->tex, NULL);
 762
 763     xfree(priv);
 764 }
 765
 766 static Bool
 767 ExaPixmapIsOffscreen(PixmapPtr pPixmap)
 768 {
 769     struct exa_pixmap_priv *priv;
 770
 771     priv = exaGetPixmapDriverPrivate(pPixmap);
 772
 773     if (!priv)
 774         return FALSE;
 775
 776     if (priv->tex)
 777         return TRUE;
 778
 779     return FALSE;
 780 }
 781
 782 int
 783 xorg_exa_set_displayed_usage(PixmapPtr pPixmap)
 784 {
 785     struct exa_pixmap_priv *priv;
 786     priv = exaGetPixmapDriverPrivate(pPixmap);
 787
 788     if (!priv) {
 789         FatalError("NO PIXMAP PRIVATE\n");
 790         return 0;
 791     }
 792
 793     priv->flags |= PIPE_TEXTURE_USAGE_PRIMARY;
 794
 795     return 0;
 796 }
 797
 798 int
 799 xorg_exa_set_shared_usage(PixmapPtr pPixmap)
 800 {
 801     struct exa_pixmap_priv *priv;
 802     priv = exaGetPixmapDriverPrivate(pPixmap);
 803
 804     if (!priv) {
 805         FatalError("NO PIXMAP PRIVATE\n");
 806         return 0;
 807     }
 808
 809     priv->flags |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
 810
 811     return 0;
 812 }
 813
 814 unsigned
 815 xorg_exa_get_pixmap_handle(PixmapPtr pPixmap, unsigned *stride_out)
 816 {
 817     ScreenPtr pScreen = pPixmap->drawable.pScreen;
 818     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 819     modesettingPtr ms = modesettingPTR(pScrn);
 820     struct exa_pixmap_priv *priv;
 821     unsigned handle;
 822     unsigned stride;
 823
 824     if (!ms->exa) {
 825         FatalError("NO MS->EXA\n");
 826         return 0;
 827     }
 828
 829     priv = exaGetPixmapDriverPrivate(pPixmap);
 830
 831     if (!priv) {
 832         FatalError("NO PIXMAP PRIVATE\n");
 833         return 0;
 834     }
 835
 836     ms->api->local_handle_from_texture(ms->api, ms->screen, priv->tex, &stride, &handle);
 837     if (stride_out)
 838         *stride_out = stride;
 839
 840     return handle;
 841 }
 842
 843 static Bool
 844 size_match( int width, int tex_width )
 845 {
 846 #if ROUND_UP_TEXTURES
 847    if (width > tex_width)
 848       return FALSE;
 849
 850    if (width * 2 < tex_width)
 851       return FALSE;
 852
 853    return TRUE;
 854 #else
 855    return width == tex_width;
 856 #endif
 857 }
 858
 859 static Bool
 860 ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
 861                       int depth, int bitsPerPixel, int devKind,
 862                       pointer pPixData)
 863 {
 864     ScreenPtr pScreen = pPixmap->drawable.pScreen;
 865     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 866     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 867     modesettingPtr ms = modesettingPTR(pScrn);
 868     struct exa_context *exa = ms->exa;
 869
 870     if (!priv || pPixData)
 871         return FALSE;
 872
 873     if (0) {
 874        debug_printf("%s pixmap %p sz %dx%dx%d devKind %d\n",
 875                     __FUNCTION__, pPixmap, width, height, bitsPerPixel, devKind);
 876
 877        if (priv->tex)
 878           debug_printf("  ==> old texture %dx%d\n",
 879                        priv->tex->width0,
 880                        priv->tex->height0);
 881     }
 882
 883
 884     if (depth <= 0)
 885         depth = pPixmap->drawable.depth;
 886
 887     if (bitsPerPixel <= 0)
 888         bitsPerPixel = pPixmap->drawable.bitsPerPixel;
 889
 890     if (width <= 0)
 891         width = pPixmap->drawable.width;
 892
 893     if (height <= 0)
 894         height = pPixmap->drawable.height;
 895
 896     if (width <= 0 || height <= 0 || depth <= 0)
 897         return FALSE;
 898
 899     miModifyPixmapHeader(pPixmap, width, height, depth,
 900                              bitsPerPixel, devKind, NULL);
 901
 902     priv->width = width;
 903     priv->height = height;
 904
 905     /* Deal with screen resize */
 906     if ((exa->accel || priv->flags) &&
 907         (!priv->tex ||
 908          !size_match(width, priv->tex->width0) ||
 909          !size_match(height, priv->tex->height0) ||
 910          priv->tex_flags != priv->flags)) {
 911         struct pipe_texture *texture = NULL;
 912         struct pipe_texture template;
 913
 914         memset(&template, 0, sizeof(template));
 915         template.target = PIPE_TEXTURE_2D;
 916         exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &priv->picture_format);
 917         if (ROUND_UP_TEXTURES && priv->flags == 0) {
 918            template.width0 = util_next_power_of_two(width);
 919            template.height0 = util_next_power_of_two(height);
 920         }
 921         else {
 922            template.width0 = width;
 923            template.height0 = height;
 924         }
 925
 926         template.depth0 = 1;
 927         template.last_level = 0;
 928         template.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET | priv->flags;
 929         priv->tex_flags = priv->flags;
 930         texture = exa->scrn->texture_create(exa->scrn, &template);
 931
 932         if (priv->tex) {
 933             struct pipe_surface *dst_surf;
 934             struct pipe_surface *src_surf;
 935
 936             dst_surf = exa->scrn->get_tex_surface(
 937                 exa->scrn, texture, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
 938             src_surf = xorg_gpu_surface(exa->pipe->screen, priv);
 939             if (exa->pipe->surface_copy) {
 940                exa->pipe->surface_copy(exa->pipe, dst_surf, 0, 0, src_surf,
 941                                        0, 0, min(width, texture->width0),
 942                                        min(height, texture->height0));
 943             } else {
 944                util_surface_copy(exa->pipe, FALSE, dst_surf, 0, 0, src_surf,
 945                                  0, 0, min(width, texture->width0),
 946                                  min(height, texture->height0));
 947             }
 948             exa->scrn->tex_surface_destroy(dst_surf);
 949             exa->scrn->tex_surface_destroy(src_surf);
 950         }
 951
 952         pipe_texture_reference(&priv->tex, texture);
 953         /* the texture we create has one reference */
 954         pipe_texture_reference(&texture, NULL);
 955     }
 956
 957     return TRUE;
 958 }
 959
 960 struct pipe_texture *
 961 xorg_exa_get_texture(PixmapPtr pPixmap)
 962 {
 963    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 964    struct pipe_texture *tex = NULL;
 965    pipe_texture_reference(&tex, priv->tex);
 966    return tex;
 967 }
 968
 969 Bool
 970 xorg_exa_set_texture(PixmapPtr pPixmap, struct  pipe_texture *tex)
 971 {
 972     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 973
 974     int mask = PIPE_TEXTURE_USAGE_PRIMARY | PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
 975
 976     if (!priv)
 977         return FALSE;
 978
 979     if (pPixmap->drawable.width != tex->width0 ||
 980         pPixmap->drawable.height != tex->height0)
 981         return FALSE;
 982
 983     pipe_texture_reference(&priv->tex, tex);
 984     priv->tex_flags = tex->tex_usage & mask;
 985
 986     return TRUE;
 987 }
 988
 989 struct pipe_texture *
 990 xorg_exa_create_root_texture(ScrnInfoPtr pScrn,
 991                              int width, int height,
 992                              int depth, int bitsPerPixel)
 993 {
 994     modesettingPtr ms = modesettingPTR(pScrn);
 995     struct exa_context *exa = ms->exa;
 996     struct pipe_texture template;
 997     int dummy;
 998
 999     memset(&template, 0, sizeof(template));
1000     template.target = PIPE_TEXTURE_2D;
1001     exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &dummy);
1002     template.width0 = width;
1003     template.height0 = height;
1004     template.depth0 = 1;
1005     template.last_level = 0;
1006     template.tex_usage |= PIPE_TEXTURE_USAGE_RENDER_TARGET;
1007     template.tex_usage |= PIPE_TEXTURE_USAGE_PRIMARY;
1008     template.tex_usage |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
1009
1010     return exa->scrn->texture_create(exa->scrn, &template);
1011 }
1012
1013 void
1014 xorg_exa_close(ScrnInfoPtr pScrn)
1015 {
1016    modesettingPtr ms = modesettingPTR(pScrn);
1017    struct exa_context *exa = ms->exa;
1018
1019    renderer_destroy(exa->renderer);
1020
1021    if (exa->pipe)
1022       exa->pipe->destroy(exa->pipe);
1023    exa->pipe = NULL;
1024    /* Since this was shared be proper with the pointer */
1025    ms->ctx = NULL;
1026
1027    exaDriverFini(pScrn->pScreen);
1028    xfree(exa);
1029    ms->exa = NULL;
1030 }
1031
1032 void *
1033 xorg_exa_init(ScrnInfoPtr pScrn, Bool accel)
1034 {
1035    modesettingPtr ms = modesettingPTR(pScrn);
1036    struct exa_context *exa;
1037    ExaDriverPtr pExa;
1038
1039    exa = xcalloc(1, sizeof(struct exa_context));
1040    if (!exa)
1041       return NULL;
1042
1043    pExa = exaDriverAlloc();
1044    if (!pExa) {
1045       goto out_err;
1046    }
1047
1048    memset(pExa, 0, sizeof(*pExa));
1049
1050    pExa->exa_major         = 2;
1051    pExa->exa_minor         = 2;
1052    pExa->memoryBase        = 0;
1053    pExa->memorySize        = 0;
1054    pExa->offScreenBase     = 0;
1055    pExa->pixmapOffsetAlign = 0;
1056    pExa->pixmapPitchAlign  = 1;
1057    pExa->flags             = EXA_OFFSCREEN_PIXMAPS | EXA_HANDLES_PIXMAPS;
1058 #ifdef EXA_SUPPORTS_PREPARE_AUX
1059    pExa->flags            |= EXA_SUPPORTS_PREPARE_AUX;
1060 #endif
1061 #ifdef EXA_MIXED_PIXMAPS
1062    pExa->flags            |= EXA_MIXED_PIXMAPS;
1063 #endif
1064    pExa->maxX              = 8191; /* FIXME */
1065    pExa->maxY              = 8191; /* FIXME */
1066
1067    pExa->WaitMarker         = ExaWaitMarker;
1068    pExa->MarkSync           = ExaMarkSync;
1069    pExa->PrepareSolid       = ExaPrepareSolid;
1070    pExa->Solid              = ExaSolid;
1071    pExa->DoneSolid          = ExaDoneSolid;
1072    pExa->PrepareCopy        = ExaPrepareCopy;
1073    pExa->Copy               = ExaCopy;
1074    pExa->DoneCopy           = ExaDoneCopy;
1075    pExa->CheckComposite     = ExaCheckComposite;
1076    pExa->PrepareComposite   = ExaPrepareComposite;
1077    pExa->Composite          = ExaComposite;
1078    pExa->DoneComposite      = ExaDoneComposite;
1079    pExa->PixmapIsOffscreen  = ExaPixmapIsOffscreen;
1080    pExa->DownloadFromScreen = ExaDownloadFromScreen;
1081    pExa->UploadToScreen     = ExaUploadToScreen;
1082    pExa->PrepareAccess      = ExaPrepareAccess;
1083    pExa->FinishAccess       = ExaFinishAccess;
1084    pExa->CreatePixmap       = ExaCreatePixmap;
1085    pExa->DestroyPixmap      = ExaDestroyPixmap;
1086    pExa->ModifyPixmapHeader = ExaModifyPixmapHeader;
1087
1088    if (!exaDriverInit(pScrn->pScreen, pExa)) {
1089       goto out_err;
1090    }
1091
1092    exa->scrn = ms->screen;
1093    exa->pipe = ms->api->create_context(ms->api, exa->scrn);
1094    /* Share context with DRI */
1095    ms->ctx = exa->pipe;
1096
1097    exa->renderer = renderer_create(exa->pipe);
1098    exa->accel = accel;
1099
1100    return (void *)exa;
1101
1102 out_err:
1103    xorg_exa_close(pScrn);
1104
1105    return NULL;
1106 }
1107
1108 struct pipe_surface *
1109 xorg_gpu_surface(struct pipe_screen *scrn, struct exa_pixmap_priv *priv)
1110 {
1111    return scrn->get_tex_surface(scrn, priv->tex, 0, 0, 0,
1112                                 PIPE_BUFFER_USAGE_GPU_READ |
1113                                 PIPE_BUFFER_USAGE_GPU_WRITE);
1114
1115 }
1116
1117 void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags,
1118                     struct pipe_fence_handle **fence)
1119 {
1120    exa->pipe->flush(exa->pipe, pipeFlushFlags, fence);
1121 }
1122
1123 void xorg_exa_finish(struct exa_context *exa)
1124 {
1125    struct pipe_fence_handle *fence = NULL;
1126
1127    xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, &fence);
1128
1129    exa->pipe->screen->fence_finish(exa->pipe->screen, fence, 0);
1130    exa->pipe->screen->fence_reference(exa->pipe->screen, &fence, NULL);
1131 }
1132