VirtualBox

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

Last change on this file since 99743 was 52145, checked in by vboxsync, 10 years ago

Additions/x11/x11include: add header files for X.Org Server 1.16.
  • Property svn:eol-style set to native
File size: 20.4 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 "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
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#ifdef HAVE_TYPEOF
252#define swap(priv, real, mem) {\
253 typeof(real->mem) tmp = priv->Saved##mem; \
254 priv->Saved##mem = real->mem; \
255 real->mem = tmp; \
256}
257#else
258#define swap(priv, real, mem) {\
259 void *tmp = priv->Saved##mem; \
260 priv->Saved##mem = real->mem; \
261 real->mem = tmp; \
262}
263#endif
264
265#define EXA_PRE_FALLBACK(_screen_) \
266 ExaScreenPriv(_screen_); \
267 pExaScr->fallback_counter++;
268
269#define EXA_POST_FALLBACK(_screen_) \
270 pExaScr->fallback_counter--;
271
272#define EXA_PRE_FALLBACK_GC(_gc_) \
273 ExaScreenPriv(_gc_->pScreen); \
274 ExaGCPriv(_gc_); \
275 pExaScr->fallback_counter++; \
276 swap(pExaGC, _gc_, ops);
277
278#define EXA_POST_FALLBACK_GC(_gc_) \
279 pExaScr->fallback_counter--; \
280 swap(pExaGC, _gc_, ops);
281
282/** Align an offset to an arbitrary alignment */
283#define EXA_ALIGN(offset, align) (((offset) + (align) - 1) - \
284 (((offset) + (align) - 1) % (align)))
285/** Align an offset to a power-of-two alignment */
286#define EXA_ALIGN2(offset, align) (((offset) + (align) - 1) & ~((align) - 1))
287
288#define EXA_PIXMAP_SCORE_MOVE_IN 10
289#define EXA_PIXMAP_SCORE_MAX 20
290#define EXA_PIXMAP_SCORE_MOVE_OUT -10
291#define EXA_PIXMAP_SCORE_MIN -20
292#define EXA_PIXMAP_SCORE_PINNED 1000
293#define EXA_PIXMAP_SCORE_INIT 1001
294
295#define ExaGetPixmapPriv(p) ((ExaPixmapPrivPtr)dixGetPrivateAddr(&(p)->devPrivates, &ExaGetScreenPriv((p)->drawable.pScreen)->pixmapPrivateKeyRec))
296#define ExaPixmapPriv(p) ExaPixmapPrivPtr pExaPixmap = ExaGetPixmapPriv(p)
297
298#define EXA_RANGE_PITCH (1 << 0)
299#define EXA_RANGE_WIDTH (1 << 1)
300#define EXA_RANGE_HEIGHT (1 << 2)
301
302typedef struct {
303 ExaOffscreenArea *area;
304 int score; /**< score for the move-in vs move-out heuristic */
305 Bool use_gpu_copy;
306
307 CARD8 *sys_ptr; /**< pointer to pixmap data in system memory */
308 int sys_pitch; /**< pitch of pixmap in system memory */
309
310 CARD8 *fb_ptr; /**< pointer to pixmap data in framebuffer memory */
311 int fb_pitch; /**< pitch of pixmap in framebuffer memory */
312 unsigned int fb_size; /**< size of pixmap in framebuffer memory */
313
314 /**
315 * Holds information about whether this pixmap can be used for
316 * acceleration (== 0) or not (> 0).
317 *
318 * Contains a OR'ed combination of the following values:
319 * EXA_RANGE_PITCH - set if the pixmap's pitch is out of range
320 * EXA_RANGE_WIDTH - set if the pixmap's width is out of range
321 * EXA_RANGE_HEIGHT - set if the pixmap's height is out of range
322 */
323 unsigned int accel_blocked;
324
325 /**
326 * The damage record contains the areas of the pixmap's current location
327 * (framebuffer or system) that have been damaged compared to the other
328 * location.
329 */
330 DamagePtr pDamage;
331 /**
332 * The valid regions mark the valid bits (at least, as they're derived from
333 * damage, which may be overreported) of a pixmap's system and FB copies.
334 */
335 RegionRec validSys, validFB;
336 /**
337 * Driver private storage per EXA pixmap
338 */
339 void *driverPriv;
340} ExaPixmapPrivRec, *ExaPixmapPrivPtr;
341
342typedef struct {
343 /* GC values from the layer below. */
344 const GCOps *Savedops;
345 const GCFuncs *Savedfuncs;
346} ExaGCPrivRec, *ExaGCPrivPtr;
347
348typedef struct {
349 PicturePtr pDst;
350 INT16 xSrc;
351 INT16 ySrc;
352 INT16 xMask;
353 INT16 yMask;
354 INT16 xDst;
355 INT16 yDst;
356 INT16 width;
357 INT16 height;
358} ExaCompositeRectRec, *ExaCompositeRectPtr;
359
360/**
361 * exaDDXDriverInit must be implemented by the DDX using EXA, and is the place
362 * to set EXA options or hook in screen functions to handle using EXA as the AA.
363 */
364void exaDDXDriverInit(ScreenPtr pScreen);
365
366/* exa_unaccel.c */
367void
368 exaPrepareAccessGC(GCPtr pGC);
369
370void
371 exaFinishAccessGC(GCPtr pGC);
372
373void
374
375ExaCheckFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nspans,
376 DDXPointPtr ppt, int *pwidth, int fSorted);
377
378void
379
380ExaCheckSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *psrc,
381 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
382
383void
384
385ExaCheckPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
386 int x, int y, int w, int h, int leftPad, int format,
387 char *bits);
388
389void
390
391ExaCheckCopyNtoN(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
392 BoxPtr pbox, int nbox, int dx, int dy, Bool reverse,
393 Bool upsidedown, Pixel bitplane, void *closure);
394
395RegionPtr
396
397ExaCheckCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
398 int srcx, int srcy, int w, int h, int dstx, int dsty);
399
400RegionPtr
401
402ExaCheckCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
403 int srcx, int srcy, int w, int h, int dstx, int dsty,
404 unsigned long bitPlane);
405
406void
407
408ExaCheckPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
409 DDXPointPtr pptInit);
410
411void
412
413ExaCheckPolylines(DrawablePtr pDrawable, GCPtr pGC,
414 int mode, int npt, DDXPointPtr ppt);
415
416void
417
418ExaCheckPolySegment(DrawablePtr pDrawable, GCPtr pGC,
419 int nsegInit, xSegment * pSegInit);
420
421void
422 ExaCheckPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * pArcs);
423
424void
425
426ExaCheckPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
427 int nrect, xRectangle *prect);
428
429void
430
431ExaCheckImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
432 int x, int y, unsigned int nglyph,
433 CharInfoPtr * ppci, void *pglyphBase);
434
435void
436
437ExaCheckPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
438 int x, int y, unsigned int nglyph,
439 CharInfoPtr * ppci, void *pglyphBase);
440
441void
442
443ExaCheckPushPixels(GCPtr pGC, PixmapPtr pBitmap,
444 DrawablePtr pDrawable, int w, int h, int x, int y);
445
446void
447 ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
448
449void
450
451ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
452 unsigned int format, unsigned long planeMask, char *d);
453
454void
455
456ExaCheckGetSpans(DrawablePtr pDrawable,
457 int wMax,
458 DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart);
459
460void
461
462ExaCheckAddTraps(PicturePtr pPicture,
463 INT16 x_off, INT16 y_off, int ntrap, xTrap * traps);
464
465/* exa_accel.c */
466
467static _X_INLINE Bool
468exaGCReadsDestination(DrawablePtr pDrawable, unsigned long planemask,
469 unsigned int fillStyle, unsigned char alu,
470 unsigned int clientClipType)
471{
472 return ((alu != GXcopy && alu != GXclear && alu != GXset &&
473 alu != GXcopyInverted) || fillStyle == FillStippled ||
474 clientClipType != CT_NONE ||
475 !EXA_PM_IS_SOLID(pDrawable, planemask));
476}
477
478void
479 exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
480
481Bool
482
483exaFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
484 DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
485 unsigned int clientClipType);
486
487void
488
489exaGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
490 unsigned int format, unsigned long planeMask, char *d);
491
492RegionPtr
493
494exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
495 int srcx, int srcy, int width, int height, int dstx, int dsty);
496
497Bool
498
499exaHWCopyNtoN(DrawablePtr pSrcDrawable,
500 DrawablePtr pDstDrawable,
501 GCPtr pGC,
502 BoxPtr pbox,
503 int nbox, int dx, int dy, Bool reverse, Bool upsidedown);
504
505void
506
507exaCopyNtoN(DrawablePtr pSrcDrawable,
508 DrawablePtr pDstDrawable,
509 GCPtr pGC,
510 BoxPtr pbox,
511 int nbox,
512 int dx,
513 int dy,
514 Bool reverse, Bool upsidedown, Pixel bitplane, void *closure);
515
516extern const GCOps exaOps;
517
518void
519
520ExaCheckComposite(CARD8 op,
521 PicturePtr pSrc,
522 PicturePtr pMask,
523 PicturePtr pDst,
524 INT16 xSrc,
525 INT16 ySrc,
526 INT16 xMask,
527 INT16 yMask,
528 INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
529
530void
531
532ExaCheckGlyphs(CARD8 op,
533 PicturePtr pSrc,
534 PicturePtr pDst,
535 PictFormatPtr maskFormat,
536 INT16 xSrc,
537 INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
538
539/* exa_offscreen.c */
540void
541 ExaOffscreenSwapOut(ScreenPtr pScreen);
542
543void
544 ExaOffscreenSwapIn(ScreenPtr pScreen);
545
546ExaOffscreenArea *ExaOffscreenDefragment(ScreenPtr pScreen);
547
548Bool
549 exaOffscreenInit(ScreenPtr pScreen);
550
551void
552 ExaOffscreenFini(ScreenPtr pScreen);
553
554/* exa.c */
555Bool
556 ExaDoPrepareAccess(PixmapPtr pPixmap, int index);
557
558void
559 exaPrepareAccess(DrawablePtr pDrawable, int index);
560
561void
562 exaFinishAccess(DrawablePtr pDrawable, int index);
563
564void
565 exaDestroyPixmap(PixmapPtr pPixmap);
566
567void
568 exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2);
569
570void
571
572exaGetDrawableDeltas(DrawablePtr pDrawable, PixmapPtr pPixmap,
573 int *xp, int *yp);
574
575Bool
576 exaPixmapHasGpuCopy(PixmapPtr p);
577
578PixmapPtr
579 exaGetOffscreenPixmap(DrawablePtr pDrawable, int *xp, int *yp);
580
581PixmapPtr
582 exaGetDrawablePixmap(DrawablePtr pDrawable);
583
584void
585
586exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
587 int w, int h, int bpp);
588
589void
590
591exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
592 int w, int h, int bpp);
593
594void
595 exaDoMigration(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
596
597Bool
598 exaPixmapIsPinned(PixmapPtr pPix);
599
600extern const GCFuncs exaGCFuncs;
601
602/* exa_classic.c */
603PixmapPtr
604
605exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
606 unsigned usage_hint);
607
608Bool
609
610exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height,
611 int depth, int bitsPerPixel, int devKind,
612 void *pPixData);
613
614Bool
615 exaDestroyPixmap_classic(PixmapPtr pPixmap);
616
617Bool
618 exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
619
620/* exa_driver.c */
621PixmapPtr
622
623exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
624 unsigned usage_hint);
625
626Bool
627
628exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height,
629 int depth, int bitsPerPixel, int devKind,
630 void *pPixData);
631
632Bool
633 exaDestroyPixmap_driver(PixmapPtr pPixmap);
634
635Bool
636 exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
637
638/* exa_mixed.c */
639PixmapPtr
640
641exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
642 unsigned usage_hint);
643
644Bool
645
646exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
647 int bitsPerPixel, int devKind, void *pPixData);
648
649Bool
650 exaDestroyPixmap_mixed(PixmapPtr pPixmap);
651
652Bool
653 exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
654
655/* exa_migration_mixed.c */
656void
657 exaCreateDriverPixmap_mixed(PixmapPtr pPixmap);
658
659void
660 exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
661
662void
663 exaMoveInPixmap_mixed(PixmapPtr pPixmap);
664
665void
666 exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure);
667
668void
669 exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);
670
671Bool
672exaSetSharedPixmapBacking_mixed(PixmapPtr pPixmap, void *handle);
673Bool
674exaSharePixmapBacking_mixed(PixmapPtr pPixmap, ScreenPtr slave, void **handle_p);
675
676/* exa_render.c */
677Bool
678 exaOpReadsDestination(CARD8 op);
679
680void
681
682exaComposite(CARD8 op,
683 PicturePtr pSrc,
684 PicturePtr pMask,
685 PicturePtr pDst,
686 INT16 xSrc,
687 INT16 ySrc,
688 INT16 xMask,
689 INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
690
691void
692
693exaCompositeRects(CARD8 op,
694 PicturePtr Src,
695 PicturePtr pMask,
696 PicturePtr pDst, int nrect, ExaCompositeRectPtr rects);
697
698void
699
700exaTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
701 PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
702 int ntrap, xTrapezoid * traps);
703
704void
705
706exaTriangles(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
707 PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
708 int ntri, xTriangle * tris);
709
710/* exa_glyph.c */
711void
712 exaGlyphsInit(ScreenPtr pScreen);
713
714void
715 exaGlyphsFini(ScreenPtr pScreen);
716
717void
718
719exaGlyphs(CARD8 op,
720 PicturePtr pSrc,
721 PicturePtr pDst,
722 PictFormatPtr maskFormat,
723 INT16 xSrc,
724 INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
725
726/* exa_migration_classic.c */
727void
728 exaCopyDirtyToSys(ExaMigrationPtr migrate);
729
730void
731 exaCopyDirtyToFb(ExaMigrationPtr migrate);
732
733void
734 exaDoMigration_classic(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
735
736void
737 exaPixmapSave(ScreenPtr pScreen, ExaOffscreenArea * area);
738
739void
740 exaMoveOutPixmap_classic(PixmapPtr pPixmap);
741
742void
743 exaMoveInPixmap_classic(PixmapPtr pPixmap);
744
745void
746 exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);
747
748#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