exa_priv.h@ 78293

Last change on this file since 78293 was 58634, checked in by vboxsync, 9 years ago
Additions/x11: added header files for building X.Org video driver against X.Org Server 1.18.
Property svn:eol-style set to `native`
File size: 20.0 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) \
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 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
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	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 slave, 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 */

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: