xorg_exa.c revision 8b0c217f2bc123bffd25cc4977d6abb1b3fa8186
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 45#include "util/u_rect.h" 46#include "util/u_math.h" 47#include "util/u_debug.h" 48#include "util/u_format.h" 49#include "util/u_surface.h" 50 51#define DEBUG_PRINT 0 52#define ROUND_UP_TEXTURES 1 53 54/* 55 * Helper functions 56 */ 57struct render_format_str { 58 int format; 59 const char *name; 60}; 61static 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}; 107static 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 117static void 118exa_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_B8G8R8A8_UNORM; 123 *picture_format = PICT_a8r8g8b8; 124 assert(*bbp == 32); 125 break; 126 case 24: 127 *format = PIPE_FORMAT_B8G8R8X8_UNORM; 128 *picture_format = PICT_x8r8g8b8; 129 assert(*bbp == 32); 130 break; 131 case 16: 132 *format = PIPE_FORMAT_B5G6R5_UNORM; 133 *picture_format = PICT_r5g6b5; 134 assert(*bbp == 16); 135 break; 136 case 15: 137 *format = PIPE_FORMAT_B5G5R5A1_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_B8G8R8A8_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 161static void 162ExaWaitMarker(ScreenPtr pScreen, int marker) 163{ 164 /* Nothing to do, handled in the PrepareAccess hook */ 165} 166 167static int 168ExaMarkSync(ScreenPtr pScreen) 169{ 170 return 1; 171} 172 173 174/*********************************************************************** 175 * Screen upload/download 176 */ 177 178static Bool 179ExaDownloadFromScreen(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 transfer = pipe_get_transfer(exa->pipe, priv->tex, 0, 0, 0, 193 PIPE_TRANSFER_READ, x, y, w, h); 194 if (!transfer) 195 return FALSE; 196 197#if DEBUG_PRINT 198 debug_printf("------ ExaDownloadFromScreen(%d, %d, %d, %d, %d)\n", 199 x, y, w, h, dst_pitch); 200#endif 201 202 util_copy_rect((unsigned char*)dst, priv->tex->format, dst_pitch, 0, 0, 203 w, h, exa->pipe->transfer_map(exa->pipe, transfer), 204 transfer->stride, 0, 0); 205 206 exa->pipe->transfer_unmap(exa->pipe, transfer); 207 exa->pipe->transfer_destroy(exa->pipe, transfer); 208 209 return TRUE; 210} 211 212static Bool 213ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src, 214 int src_pitch) 215{ 216 ScreenPtr pScreen = pPix->drawable.pScreen; 217 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 218 modesettingPtr ms = modesettingPTR(pScrn); 219 struct exa_context *exa = ms->exa; 220 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix); 221 struct pipe_transfer *transfer; 222 223 if (!priv || !priv->tex) 224 return FALSE; 225 226 transfer = pipe_get_transfer(exa->pipe, priv->tex, 0, 0, 0, 227 PIPE_TRANSFER_WRITE, x, y, w, h); 228 if (!transfer) 229 return FALSE; 230 231#if DEBUG_PRINT 232 debug_printf("++++++ ExaUploadToScreen(%d, %d, %d, %d, %d)\n", 233 x, y, w, h, src_pitch); 234#endif 235 236 util_copy_rect(exa->pipe->transfer_map(exa->pipe, transfer), 237 priv->tex->format, transfer->stride, 0, 0, w, h, 238 (unsigned char*)src, src_pitch, 0, 0); 239 240 exa->pipe->transfer_unmap(exa->pipe, transfer); 241 exa->pipe->transfer_destroy(exa->pipe, transfer); 242 243 return TRUE; 244} 245 246static Bool 247ExaPrepareAccess(PixmapPtr pPix, int index) 248{ 249 ScreenPtr pScreen = pPix->drawable.pScreen; 250 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 251 modesettingPtr ms = modesettingPTR(pScrn); 252 struct exa_context *exa = ms->exa; 253 struct exa_pixmap_priv *priv; 254 255 priv = exaGetPixmapDriverPrivate(pPix); 256 257 if (!priv) 258 return FALSE; 259 260 if (!priv->tex) 261 return FALSE; 262 263 if (priv->map_count == 0) 264 { 265 assert(pPix->drawable.width <= priv->tex->width0); 266 assert(pPix->drawable.height <= priv->tex->height0); 267 268 priv->map_transfer = 269 pipe_get_transfer(exa->pipe, priv->tex, 0, 0, 0, 270#ifdef EXA_MIXED_PIXMAPS 271 PIPE_TRANSFER_MAP_DIRECTLY | 272#endif 273 PIPE_TRANSFER_READ_WRITE, 274 0, 0, 275 pPix->drawable.width, 276 pPix->drawable.height ); 277 if (!priv->map_transfer) 278#ifdef EXA_MIXED_PIXMAPS 279 return FALSE; 280#else 281 FatalError("failed to create transfer\n"); 282#endif 283 284 pPix->devPrivate.ptr = 285 exa->pipe->transfer_map(exa->pipe, priv->map_transfer); 286 pPix->devKind = priv->map_transfer->stride; 287 } 288 289 priv->map_count++; 290 291 return TRUE; 292} 293 294static void 295ExaFinishAccess(PixmapPtr pPix, int index) 296{ 297 ScreenPtr pScreen = pPix->drawable.pScreen; 298 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 299 modesettingPtr ms = modesettingPTR(pScrn); 300 struct exa_context *exa = ms->exa; 301 struct exa_pixmap_priv *priv; 302 priv = exaGetPixmapDriverPrivate(pPix); 303 304 if (!priv) 305 return; 306 307 if (!priv->map_transfer) 308 return; 309 310 if (--priv->map_count == 0) { 311 assert(priv->map_transfer); 312 exa->pipe->transfer_unmap(exa->pipe, priv->map_transfer); 313 exa->pipe->transfer_destroy(exa->pipe, priv->map_transfer); 314 priv->map_transfer = NULL; 315 pPix->devPrivate.ptr = NULL; 316 } 317} 318 319/*********************************************************************** 320 * Solid Fills 321 */ 322 323static Bool 324ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg) 325{ 326 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; 327 modesettingPtr ms = modesettingPTR(pScrn); 328 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); 329 struct exa_context *exa = ms->exa; 330 331#if DEBUG_PRINT 332 debug_printf("ExaPrepareSolid(0x%x)\n", fg); 333#endif 334 if (!exa->accel) 335 return FALSE; 336 337 if (!exa->pipe) 338 XORG_FALLBACK("accle not enabled"); 339 340 if (!priv || !priv->tex) 341 XORG_FALLBACK("%s", !priv ? "!priv" : "!priv->tex"); 342 343 if (!EXA_PM_IS_SOLID(&pPixmap->drawable, planeMask)) 344 XORG_FALLBACK("planeMask is not solid"); 345 346 if (alu != GXcopy) 347 XORG_FALLBACK("not GXcopy"); 348 349 if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, 350 priv->tex->target, 351 PIPE_BIND_RENDER_TARGET, 0)) { 352 XORG_FALLBACK("format %s", util_format_name(priv->tex->format)); 353 } 354 355 return xorg_solid_bind_state(exa, priv, fg); 356} 357 358static void 359ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1) 360{ 361 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; 362 modesettingPtr ms = modesettingPTR(pScrn); 363 struct exa_context *exa = ms->exa; 364 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); 365 366#if DEBUG_PRINT 367 debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1); 368#endif 369 370 if (x0 == 0 && y0 == 0 && 371 x1 == pPixmap->drawable.width && y1 == pPixmap->drawable.height) { 372 exa->pipe->clear(exa->pipe, PIPE_CLEAR_COLOR, exa->solid_color, 0.0, 0); 373 return; 374 } 375 376 xorg_solid(exa, priv, x0, y0, x1, y1) ; 377} 378 379 380static void 381ExaDoneSolid(PixmapPtr pPixmap) 382{ 383 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; 384 modesettingPtr ms = modesettingPTR(pScrn); 385 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); 386 struct exa_context *exa = ms->exa; 387 388 if (!priv) 389 return; 390 391 xorg_composite_done(exa); 392} 393 394/*********************************************************************** 395 * Copy Blits 396 */ 397 398static Bool 399ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir, 400 int ydir, int alu, Pixel planeMask) 401{ 402 ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum]; 403 modesettingPtr ms = modesettingPTR(pScrn); 404 struct exa_context *exa = ms->exa; 405 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap); 406 struct exa_pixmap_priv *src_priv = exaGetPixmapDriverPrivate(pSrcPixmap); 407 408#if DEBUG_PRINT 409 debug_printf("ExaPrepareCopy\n"); 410#endif 411 412 if (!exa->accel) 413 return FALSE; 414 415 if (!exa->pipe) 416 XORG_FALLBACK("accle not enabled"); 417 418 if (!priv || !priv->tex) 419 XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex"); 420 421 if (!src_priv || !src_priv->tex) 422 XORG_FALLBACK("pSrc %s", !src_priv ? "!priv" : "!priv->tex"); 423 424 if (!EXA_PM_IS_SOLID(&pSrcPixmap->drawable, planeMask)) 425 XORG_FALLBACK("planeMask is not solid"); 426 427 if (alu != GXcopy) 428 XORG_FALLBACK("alu not GXcopy"); 429 430 if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, 431 priv->tex->target, 432 PIPE_BIND_RENDER_TARGET, 0)) 433 XORG_FALLBACK("pDst format %s", util_format_name(priv->tex->format)); 434 435 if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format, 436 src_priv->tex->target, 437 PIPE_BIND_SAMPLER_VIEW, 0)) 438 XORG_FALLBACK("pSrc format %s", util_format_name(src_priv->tex->format)); 439 440 exa->copy.src = src_priv; 441 exa->copy.dst = priv; 442 443 /* For same-surface copies, the pipe->surface_copy path is clearly 444 * superior, providing it is implemented. In other cases it's not 445 * clear what the better path would be, and eventually we'd 446 * probably want to gather timings and choose dynamically. 447 */ 448 if (exa->pipe->surface_copy && 449 exa->copy.src == exa->copy.dst) { 450 451 exa->copy.use_surface_copy = TRUE; 452 453 exa->copy.src_surface = 454 exa->scrn->get_tex_surface( exa->scrn, 455 exa->copy.src->tex, 456 0, 0, 0, 457 PIPE_BIND_BLIT_SOURCE); 458 459 exa->copy.dst_surface = 460 exa->scrn->get_tex_surface( exa->scrn, 461 exa->copy.dst->tex, 462 0, 0, 0, 463 PIPE_BIND_BLIT_DESTINATION ); 464 } 465 else { 466 exa->copy.use_surface_copy = FALSE; 467 468 if (exa->copy.dst == exa->copy.src) 469 exa->copy.src_texture = renderer_clone_texture( exa->renderer, 470 exa->copy.src->tex ); 471 else 472 pipe_resource_reference(&exa->copy.src_texture, 473 exa->copy.src->tex); 474 475 exa->copy.dst_surface = 476 exa->scrn->get_tex_surface(exa->scrn, 477 exa->copy.dst->tex, 478 0, 0, 0, 479 PIPE_BIND_BLIT_DESTINATION); 480 481 482 renderer_copy_prepare(exa->renderer, 483 exa->copy.dst_surface, 484 exa->copy.src_texture ); 485 } 486 487 488 return TRUE; 489} 490 491static void 492ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY, 493 int width, int height) 494{ 495 ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum]; 496 modesettingPtr ms = modesettingPTR(pScrn); 497 struct exa_context *exa = ms->exa; 498 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap); 499 500#if DEBUG_PRINT 501 debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n", 502 srcX, srcY, dstX, dstY, width, height); 503#endif 504 505 debug_assert(priv == exa->copy.dst); 506 (void) priv; 507 508 if (exa->copy.use_surface_copy) { 509 /* XXX: consider exposing >1 box in surface_copy interface. 510 */ 511 exa->pipe->surface_copy( exa->pipe, 512 exa->copy.dst_surface, 513 dstX, dstY, 514 exa->copy.src_surface, 515 srcX, srcY, 516 width, height ); 517 } 518 else { 519 renderer_copy_pixmap(exa->renderer, 520 dstX, dstY, 521 srcX, srcY, 522 width, height, 523 exa->copy.src_texture->width0, 524 exa->copy.src_texture->height0); 525 } 526} 527 528static void 529ExaDoneCopy(PixmapPtr pPixmap) 530{ 531 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; 532 modesettingPtr ms = modesettingPTR(pScrn); 533 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); 534 struct exa_context *exa = ms->exa; 535 536 if (!priv) 537 return; 538 539 renderer_draw_flush(exa->renderer); 540 541 exa->copy.src = NULL; 542 exa->copy.dst = NULL; 543 pipe_surface_reference(&exa->copy.src_surface, NULL); 544 pipe_surface_reference(&exa->copy.dst_surface, NULL); 545 pipe_resource_reference(&exa->copy.src_texture, NULL); 546} 547 548 549 550static Bool 551picture_check_formats(struct exa_pixmap_priv *pSrc, PicturePtr pSrcPicture) 552{ 553 if (pSrc->picture_format == pSrcPicture->format) 554 return TRUE; 555 556 if (pSrc->picture_format != PICT_a8r8g8b8) 557 return FALSE; 558 559 /* pSrc->picture_format == PICT_a8r8g8b8 */ 560 switch (pSrcPicture->format) { 561 case PICT_a8r8g8b8: 562 case PICT_x8r8g8b8: 563 case PICT_a8b8g8r8: 564 case PICT_x8b8g8r8: 565 /* just treat these two as x8... */ 566 case PICT_r8g8b8: 567 case PICT_b8g8r8: 568 return TRUE; 569#ifdef PICT_TYPE_BGRA 570 case PICT_b8g8r8a8: 571 case PICT_b8g8r8x8: 572 return FALSE; /* does not support swizzleing the alpha channel yet */ 573 case PICT_a2r10g10b10: 574 case PICT_x2r10g10b10: 575 case PICT_a2b10g10r10: 576 case PICT_x2b10g10r10: 577 return FALSE; 578#endif 579 default: 580 return FALSE; 581 } 582 return FALSE; 583} 584 585/*********************************************************************** 586 * Composite entrypoints 587 */ 588 589static Bool 590ExaCheckComposite(int op, 591 PicturePtr pSrcPicture, PicturePtr pMaskPicture, 592 PicturePtr pDstPicture) 593{ 594 ScrnInfoPtr pScrn = xf86Screens[pDstPicture->pDrawable->pScreen->myNum]; 595 modesettingPtr ms = modesettingPTR(pScrn); 596 struct exa_context *exa = ms->exa; 597 598#if DEBUG_PRINT 599 debug_printf("ExaCheckComposite(%d, %p, %p, %p) = %d\n", 600 op, pSrcPicture, pMaskPicture, pDstPicture, accelerated); 601#endif 602 603 if (!exa->accel) 604 return FALSE; 605 606 return xorg_composite_accelerated(op, 607 pSrcPicture, 608 pMaskPicture, 609 pDstPicture); 610} 611 612 613static Bool 614ExaPrepareComposite(int op, PicturePtr pSrcPicture, 615 PicturePtr pMaskPicture, PicturePtr pDstPicture, 616 PixmapPtr pSrc, PixmapPtr pMask, PixmapPtr pDst) 617{ 618 ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum]; 619 modesettingPtr ms = modesettingPTR(pScrn); 620 struct exa_context *exa = ms->exa; 621 struct exa_pixmap_priv *priv; 622 623 if (!exa->accel) 624 return FALSE; 625 626#if DEBUG_PRINT 627 debug_printf("ExaPrepareComposite(%d, src=0x%p, mask=0x%p, dst=0x%p)\n", 628 op, pSrcPicture, pMaskPicture, pDstPicture); 629 debug_printf("\tFormats: src(%s), mask(%s), dst(%s)\n", 630 pSrcPicture ? render_format_name(pSrcPicture->format) : "none", 631 pMaskPicture ? render_format_name(pMaskPicture->format) : "none", 632 pDstPicture ? render_format_name(pDstPicture->format) : "none"); 633#endif 634 if (!exa->pipe) 635 XORG_FALLBACK("accle not enabled"); 636 637 priv = exaGetPixmapDriverPrivate(pDst); 638 if (!priv || !priv->tex) 639 XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex"); 640 641 if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, 642 priv->tex->target, 643 PIPE_BIND_RENDER_TARGET, 0)) 644 XORG_FALLBACK("pDst format: %s", util_format_name(priv->tex->format)); 645 646 if (priv->picture_format != pDstPicture->format) 647 XORG_FALLBACK("pDst pic_format: %s != %s", 648 render_format_name(priv->picture_format), 649 render_format_name(pDstPicture->format)); 650 651 if (pSrc) { 652 priv = exaGetPixmapDriverPrivate(pSrc); 653 if (!priv || !priv->tex) 654 XORG_FALLBACK("pSrc %s", !priv ? "!priv" : "!priv->tex"); 655 656 if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, 657 priv->tex->target, 658 PIPE_BIND_SAMPLER_VIEW, 0)) 659 XORG_FALLBACK("pSrc format: %s", util_format_name(priv->tex->format)); 660 661 if (!picture_check_formats(priv, pSrcPicture)) 662 XORG_FALLBACK("pSrc pic_format: %s != %s", 663 render_format_name(priv->picture_format), 664 render_format_name(pSrcPicture->format)); 665 666 } 667 668 if (pMask) { 669 priv = exaGetPixmapDriverPrivate(pMask); 670 if (!priv || !priv->tex) 671 XORG_FALLBACK("pMask %s", !priv ? "!priv" : "!priv->tex"); 672 673 if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, 674 priv->tex->target, 675 PIPE_BIND_SAMPLER_VIEW, 0)) 676 XORG_FALLBACK("pMask format: %s", util_format_name(priv->tex->format)); 677 678 if (!picture_check_formats(priv, pMaskPicture)) 679 XORG_FALLBACK("pMask pic_format: %s != %s", 680 render_format_name(priv->picture_format), 681 render_format_name(pMaskPicture->format)); 682 } 683 684 return xorg_composite_bind_state(exa, op, pSrcPicture, pMaskPicture, 685 pDstPicture, 686 pSrc ? exaGetPixmapDriverPrivate(pSrc) : NULL, 687 pMask ? exaGetPixmapDriverPrivate(pMask) : NULL, 688 exaGetPixmapDriverPrivate(pDst)); 689} 690 691static void 692ExaComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY, 693 int dstX, int dstY, int width, int height) 694{ 695 ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum]; 696 modesettingPtr ms = modesettingPTR(pScrn); 697 struct exa_context *exa = ms->exa; 698 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDst); 699 700#if DEBUG_PRINT 701 debug_printf("\tExaComposite(src[%d,%d], mask=[%d, %d], dst=[%d, %d], dim=[%d, %d])\n", 702 srcX, srcY, maskX, maskY, dstX, dstY, width, height); 703 debug_printf("\t Num bound samplers = %d\n", 704 exa->num_bound_samplers); 705#endif 706 707 xorg_composite(exa, priv, srcX, srcY, maskX, maskY, 708 dstX, dstY, width, height); 709} 710 711 712 713static void 714ExaDoneComposite(PixmapPtr pPixmap) 715{ 716 ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; 717 modesettingPtr ms = modesettingPTR(pScrn); 718 struct exa_context *exa = ms->exa; 719 720 xorg_composite_done(exa); 721} 722 723 724/*********************************************************************** 725 * Pixmaps 726 */ 727 728static void * 729ExaCreatePixmap(ScreenPtr pScreen, int size, int align) 730{ 731 struct exa_pixmap_priv *priv; 732 733 priv = xcalloc(1, sizeof(struct exa_pixmap_priv)); 734 if (!priv) 735 return NULL; 736 737 return priv; 738} 739 740static void 741ExaDestroyPixmap(ScreenPtr pScreen, void *dPriv) 742{ 743 struct exa_pixmap_priv *priv = (struct exa_pixmap_priv *)dPriv; 744 745 if (!priv) 746 return; 747 748 pipe_resource_reference(&priv->tex, NULL); 749 750 xfree(priv); 751} 752 753static Bool 754ExaPixmapIsOffscreen(PixmapPtr pPixmap) 755{ 756 struct exa_pixmap_priv *priv; 757 758 priv = exaGetPixmapDriverPrivate(pPixmap); 759 760 if (!priv) 761 return FALSE; 762 763 if (priv->tex) 764 return TRUE; 765 766 return FALSE; 767} 768 769int 770xorg_exa_set_displayed_usage(PixmapPtr pPixmap) 771{ 772 struct exa_pixmap_priv *priv; 773 priv = exaGetPixmapDriverPrivate(pPixmap); 774 775 if (!priv) { 776 FatalError("NO PIXMAP PRIVATE\n"); 777 return 0; 778 } 779 780 priv->flags |= PIPE_BIND_SCANOUT; 781 782 return 0; 783} 784 785int 786xorg_exa_set_shared_usage(PixmapPtr pPixmap) 787{ 788 struct exa_pixmap_priv *priv; 789 priv = exaGetPixmapDriverPrivate(pPixmap); 790 791 if (!priv) { 792 FatalError("NO PIXMAP PRIVATE\n"); 793 return 0; 794 } 795 796 priv->flags |= PIPE_BIND_SHARED; 797 798 return 0; 799} 800 801 802 803static Bool 804size_match( int width, int tex_width ) 805{ 806#if ROUND_UP_TEXTURES 807 if (width > tex_width) 808 return FALSE; 809 810 if (width * 2 < tex_width) 811 return FALSE; 812 813 return TRUE; 814#else 815 return width == tex_width; 816#endif 817} 818 819static Bool 820ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height, 821 int depth, int bitsPerPixel, int devKind, 822 pointer pPixData) 823{ 824 ScreenPtr pScreen = pPixmap->drawable.pScreen; 825 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 826 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); 827 modesettingPtr ms = modesettingPTR(pScrn); 828 struct exa_context *exa = ms->exa; 829 830 if (!priv || pPixData) 831 return FALSE; 832 833 if (0) { 834 debug_printf("%s pixmap %p sz %dx%dx%d devKind %d\n", 835 __FUNCTION__, pPixmap, width, height, bitsPerPixel, devKind); 836 837 if (priv->tex) 838 debug_printf(" ==> old texture %dx%d\n", 839 priv->tex->width0, 840 priv->tex->height0); 841 } 842 843 844 if (depth <= 0) 845 depth = pPixmap->drawable.depth; 846 847 if (bitsPerPixel <= 0) 848 bitsPerPixel = pPixmap->drawable.bitsPerPixel; 849 850 if (width <= 0) 851 width = pPixmap->drawable.width; 852 853 if (height <= 0) 854 height = pPixmap->drawable.height; 855 856 if (width <= 0 || height <= 0 || depth <= 0) 857 return FALSE; 858 859 miModifyPixmapHeader(pPixmap, width, height, depth, 860 bitsPerPixel, devKind, NULL); 861 862 priv->width = width; 863 priv->height = height; 864 865 /* Deal with screen resize */ 866 if ((exa->accel || priv->flags) && 867 (!priv->tex || 868 !size_match(width, priv->tex->width0) || 869 !size_match(height, priv->tex->height0) || 870 priv->tex_flags != priv->flags)) { 871 struct pipe_resource *texture = NULL; 872 struct pipe_resource template; 873 874 memset(&template, 0, sizeof(template)); 875 template.target = PIPE_TEXTURE_2D; 876 exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &priv->picture_format); 877 if (ROUND_UP_TEXTURES && priv->flags == 0) { 878 template.width0 = util_next_power_of_two(width); 879 template.height0 = util_next_power_of_two(height); 880 } 881 else { 882 template.width0 = width; 883 template.height0 = height; 884 } 885 886 template.depth0 = 1; 887 template.last_level = 0; 888 template.bind = PIPE_BIND_RENDER_TARGET | priv->flags; 889 priv->tex_flags = priv->flags; 890 texture = exa->scrn->resource_create(exa->scrn, &template); 891 892 if (priv->tex) { 893 struct pipe_surface *dst_surf; 894 struct pipe_surface *src_surf; 895 896 dst_surf = exa->scrn->get_tex_surface( 897 exa->scrn, texture, 0, 0, 0, PIPE_BIND_BLIT_DESTINATION); 898 src_surf = xorg_gpu_surface(exa->pipe->screen, priv); 899 if (exa->pipe->surface_copy) { 900 exa->pipe->surface_copy(exa->pipe, dst_surf, 0, 0, src_surf, 901 0, 0, min(width, texture->width0), 902 min(height, texture->height0)); 903 } else { 904 util_surface_copy(exa->pipe, FALSE, dst_surf, 0, 0, src_surf, 905 0, 0, min(width, texture->width0), 906 min(height, texture->height0)); 907 } 908 exa->scrn->tex_surface_destroy(dst_surf); 909 exa->scrn->tex_surface_destroy(src_surf); 910 } 911 912 pipe_resource_reference(&priv->tex, texture); 913 /* the texture we create has one reference */ 914 pipe_resource_reference(&texture, NULL); 915 } 916 917 return TRUE; 918} 919 920struct pipe_resource * 921xorg_exa_get_texture(PixmapPtr pPixmap) 922{ 923 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); 924 struct pipe_resource *tex = NULL; 925 pipe_resource_reference(&tex, priv->tex); 926 return tex; 927} 928 929Bool 930xorg_exa_set_texture(PixmapPtr pPixmap, struct pipe_resource *tex) 931{ 932 struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); 933 934 int mask = PIPE_BIND_SHARED | PIPE_BIND_SCANOUT; 935 936 if (!priv) 937 return FALSE; 938 939 if (pPixmap->drawable.width != tex->width0 || 940 pPixmap->drawable.height != tex->height0) 941 return FALSE; 942 943 pipe_resource_reference(&priv->tex, tex); 944 priv->tex_flags = tex->bind & mask; 945 946 return TRUE; 947} 948 949struct pipe_resource * 950xorg_exa_create_root_texture(ScrnInfoPtr pScrn, 951 int width, int height, 952 int depth, int bitsPerPixel) 953{ 954 modesettingPtr ms = modesettingPTR(pScrn); 955 struct exa_context *exa = ms->exa; 956 struct pipe_resource template; 957 int dummy; 958 959 memset(&template, 0, sizeof(template)); 960 template.target = PIPE_TEXTURE_2D; 961 exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &dummy); 962 template.width0 = width; 963 template.height0 = height; 964 template.depth0 = 1; 965 template.last_level = 0; 966 template.bind |= PIPE_BIND_RENDER_TARGET; 967 template.bind |= PIPE_BIND_SCANOUT; 968 template.bind |= PIPE_BIND_SHARED; 969 970 return exa->scrn->resource_create(exa->scrn, &template); 971} 972 973void 974xorg_exa_close(ScrnInfoPtr pScrn) 975{ 976 modesettingPtr ms = modesettingPTR(pScrn); 977 struct exa_context *exa = ms->exa; 978 979 pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL); 980 pipe_sampler_view_reference(&exa->bound_sampler_views[1], NULL); 981 982 renderer_destroy(exa->renderer); 983 984 if (exa->pipe) 985 exa->pipe->destroy(exa->pipe); 986 exa->pipe = NULL; 987 /* Since this was shared be proper with the pointer */ 988 ms->ctx = NULL; 989 990 exaDriverFini(pScrn->pScreen); 991 xfree(exa); 992 ms->exa = NULL; 993} 994 995void * 996xorg_exa_init(ScrnInfoPtr pScrn, Bool accel) 997{ 998 modesettingPtr ms = modesettingPTR(pScrn); 999 struct exa_context *exa; 1000 ExaDriverPtr pExa; 1001 1002 exa = xcalloc(1, sizeof(struct exa_context)); 1003 if (!exa) 1004 return NULL; 1005 1006 pExa = exaDriverAlloc(); 1007 if (!pExa) { 1008 goto out_err; 1009 } 1010 1011 memset(pExa, 0, sizeof(*pExa)); 1012 1013 pExa->exa_major = 2; 1014 pExa->exa_minor = 2; 1015 pExa->memoryBase = 0; 1016 pExa->memorySize = 0; 1017 pExa->offScreenBase = 0; 1018 pExa->pixmapOffsetAlign = 0; 1019 pExa->pixmapPitchAlign = 1; 1020 pExa->flags = EXA_OFFSCREEN_PIXMAPS | EXA_HANDLES_PIXMAPS; 1021#ifdef EXA_SUPPORTS_PREPARE_AUX 1022 pExa->flags |= EXA_SUPPORTS_PREPARE_AUX; 1023#endif 1024#ifdef EXA_MIXED_PIXMAPS 1025 pExa->flags |= EXA_MIXED_PIXMAPS; 1026#endif 1027 pExa->maxX = 8191; /* FIXME */ 1028 pExa->maxY = 8191; /* FIXME */ 1029 1030 pExa->WaitMarker = ExaWaitMarker; 1031 pExa->MarkSync = ExaMarkSync; 1032 pExa->PrepareSolid = ExaPrepareSolid; 1033 pExa->Solid = ExaSolid; 1034 pExa->DoneSolid = ExaDoneSolid; 1035 pExa->PrepareCopy = ExaPrepareCopy; 1036 pExa->Copy = ExaCopy; 1037 pExa->DoneCopy = ExaDoneCopy; 1038 pExa->CheckComposite = ExaCheckComposite; 1039 pExa->PrepareComposite = ExaPrepareComposite; 1040 pExa->Composite = ExaComposite; 1041 pExa->DoneComposite = ExaDoneComposite; 1042 pExa->PixmapIsOffscreen = ExaPixmapIsOffscreen; 1043 pExa->DownloadFromScreen = ExaDownloadFromScreen; 1044 pExa->UploadToScreen = ExaUploadToScreen; 1045 pExa->PrepareAccess = ExaPrepareAccess; 1046 pExa->FinishAccess = ExaFinishAccess; 1047 pExa->CreatePixmap = ExaCreatePixmap; 1048 pExa->DestroyPixmap = ExaDestroyPixmap; 1049 pExa->ModifyPixmapHeader = ExaModifyPixmapHeader; 1050 1051 if (!exaDriverInit(pScrn->pScreen, pExa)) { 1052 goto out_err; 1053 } 1054 1055 exa->scrn = ms->screen; 1056 exa->pipe = exa->scrn->context_create(exa->scrn, NULL); 1057 if (exa->pipe == NULL) 1058 goto out_err; 1059 1060 /* Share context with DRI */ 1061 ms->ctx = exa->pipe; 1062 1063 exa->renderer = renderer_create(exa->pipe); 1064 exa->accel = accel; 1065 1066 return (void *)exa; 1067 1068out_err: 1069 xorg_exa_close(pScrn); 1070 1071 return NULL; 1072} 1073 1074struct pipe_surface * 1075xorg_gpu_surface(struct pipe_screen *scrn, struct exa_pixmap_priv *priv) 1076{ 1077 1078 /* seems to get called both for blits and render target usage */ 1079 return scrn->get_tex_surface(scrn, priv->tex, 0, 0, 0, 1080 PIPE_BIND_BLIT_SOURCE | 1081 PIPE_BIND_BLIT_DESTINATION | 1082 PIPE_BIND_RENDER_TARGET); 1083 1084} 1085 1086void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags, 1087 struct pipe_fence_handle **fence) 1088{ 1089 exa->pipe->flush(exa->pipe, pipeFlushFlags, fence); 1090} 1091 1092void xorg_exa_finish(struct exa_context *exa) 1093{ 1094 struct pipe_fence_handle *fence = NULL; 1095 1096 xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, &fence); 1097 1098 exa->pipe->screen->fence_finish(exa->pipe->screen, fence, 0); 1099 exa->pipe->screen->fence_reference(exa->pipe->screen, &fence, NULL); 1100} 1101 1102