VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/x11include/xorg-server-1.17.1/exa_priv.h@ 77662

最後變更 在這個檔案從77662是 54163,由 vboxsync 提交於 10 年 前

Additions/x11/vboxvideo: support X.Org Server 1.17 (still untested).
  • 屬性 svn:eol-style 設為 native
檔案大小: 20.0 KB
行 
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) \
64do { \
65 ErrorF("EXA fallback at %s: ", __FUNCTION__); \
66 ErrorF x; \
67} while (0)
68
69char
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) \
91do { \
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 */
101enum ExaMigrationHeuristic {
102 ExaMigrationGreedy,
103 ExaMigrationAlways,
104 ExaMigrationSmart
105};
106
107typedef struct {
108 unsigned char sha1[20];
109} ExaCachedGlyphRec, *ExaCachedGlyphPtr;
110
111typedef 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 preferrable 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 layed 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
142typedef struct _ExaMigrationRec {
143 Bool as_dst;
144 Bool as_src;
145 PixmapPtr pPix;
146 RegionPtr pReg;
147} ExaMigrationRec, *ExaMigrationPtr;
148
149typedef void (*EnableDisableFBAccessProcPtr) (ScreenPtr, Bool);
150typedef 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
217extern 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 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
290typedef 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
330typedef struct {
331 /* GC values from the layer below. */
332 const GCOps *Savedops;
333 const GCFuncs *Savedfuncs;
334} ExaGCPrivRec, *ExaGCPrivPtr;
335
336typedef 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 */
352void exaDDXDriverInit(ScreenPtr pScreen);
353
354/* exa_unaccel.c */
355void
356 exaPrepareAccessGC(GCPtr pGC);
357
358void
359 exaFinishAccessGC(GCPtr pGC);
360
361void
362
363ExaCheckFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nspans,
364 DDXPointPtr ppt, int *pwidth, int fSorted);
365
366void
367
368ExaCheckSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *psrc,
369 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
370
371void
372
373ExaCheckPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
374 int x, int y, int w, int h, int leftPad, int format,
375 char *bits);
376
377void
378
379ExaCheckCopyNtoN(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
383RegionPtr
384
385ExaCheckCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
386 int srcx, int srcy, int w, int h, int dstx, int dsty);
387
388RegionPtr
389
390ExaCheckCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
391 int srcx, int srcy, int w, int h, int dstx, int dsty,
392 unsigned long bitPlane);
393
394void
395
396ExaCheckPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
397 DDXPointPtr pptInit);
398
399void
400
401ExaCheckPolylines(DrawablePtr pDrawable, GCPtr pGC,
402 int mode, int npt, DDXPointPtr ppt);
403
404void
405
406ExaCheckPolySegment(DrawablePtr pDrawable, GCPtr pGC,
407 int nsegInit, xSegment * pSegInit);
408
409void
410 ExaCheckPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * pArcs);
411
412void
413
414ExaCheckPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
415 int nrect, xRectangle *prect);
416
417void
418
419ExaCheckImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
420 int x, int y, unsigned int nglyph,
421 CharInfoPtr * ppci, void *pglyphBase);
422
423void
424
425ExaCheckPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
426 int x, int y, unsigned int nglyph,
427 CharInfoPtr * ppci, void *pglyphBase);
428
429void
430
431ExaCheckPushPixels(GCPtr pGC, PixmapPtr pBitmap,
432 DrawablePtr pDrawable, int w, int h, int x, int y);
433
434void
435 ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
436
437void
438
439ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
440 unsigned int format, unsigned long planeMask, char *d);
441
442void
443
444ExaCheckGetSpans(DrawablePtr pDrawable,
445 int wMax,
446 DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart);
447
448void
449
450ExaCheckAddTraps(PicturePtr pPicture,
451 INT16 x_off, INT16 y_off, int ntrap, xTrap * traps);
452
453/* exa_accel.c */
454
455static _X_INLINE Bool
456exaGCReadsDestination(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
465void
466 exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
467
468Bool
469
470exaFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
471 DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
472 Bool clientClip);
473
474void
475
476exaGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
477 unsigned int format, unsigned long planeMask, char *d);
478
479RegionPtr
480
481exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
482 int srcx, int srcy, int width, int height, int dstx, int dsty);
483
484Bool
485
486exaHWCopyNtoN(DrawablePtr pSrcDrawable,
487 DrawablePtr pDstDrawable,
488 GCPtr pGC,
489 BoxPtr pbox,
490 int nbox, int dx, int dy, Bool reverse, Bool upsidedown);
491
492void
493
494exaCopyNtoN(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
503extern const GCOps exaOps;
504
505void
506
507ExaCheckComposite(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
517void
518
519ExaCheckGlyphs(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 */
527void
528 ExaOffscreenSwapOut(ScreenPtr pScreen);
529
530void
531 ExaOffscreenSwapIn(ScreenPtr pScreen);
532
533ExaOffscreenArea *ExaOffscreenDefragment(ScreenPtr pScreen);
534
535Bool
536 exaOffscreenInit(ScreenPtr pScreen);
537
538void
539 ExaOffscreenFini(ScreenPtr pScreen);
540
541/* exa.c */
542Bool
543 ExaDoPrepareAccess(PixmapPtr pPixmap, int index);
544
545void
546 exaPrepareAccess(DrawablePtr pDrawable, int index);
547
548void
549 exaFinishAccess(DrawablePtr pDrawable, int index);
550
551void
552 exaDestroyPixmap(PixmapPtr pPixmap);
553
554void
555 exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2);
556
557void
558
559exaGetDrawableDeltas(DrawablePtr pDrawable, PixmapPtr pPixmap,
560 int *xp, int *yp);
561
562Bool
563 exaPixmapHasGpuCopy(PixmapPtr p);
564
565PixmapPtr
566 exaGetOffscreenPixmap(DrawablePtr pDrawable, int *xp, int *yp);
567
568PixmapPtr
569 exaGetDrawablePixmap(DrawablePtr pDrawable);
570
571void
572
573exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
574 int w, int h, int bpp);
575
576void
577
578exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
579 int w, int h, int bpp);
580
581void
582 exaDoMigration(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
583
584Bool
585 exaPixmapIsPinned(PixmapPtr pPix);
586
587extern const GCFuncs exaGCFuncs;
588
589/* exa_classic.c */
590PixmapPtr
591
592exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
593 unsigned usage_hint);
594
595Bool
596
597exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height,
598 int depth, int bitsPerPixel, int devKind,
599 void *pPixData);
600
601Bool
602 exaDestroyPixmap_classic(PixmapPtr pPixmap);
603
604Bool
605 exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
606
607/* exa_driver.c */
608PixmapPtr
609
610exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
611 unsigned usage_hint);
612
613Bool
614
615exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height,
616 int depth, int bitsPerPixel, int devKind,
617 void *pPixData);
618
619Bool
620 exaDestroyPixmap_driver(PixmapPtr pPixmap);
621
622Bool
623 exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
624
625/* exa_mixed.c */
626PixmapPtr
627
628exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
629 unsigned usage_hint);
630
631Bool
632
633exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
634 int bitsPerPixel, int devKind, void *pPixData);
635
636Bool
637 exaDestroyPixmap_mixed(PixmapPtr pPixmap);
638
639Bool
640 exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
641
642/* exa_migration_mixed.c */
643void
644 exaCreateDriverPixmap_mixed(PixmapPtr pPixmap);
645
646void
647 exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
648
649void
650 exaMoveInPixmap_mixed(PixmapPtr pPixmap);
651
652void
653 exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure);
654
655void
656 exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);
657
658Bool
659exaSetSharedPixmapBacking_mixed(PixmapPtr pPixmap, void *handle);
660Bool
661exaSharePixmapBacking_mixed(PixmapPtr pPixmap, ScreenPtr slave, void **handle_p);
662
663/* exa_render.c */
664Bool
665 exaOpReadsDestination(CARD8 op);
666
667void
668
669exaComposite(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
678void
679
680exaCompositeRects(CARD8 op,
681 PicturePtr Src,
682 PicturePtr pMask,
683 PicturePtr pDst, int nrect, ExaCompositeRectPtr rects);
684
685void
686
687exaTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
688 PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
689 int ntrap, xTrapezoid * traps);
690
691void
692
693exaTriangles(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
694 PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
695 int ntri, xTriangle * tris);
696
697/* exa_glyph.c */
698void
699 exaGlyphsInit(ScreenPtr pScreen);
700
701void
702 exaGlyphsFini(ScreenPtr pScreen);
703
704void
705
706exaGlyphs(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 */
714void
715 exaCopyDirtyToSys(ExaMigrationPtr migrate);
716
717void
718 exaCopyDirtyToFb(ExaMigrationPtr migrate);
719
720void
721 exaDoMigration_classic(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
722
723void
724 exaPixmapSave(ScreenPtr pScreen, ExaOffscreenArea * area);
725
726void
727 exaMoveOutPixmap_classic(PixmapPtr pPixmap);
728
729void
730 exaMoveInPixmap_classic(PixmapPtr pPixmap);
731
732void
733 exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);
734
735#endif /* EXAPRIV_H */
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette