exa_priv.h (20500B)
1 /* 2 * 3 * Copyright (C) 2000 Keith Packard, member of The XFree86 Project, Inc. 4 * 2005 Zack Rusin, Trolltech 5 * 6 * Permission to use, copy, modify, distribute, and sell this software and its 7 * documentation for any purpose is hereby granted without fee, provided that 8 * the above copyright notice appear in all copies and that both that 9 * copyright notice and this permission notice appear in supporting 10 * documentation, and that the name of Keith Packard not be used in 11 * advertising or publicity pertaining to distribution of the software without 12 * specific, written prior permission. Keith Packard makes no 13 * representations about the suitability of this software for any purpose. It 14 * is provided "as is" without express or implied warranty. 15 * 16 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS 17 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 18 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 19 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 20 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 21 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 22 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 23 * SOFTWARE. 24 */ 25 26 #ifndef EXAPRIV_H 27 #define EXAPRIV_H 28 29 #ifdef HAVE_DIX_CONFIG_H 30 #include <dix-config.h> 31 #endif 32 33 #include "exa.h" 34 35 #include <X11/X.h> 36 #include <X11/Xproto.h> 37 #ifdef MITSHM 38 #include "shmint.h" 39 #endif 40 #include "scrnintstr.h" 41 #include "pixmapstr.h" 42 #include "windowstr.h" 43 #include "servermd.h" 44 #include "colormapst.h" 45 #include "gcstruct.h" 46 #include "input.h" 47 #include "mipointer.h" 48 #include "mi.h" 49 #include "dix.h" 50 #include "fb.h" 51 #include "fboverlay.h" 52 #include "fbpict.h" 53 #include "glyphstr.h" 54 #include "damage.h" 55 56 #define DEBUG_TRACE_FALL 0 57 #define DEBUG_MIGRATE 0 58 #define DEBUG_PIXMAP 0 59 #define DEBUG_OFFSCREEN 0 60 #define DEBUG_GLYPH_CACHE 0 61 62 #if DEBUG_TRACE_FALL 63 #define EXA_FALLBACK(x) \ 64 do { \ 65 ErrorF("EXA fallback at %s: ", __FUNCTION__); \ 66 ErrorF x; \ 67 } while (0) 68 69 char 70 exaDrawableLocation(DrawablePtr pDrawable); 71 #else 72 #define EXA_FALLBACK(x) 73 #endif 74 75 #if DEBUG_PIXMAP 76 #define DBG_PIXMAP(a) ErrorF a 77 #else 78 #define DBG_PIXMAP(a) 79 #endif 80 81 #ifndef EXA_MAX_FB 82 #define EXA_MAX_FB FB_OVERLAY_MAX 83 #endif 84 85 #ifdef DEBUG 86 #define EXA_FatalErrorDebug(x) FatalError x 87 #define EXA_FatalErrorDebugWithRet(x, ret) FatalError x 88 #else 89 #define EXA_FatalErrorDebug(x) ErrorF x 90 #define EXA_FatalErrorDebugWithRet(x, ret) \ 91 do { \ 92 ErrorF x; \ 93 return ret; \ 94 } while (0) 95 #endif 96 97 /** 98 * This is the list of migration heuristics supported by EXA. See 99 * exaDoMigration() for what their implementations do. 100 */ 101 enum ExaMigrationHeuristic { 102 ExaMigrationGreedy, 103 ExaMigrationAlways, 104 ExaMigrationSmart 105 }; 106 107 typedef struct { 108 unsigned char sha1[20]; 109 } ExaCachedGlyphRec, *ExaCachedGlyphPtr; 110 111 typedef struct { 112 /* The identity of the cache, statically configured at initialization */ 113 unsigned int format; 114 int glyphWidth; 115 int glyphHeight; 116 117 int size; /* Size of cache; eventually this should be dynamically determined */ 118 119 /* Hash table mapping from glyph sha1 to position in the glyph; we use 120 * open addressing with a hash table size determined based on size and large 121 * enough so that we always have a good amount of free space, so we can 122 * use linear probing. (Linear probing is preferable to double hashing 123 * here because it allows us to easily remove entries.) 124 */ 125 int *hashEntries; 126 int hashSize; 127 128 ExaCachedGlyphPtr glyphs; 129 int glyphCount; /* Current number of glyphs */ 130 131 PicturePtr picture; /* Where the glyphs of the cache are stored */ 132 int yOffset; /* y location within the picture where the cache starts */ 133 int columns; /* Number of columns the glyphs are laid out in */ 134 int evictionPosition; /* Next random position to evict a glyph */ 135 } ExaGlyphCacheRec, *ExaGlyphCachePtr; 136 137 #define EXA_NUM_GLYPH_CACHES 4 138 139 #define EXA_FALLBACK_COPYWINDOW (1 << 0) 140 #define EXA_ACCEL_COPYWINDOW (1 << 1) 141 142 typedef struct _ExaMigrationRec { 143 Bool as_dst; 144 Bool as_src; 145 PixmapPtr pPix; 146 RegionPtr pReg; 147 } ExaMigrationRec, *ExaMigrationPtr; 148 149 typedef void (*EnableDisableFBAccessProcPtr) (ScreenPtr, Bool); 150 typedef struct { 151 ExaDriverPtr info; 152 ScreenBlockHandlerProcPtr SavedBlockHandler; 153 ScreenWakeupHandlerProcPtr SavedWakeupHandler; 154 CreateGCProcPtr SavedCreateGC; 155 CloseScreenProcPtr SavedCloseScreen; 156 GetImageProcPtr SavedGetImage; 157 GetSpansProcPtr SavedGetSpans; 158 CreatePixmapProcPtr SavedCreatePixmap; 159 DestroyPixmapProcPtr SavedDestroyPixmap; 160 CopyWindowProcPtr SavedCopyWindow; 161 ChangeWindowAttributesProcPtr SavedChangeWindowAttributes; 162 BitmapToRegionProcPtr SavedBitmapToRegion; 163 CreateScreenResourcesProcPtr SavedCreateScreenResources; 164 ModifyPixmapHeaderProcPtr SavedModifyPixmapHeader; 165 SharePixmapBackingProcPtr SavedSharePixmapBacking; 166 SetSharedPixmapBackingProcPtr SavedSetSharedPixmapBacking; 167 SourceValidateProcPtr SavedSourceValidate; 168 CompositeProcPtr SavedComposite; 169 TrianglesProcPtr SavedTriangles; 170 GlyphsProcPtr SavedGlyphs; 171 TrapezoidsProcPtr SavedTrapezoids; 172 AddTrapsProcPtr SavedAddTraps; 173 void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, 174 Bool can_accel); 175 Bool (*pixmap_has_gpu_copy) (PixmapPtr pPixmap); 176 void (*do_move_in_pixmap) (PixmapPtr pPixmap); 177 void (*do_move_out_pixmap) (PixmapPtr pPixmap); 178 void (*prepare_access_reg) (PixmapPtr pPixmap, int index, RegionPtr pReg); 179 180 Bool swappedOut; 181 enum ExaMigrationHeuristic migration; 182 Bool checkDirtyCorrectness; 183 unsigned disableFbCount; 184 Bool optimize_migration; 185 unsigned offScreenCounter; 186 unsigned numOffscreenAvailable; 187 CARD32 lastDefragment; 188 CARD32 nextDefragment; 189 PixmapPtr deferred_mixed_pixmap; 190 191 /* Reference counting for accessed pixmaps */ 192 struct { 193 PixmapPtr pixmap; 194 int count; 195 Bool retval; 196 } access[EXA_NUM_PREPARE_INDICES]; 197 198 /* Holds information on fallbacks that cannot be relayed otherwise. */ 199 unsigned int fallback_flags; 200 unsigned int fallback_counter; 201 202 ExaGlyphCacheRec glyphCaches[EXA_NUM_GLYPH_CACHES]; 203 204 /** 205 * Regions affected by fallback composite source / mask operations. 206 */ 207 208 RegionRec srcReg; 209 RegionRec maskReg; 210 PixmapPtr srcPix; 211 PixmapPtr maskPix; 212 213 DevPrivateKeyRec pixmapPrivateKeyRec; 214 DevPrivateKeyRec gcPrivateKeyRec; 215 } ExaScreenPrivRec, *ExaScreenPrivPtr; 216 217 extern DevPrivateKeyRec exaScreenPrivateKeyRec; 218 219 #define exaScreenPrivateKey (&exaScreenPrivateKeyRec) 220 221 #define ExaGetScreenPriv(s) ((ExaScreenPrivPtr)dixGetPrivate(&(s)->devPrivates, exaScreenPrivateKey)) 222 #define ExaScreenPriv(s) ExaScreenPrivPtr pExaScr = ExaGetScreenPriv(s) 223 224 #define ExaGetGCPriv(gc) ((ExaGCPrivPtr)dixGetPrivateAddr(&(gc)->devPrivates, &ExaGetScreenPriv(gc->pScreen)->gcPrivateKeyRec)) 225 #define ExaGCPriv(gc) ExaGCPrivPtr pExaGC = ExaGetGCPriv(gc) 226 227 /* 228 * Some macros to deal with function wrapping. 229 */ 230 #define wrap(priv, real, mem, func) {\ 231 priv->Saved##mem = real->mem; \ 232 real->mem = func; \ 233 } 234 235 #define unwrap(priv, real, mem) {\ 236 real->mem = priv->Saved##mem; \ 237 } 238 239 #ifdef HAVE_TYPEOF 240 #define swap(priv, real, mem) {\ 241 typeof(real->mem) tmp = priv->Saved##mem; \ 242 priv->Saved##mem = real->mem; \ 243 real->mem = tmp; \ 244 } 245 #else 246 #define swap(priv, real, mem) {\ 247 const void *tmp = priv->Saved##mem; \ 248 priv->Saved##mem = real->mem; \ 249 real->mem = tmp; \ 250 } 251 #endif 252 253 #define EXA_PRE_FALLBACK(_screen_) \ 254 ExaScreenPriv(_screen_); \ 255 pExaScr->fallback_counter++; 256 257 #define EXA_POST_FALLBACK(_screen_) \ 258 pExaScr->fallback_counter--; 259 260 #define EXA_PRE_FALLBACK_GC(_gc_) \ 261 ExaScreenPriv(_gc_->pScreen); \ 262 ExaGCPriv(_gc_); \ 263 pExaScr->fallback_counter++; \ 264 swap(pExaGC, _gc_, ops); 265 266 #define EXA_POST_FALLBACK_GC(_gc_) \ 267 pExaScr->fallback_counter--; \ 268 swap(pExaGC, _gc_, ops); 269 270 /** Align an offset to an arbitrary alignment */ 271 #define EXA_ALIGN(offset, align) (((offset) + (align) - 1) - \ 272 (((offset) + (align) - 1) % (align))) 273 /** Align an offset to a power-of-two alignment */ 274 #define EXA_ALIGN2(offset, align) (((offset) + (align) - 1) & ~((align) - 1)) 275 276 #define EXA_PIXMAP_SCORE_MOVE_IN 10 277 #define EXA_PIXMAP_SCORE_MAX 20 278 #define EXA_PIXMAP_SCORE_MOVE_OUT -10 279 #define EXA_PIXMAP_SCORE_MIN -20 280 #define EXA_PIXMAP_SCORE_PINNED 1000 281 #define EXA_PIXMAP_SCORE_INIT 1001 282 283 #define ExaGetPixmapPriv(p) ((ExaPixmapPrivPtr)dixGetPrivateAddr(&(p)->devPrivates, &ExaGetScreenPriv((p)->drawable.pScreen)->pixmapPrivateKeyRec)) 284 #define ExaPixmapPriv(p) ExaPixmapPrivPtr pExaPixmap = ExaGetPixmapPriv(p) 285 286 #define EXA_RANGE_PITCH (1 << 0) 287 #define EXA_RANGE_WIDTH (1 << 1) 288 #define EXA_RANGE_HEIGHT (1 << 2) 289 290 typedef struct { 291 ExaOffscreenArea *area; 292 int score; /**< score for the move-in vs move-out heuristic */ 293 Bool use_gpu_copy; 294 295 CARD8 *sys_ptr; /**< pointer to pixmap data in system memory */ 296 int sys_pitch; /**< pitch of pixmap in system memory */ 297 298 CARD8 *fb_ptr; /**< pointer to pixmap data in framebuffer memory */ 299 int fb_pitch; /**< pitch of pixmap in framebuffer memory */ 300 unsigned int fb_size; /**< size of pixmap in framebuffer memory */ 301 302 /** 303 * Holds information about whether this pixmap can be used for 304 * acceleration (== 0) or not (> 0). 305 * 306 * Contains a OR'ed combination of the following values: 307 * EXA_RANGE_PITCH - set if the pixmap's pitch is out of range 308 * EXA_RANGE_WIDTH - set if the pixmap's width is out of range 309 * EXA_RANGE_HEIGHT - set if the pixmap's height is out of range 310 */ 311 unsigned int accel_blocked; 312 313 /** 314 * The damage record contains the areas of the pixmap's current location 315 * (framebuffer or system) that have been damaged compared to the other 316 * location. 317 */ 318 DamagePtr pDamage; 319 /** 320 * The valid regions mark the valid bits (at least, as they're derived from 321 * damage, which may be overreported) of a pixmap's system and FB copies. 322 */ 323 RegionRec validSys, validFB; 324 /** 325 * Driver private storage per EXA pixmap 326 */ 327 void *driverPriv; 328 } ExaPixmapPrivRec, *ExaPixmapPrivPtr; 329 330 typedef struct { 331 /* GC values from the layer below. */ 332 const GCOps *Savedops; 333 const GCFuncs *Savedfuncs; 334 } ExaGCPrivRec, *ExaGCPrivPtr; 335 336 typedef struct { 337 PicturePtr pDst; 338 INT16 xSrc; 339 INT16 ySrc; 340 INT16 xMask; 341 INT16 yMask; 342 INT16 xDst; 343 INT16 yDst; 344 INT16 width; 345 INT16 height; 346 } ExaCompositeRectRec, *ExaCompositeRectPtr; 347 348 /** 349 * exaDDXDriverInit must be implemented by the DDX using EXA, and is the place 350 * to set EXA options or hook in screen functions to handle using EXA as the AA. 351 */ 352 void exaDDXDriverInit(ScreenPtr pScreen); 353 354 /* exa_unaccel.c */ 355 void 356 exaPrepareAccessGC(GCPtr pGC); 357 358 void 359 exaFinishAccessGC(GCPtr pGC); 360 361 void 362 363 ExaCheckFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nspans, 364 DDXPointPtr ppt, int *pwidth, int fSorted); 365 366 void 367 368 ExaCheckSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *psrc, 369 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted); 370 371 void 372 373 ExaCheckPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, 374 int x, int y, int w, int h, int leftPad, int format, 375 char *bits); 376 377 void 378 379 ExaCheckCopyNtoN(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, 380 BoxPtr pbox, int nbox, int dx, int dy, Bool reverse, 381 Bool upsidedown, Pixel bitplane, void *closure); 382 383 RegionPtr 384 385 ExaCheckCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, 386 int srcx, int srcy, int w, int h, int dstx, int dsty); 387 388 RegionPtr 389 390 ExaCheckCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, 391 int srcx, int srcy, int w, int h, int dstx, int dsty, 392 unsigned long bitPlane); 393 394 void 395 396 ExaCheckPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, 397 DDXPointPtr pptInit); 398 399 void 400 401 ExaCheckPolylines(DrawablePtr pDrawable, GCPtr pGC, 402 int mode, int npt, DDXPointPtr ppt); 403 404 void 405 406 ExaCheckPolySegment(DrawablePtr pDrawable, GCPtr pGC, 407 int nsegInit, xSegment * pSegInit); 408 409 void 410 ExaCheckPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * pArcs); 411 412 void 413 414 ExaCheckPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, 415 int nrect, xRectangle *prect); 416 417 void 418 419 ExaCheckImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, 420 int x, int y, unsigned int nglyph, 421 CharInfoPtr * ppci, void *pglyphBase); 422 423 void 424 425 ExaCheckPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, 426 int x, int y, unsigned int nglyph, 427 CharInfoPtr * ppci, void *pglyphBase); 428 429 void 430 431 ExaCheckPushPixels(GCPtr pGC, PixmapPtr pBitmap, 432 DrawablePtr pDrawable, int w, int h, int x, int y); 433 434 void 435 ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); 436 437 void 438 439 ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h, 440 unsigned int format, unsigned long planeMask, char *d); 441 442 void 443 444 ExaCheckGetSpans(DrawablePtr pDrawable, 445 int wMax, 446 DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart); 447 448 void 449 450 ExaCheckAddTraps(PicturePtr pPicture, 451 INT16 x_off, INT16 y_off, int ntrap, xTrap * traps); 452 453 /* exa_accel.c */ 454 455 static _X_INLINE Bool 456 exaGCReadsDestination(DrawablePtr pDrawable, unsigned long planemask, 457 unsigned int fillStyle, unsigned char alu, 458 Bool clientClip) 459 { 460 return ((alu != GXcopy && alu != GXclear && alu != GXset && 461 alu != GXcopyInverted) || fillStyle == FillStippled || 462 clientClip != FALSE || !EXA_PM_IS_SOLID(pDrawable, planemask)); 463 } 464 465 void 466 exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); 467 468 Bool 469 470 exaFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile, 471 DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu, 472 Bool clientClip); 473 474 void 475 476 exaGetImage(DrawablePtr pDrawable, int x, int y, int w, int h, 477 unsigned int format, unsigned long planeMask, char *d); 478 479 RegionPtr 480 481 exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, 482 int srcx, int srcy, int width, int height, int dstx, int dsty); 483 484 Bool 485 486 exaHWCopyNtoN(DrawablePtr pSrcDrawable, 487 DrawablePtr pDstDrawable, 488 GCPtr pGC, 489 BoxPtr pbox, 490 int nbox, int dx, int dy, Bool reverse, Bool upsidedown); 491 492 void 493 494 exaCopyNtoN(DrawablePtr pSrcDrawable, 495 DrawablePtr pDstDrawable, 496 GCPtr pGC, 497 BoxPtr pbox, 498 int nbox, 499 int dx, 500 int dy, 501 Bool reverse, Bool upsidedown, Pixel bitplane, void *closure); 502 503 extern const GCOps exaOps; 504 505 void 506 507 ExaCheckComposite(CARD8 op, 508 PicturePtr pSrc, 509 PicturePtr pMask, 510 PicturePtr pDst, 511 INT16 xSrc, 512 INT16 ySrc, 513 INT16 xMask, 514 INT16 yMask, 515 INT16 xDst, INT16 yDst, CARD16 width, CARD16 height); 516 517 void 518 519 ExaCheckGlyphs(CARD8 op, 520 PicturePtr pSrc, 521 PicturePtr pDst, 522 PictFormatPtr maskFormat, 523 INT16 xSrc, 524 INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs); 525 526 /* exa_offscreen.c */ 527 void 528 ExaOffscreenSwapOut(ScreenPtr pScreen); 529 530 void 531 ExaOffscreenSwapIn(ScreenPtr pScreen); 532 533 ExaOffscreenArea *ExaOffscreenDefragment(ScreenPtr pScreen); 534 535 Bool 536 exaOffscreenInit(ScreenPtr pScreen); 537 538 void 539 ExaOffscreenFini(ScreenPtr pScreen); 540 541 /* exa.c */ 542 Bool 543 ExaDoPrepareAccess(PixmapPtr pPixmap, int index); 544 545 void 546 exaPrepareAccess(DrawablePtr pDrawable, int index); 547 548 void 549 exaFinishAccess(DrawablePtr pDrawable, int index); 550 551 void 552 exaDestroyPixmap(PixmapPtr pPixmap); 553 554 void 555 exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2); 556 557 void 558 559 exaGetDrawableDeltas(DrawablePtr pDrawable, PixmapPtr pPixmap, 560 int *xp, int *yp); 561 562 Bool 563 exaPixmapHasGpuCopy(PixmapPtr p); 564 565 PixmapPtr 566 exaGetOffscreenPixmap(DrawablePtr pDrawable, int *xp, int *yp); 567 568 PixmapPtr 569 exaGetDrawablePixmap(DrawablePtr pDrawable); 570 571 void 572 573 exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap, 574 int w, int h, int bpp); 575 576 void 577 578 exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap, 579 int w, int h, int bpp); 580 581 void 582 exaDoMigration(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel); 583 584 Bool 585 exaPixmapIsPinned(PixmapPtr pPix); 586 587 extern const GCFuncs exaGCFuncs; 588 589 /* exa_classic.c */ 590 PixmapPtr 591 592 exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth, 593 unsigned usage_hint); 594 595 Bool 596 597 exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, 598 int depth, int bitsPerPixel, int devKind, 599 void *pPixData); 600 601 Bool 602 exaDestroyPixmap_classic(PixmapPtr pPixmap); 603 604 Bool 605 exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap); 606 607 /* exa_driver.c */ 608 PixmapPtr 609 610 exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth, 611 unsigned usage_hint); 612 613 Bool 614 615 exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height, 616 int depth, int bitsPerPixel, int devKind, 617 void *pPixData); 618 619 Bool 620 exaDestroyPixmap_driver(PixmapPtr pPixmap); 621 622 Bool 623 exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap); 624 625 /* exa_mixed.c */ 626 PixmapPtr 627 628 exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth, 629 unsigned usage_hint); 630 631 Bool 632 633 exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth, 634 int bitsPerPixel, int devKind, void *pPixData); 635 636 Bool 637 exaDestroyPixmap_mixed(PixmapPtr pPixmap); 638 639 Bool 640 exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap); 641 642 /* exa_migration_mixed.c */ 643 void 644 exaCreateDriverPixmap_mixed(PixmapPtr pPixmap); 645 646 void 647 exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel); 648 649 void 650 exaMoveInPixmap_mixed(PixmapPtr pPixmap); 651 652 void 653 exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure); 654 655 void 656 exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg); 657 658 Bool 659 exaSetSharedPixmapBacking_mixed(PixmapPtr pPixmap, void *handle); 660 Bool 661 exaSharePixmapBacking_mixed(PixmapPtr pPixmap, ScreenPtr secondary, void **handle_p); 662 663 /* exa_render.c */ 664 Bool 665 exaOpReadsDestination(CARD8 op); 666 667 void 668 669 exaComposite(CARD8 op, 670 PicturePtr pSrc, 671 PicturePtr pMask, 672 PicturePtr pDst, 673 INT16 xSrc, 674 INT16 ySrc, 675 INT16 xMask, 676 INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height); 677 678 void 679 680 exaCompositeRects(CARD8 op, 681 PicturePtr Src, 682 PicturePtr pMask, 683 PicturePtr pDst, int nrect, ExaCompositeRectPtr rects); 684 685 void 686 687 exaTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst, 688 PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, 689 int ntrap, xTrapezoid * traps); 690 691 void 692 693 exaTriangles(CARD8 op, PicturePtr pSrc, PicturePtr pDst, 694 PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, 695 int ntri, xTriangle * tris); 696 697 /* exa_glyph.c */ 698 void 699 exaGlyphsInit(ScreenPtr pScreen); 700 701 void 702 exaGlyphsFini(ScreenPtr pScreen); 703 704 void 705 706 exaGlyphs(CARD8 op, 707 PicturePtr pSrc, 708 PicturePtr pDst, 709 PictFormatPtr maskFormat, 710 INT16 xSrc, 711 INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs); 712 713 /* exa_migration_classic.c */ 714 void 715 exaCopyDirtyToSys(ExaMigrationPtr migrate); 716 717 void 718 exaCopyDirtyToFb(ExaMigrationPtr migrate); 719 720 void 721 exaDoMigration_classic(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel); 722 723 void 724 exaPixmapSave(ScreenPtr pScreen, ExaOffscreenArea * area); 725 726 void 727 exaMoveOutPixmap_classic(PixmapPtr pPixmap); 728 729 void 730 exaMoveInPixmap_classic(PixmapPtr pPixmap); 731 732 void 733 exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg); 734 735 #endif /* EXAPRIV_H */