VirtualBox

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

Last change on this file since 87454 was 43251, checked in by vboxsync, 12 years ago

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

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