exa_priv.h@ 74087

Last change on this file since 74087 was 38824, checked in by vboxsync, 13 years ago
Additions/x11: header files for building X.Org Server 1.11 modules
Property svn:eol-style set to `native`
File size: 19.3 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) \
65	do { \
66	ErrorF("EXA fallback at %s: ", __FUNCTION__); \
67	ErrorF x; \
68	} while (0)
69
70	char
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) \
92	do { \
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	*/
102	enum ExaMigrationHeuristic {
103	ExaMigrationGreedy,
104	ExaMigrationAlways,
105	ExaMigrationSmart
106	};
107
108	typedef struct {
109	unsigned char sha1[20];
110	} ExaCachedGlyphRec, *ExaCachedGlyphPtr;
111
112	typedef 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
143	typedef struct _ExaMigrationRec {
144	Bool as_dst;
145	Bool as_src;
146	PixmapPtr pPix;
147	RegionPtr pReg;
148	} ExaMigrationRec, *ExaMigrationPtr;
149
150	typedef void (*EnableDisableFBAccessProcPtr)(int, Bool);
151	typedef 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	SourceValidateProcPtr SavedSourceValidate;
167	CompositeProcPtr SavedComposite;
168	TrianglesProcPtr SavedTriangles;
169	GlyphsProcPtr SavedGlyphs;
170	TrapezoidsProcPtr SavedTrapezoids;
171	AddTrapsProcPtr SavedAddTraps;
172	void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
173	Bool (*pixmap_has_gpu_copy) (PixmapPtr pPixmap);
174	void (*do_move_in_pixmap) (PixmapPtr pPixmap);
175	void (*do_move_out_pixmap) (PixmapPtr pPixmap);
176	void (*prepare_access_reg)(PixmapPtr pPixmap, int index, RegionPtr pReg);
177
178	Bool swappedOut;
179	enum ExaMigrationHeuristic migration;
180	Bool checkDirtyCorrectness;
181	unsigned disableFbCount;
182	Bool optimize_migration;
183	unsigned offScreenCounter;
184	unsigned numOffscreenAvailable;
185	CARD32 lastDefragment;
186	CARD32 nextDefragment;
187	PixmapPtr deferred_mixed_pixmap;
188
189	/* Reference counting for accessed pixmaps */
190	struct {
191	PixmapPtr pixmap;
192	int count;
193	Bool retval;
194	} access[EXA_NUM_PREPARE_INDICES];
195
196	/* Holds information on fallbacks that cannot be relayed otherwise. */
197	unsigned int fallback_flags;
198	unsigned int fallback_counter;
199
200	ExaGlyphCacheRec glyphCaches[EXA_NUM_GLYPH_CACHES];
201
202	/**
203	* Regions affected by fallback composite source / mask operations.
204	*/
205
206	RegionRec srcReg;
207	RegionRec maskReg;
208	PixmapPtr srcPix;
209
210	} ExaScreenPrivRec, *ExaScreenPrivPtr;
211
212	/*
213	* This is the only completely portable way to
214	* compute this info.
215	*/
216	#ifndef BitsPerPixel
217	#define BitsPerPixel(d) (\
218	PixmapWidthPaddingInfo[d].notPower2 ? \
219	(PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \
220	((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
221	(PixmapWidthPaddingInfo[d].padRoundUp+1)))
222	#endif
223
224	extern DevPrivateKeyRec exaScreenPrivateKeyRec;
225	#define exaScreenPrivateKey (&exaScreenPrivateKeyRec)
226	extern DevPrivateKeyRec exaPixmapPrivateKeyRec;
227	#define exaPixmapPrivateKey (&exaPixmapPrivateKeyRec)
228	extern DevPrivateKeyRec exaGCPrivateKeyRec;
229	#define exaGCPrivateKey (&exaGCPrivateKeyRec)
230
231	#define ExaGetScreenPriv(s) ((ExaScreenPrivPtr)dixGetPrivate(&(s)->devPrivates, exaScreenPrivateKey))
232	#define ExaScreenPriv(s) ExaScreenPrivPtr pExaScr = ExaGetScreenPriv(s)
233
234	#define ExaGetGCPriv(gc) ((ExaGCPrivPtr)dixGetPrivateAddr(&(gc)->devPrivates, exaGCPrivateKey))
235	#define ExaGCPriv(gc) ExaGCPrivPtr pExaGC = ExaGetGCPriv(gc)
236
237	/*
238	* Some macros to deal with function wrapping.
239	*/
240	#define wrap(priv, real, mem, func) {\
241	priv->Saved##mem = real->mem; \
242	real->mem = func; \
243	}
244
245	#define unwrap(priv, real, mem) {\
246	real->mem = priv->Saved##mem; \
247	}
248
249	#define swap(priv, real, mem) {\
250	void *tmp = priv->Saved##mem; \
251	priv->Saved##mem = real->mem; \
252	real->mem = tmp; \
253	}
254
255	#define EXA_PRE_FALLBACK(_screen_) \
256	ExaScreenPriv(_screen_); \
257	pExaScr->fallback_counter++;
258
259	#define EXA_POST_FALLBACK(_screen_) \
260	pExaScr->fallback_counter--;
261
262	#define EXA_PRE_FALLBACK_GC(_gc_) \
263	ExaScreenPriv(_gc_->pScreen); \
264	ExaGCPriv(_gc_); \
265	pExaScr->fallback_counter++; \
266	swap(pExaGC, _gc_, ops);
267
268	#define EXA_POST_FALLBACK_GC(_gc_) \
269	pExaScr->fallback_counter--; \
270	swap(pExaGC, _gc_, ops);
271
272	/** Align an offset to an arbitrary alignment */
273	#define EXA_ALIGN(offset, align) (((offset) + (align) - 1) - \
274	(((offset) + (align) - 1) % (align)))
275	/** Align an offset to a power-of-two alignment */
276	#define EXA_ALIGN2(offset, align) (((offset) + (align) - 1) & ~((align) - 1))
277
278	#define EXA_PIXMAP_SCORE_MOVE_IN 10
279	#define EXA_PIXMAP_SCORE_MAX 20
280	#define EXA_PIXMAP_SCORE_MOVE_OUT -10
281	#define EXA_PIXMAP_SCORE_MIN -20
282	#define EXA_PIXMAP_SCORE_PINNED 1000
283	#define EXA_PIXMAP_SCORE_INIT 1001
284
285	#define ExaGetPixmapPriv(p) ((ExaPixmapPrivPtr)dixGetPrivateAddr(&(p)->devPrivates, exaPixmapPrivateKey))
286	#define ExaPixmapPriv(p) ExaPixmapPrivPtr pExaPixmap = ExaGetPixmapPriv(p)
287
288	#define EXA_RANGE_PITCH (1 << 0)
289	#define EXA_RANGE_WIDTH (1 << 1)
290	#define EXA_RANGE_HEIGHT (1 << 2)
291
292	typedef struct {
293	ExaOffscreenArea *area;
294	int score; /*< score for the move-in vs move-out heuristic /
295	Bool use_gpu_copy;
296
297	CARD8 sys_ptr; /< pointer to pixmap data in system memory /
298	int sys_pitch; /*< pitch of pixmap in system memory /
299
300	CARD8 fb_ptr; /< pointer to pixmap data in framebuffer memory /
301	int fb_pitch; /*< pitch of pixmap in framebuffer memory /
302	unsigned int fb_size; /*< size of pixmap in framebuffer memory /
303
304	/**
305	* Holds information about whether this pixmap can be used for
306	* acceleration (== 0) or not (> 0).
307	*
308	* Contains a OR'ed combination of the following values:
309	* EXA_RANGE_PITCH - set if the pixmap's pitch is out of range
310	* EXA_RANGE_WIDTH - set if the pixmap's width is out of range
311	* EXA_RANGE_HEIGHT - set if the pixmap's height is out of range
312	*/
313	unsigned int accel_blocked;
314
315	/**
316	* The damage record contains the areas of the pixmap's current location
317	* (framebuffer or system) that have been damaged compared to the other
318	* location.
319	*/
320	DamagePtr pDamage;
321	/**
322	* The valid regions mark the valid bits (at least, as they're derived from
323	* damage, which may be overreported) of a pixmap's system and FB copies.
324	*/
325	RegionRec validSys, validFB;
326	/**
327	* Driver private storage per EXA pixmap
328	*/
329	void *driverPriv;
330	} ExaPixmapPrivRec, *ExaPixmapPrivPtr;
331
332	typedef struct {
333	/* GC values from the layer below. */
334	GCOps *Savedops;
335	GCFuncs *Savedfuncs;
336	} ExaGCPrivRec, *ExaGCPrivPtr;
337
338	typedef struct {
339	PicturePtr pDst;
340	INT16 xSrc;
341	INT16 ySrc;
342	INT16 xMask;
343	INT16 yMask;
344	INT16 xDst;
345	INT16 yDst;
346	INT16 width;
347	INT16 height;
348	} ExaCompositeRectRec, *ExaCompositeRectPtr;
349
350	/**
351	* exaDDXDriverInit must be implemented by the DDX using EXA, and is the place
352	* to set EXA options or hook in screen functions to handle using EXA as the AA.
353	*/
354	void exaDDXDriverInit (ScreenPtr pScreen);
355
356	/* exa_unaccel.c */
357	void
358	exaPrepareAccessGC(GCPtr pGC);
359
360	void
361	exaFinishAccessGC(GCPtr pGC);
362
363	void
364	ExaCheckFillSpans (DrawablePtr pDrawable, GCPtr pGC, int nspans,
365	DDXPointPtr ppt, int *pwidth, int fSorted);
366
367	void
368	ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc,
369	DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
370
371	void
372	ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,
373	int x, int y, int w, int h, int leftPad, int format,
374	char *bits);
375
376	void
377	ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
378	BoxPtr pbox, int nbox, int dx, int dy, Bool reverse,
379	Bool upsidedown, Pixel bitplane, void *closure);
380
381	RegionPtr
382	ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
383	int srcx, int srcy, int w, int h, int dstx, int dsty);
384
385	RegionPtr
386	ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
387	int srcx, int srcy, int w, int h, int dstx, int dsty,
388	unsigned long bitPlane);
389
390	void
391	ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
392	DDXPointPtr pptInit);
393
394	void
395	ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,
396	int mode, int npt, DDXPointPtr ppt);
397
398	void
399	ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,
400	int nsegInit, xSegment *pSegInit);
401
402	void
403	ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,
404	int narcs, xArc *pArcs);
405
406	void
407	ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,
408	int nrect, xRectangle *prect);
409
410	void
411	ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
412	int x, int y, unsigned int nglyph,
413	CharInfoPtr *ppci, pointer pglyphBase);
414
415	void
416	ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
417	int x, int y, unsigned int nglyph,
418	CharInfoPtr *ppci, pointer pglyphBase);
419
420	void
421	ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
422	DrawablePtr pDrawable,
423	int w, int h, int x, int y);
424
425	void
426	ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
427
428	void
429	ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
430	unsigned int format, unsigned long planeMask, char *d);
431
432	void
433	ExaCheckGetSpans (DrawablePtr pDrawable,
434	int wMax,
435	DDXPointPtr ppt,
436	int *pwidth,
437	int nspans,
438	char *pdstStart);
439
440	void
441	ExaCheckAddTraps (PicturePtr pPicture,
442	INT16 x_off,
443	INT16 y_off,
444	int ntrap,
445	xTrap *traps);
446
447	/* exa_accel.c */
448
449	static _X_INLINE Bool
450	exaGCReadsDestination(DrawablePtr pDrawable, unsigned long planemask,
451	unsigned int fillStyle, unsigned char alu,
452	unsigned int clientClipType)
453	{
454	return ((alu != GXcopy && alu != GXclear && alu != GXset &&
455	alu != GXcopyInverted) \|\| fillStyle == FillStippled \|\|
456	clientClipType != CT_NONE \|\| !EXA_PM_IS_SOLID(pDrawable, planemask));
457	}
458
459	void
460	exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
461
462	Bool
463	exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
464	DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
465	unsigned int clientClipType);
466
467	void
468	exaGetImage (DrawablePtr pDrawable, int x, int y, int w, int h,
469	unsigned int format, unsigned long planeMask, char *d);
470
471	RegionPtr
472	exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
473	int srcx, int srcy, int width, int height, int dstx, int dsty);
474
475	Bool
476	exaHWCopyNtoN (DrawablePtr pSrcDrawable,
477	DrawablePtr pDstDrawable,
478	GCPtr pGC,
479	BoxPtr pbox,
480	int nbox,
481	int dx,
482	int dy,
483	Bool reverse,
484	Bool upsidedown);
485
486	void
487	exaCopyNtoN (DrawablePtr pSrcDrawable,
488	DrawablePtr pDstDrawable,
489	GCPtr pGC,
490	BoxPtr pbox,
491	int nbox,
492	int dx,
493	int dy,
494	Bool reverse,
495	Bool upsidedown,
496	Pixel bitplane,
497	void *closure);
498
499	extern const GCOps exaOps;
500
501	void
502	ExaCheckComposite (CARD8 op,
503	PicturePtr pSrc,
504	PicturePtr pMask,
505	PicturePtr pDst,
506	INT16 xSrc,
507	INT16 ySrc,
508	INT16 xMask,
509	INT16 yMask,
510	INT16 xDst,
511	INT16 yDst,
512	CARD16 width,
513	CARD16 height);
514
515	void
516	ExaCheckGlyphs (CARD8 op,
517	PicturePtr pSrc,
518	PicturePtr pDst,
519	PictFormatPtr maskFormat,
520	INT16 xSrc,
521	INT16 ySrc,
522	int nlist,
523	GlyphListPtr list,
524	GlyphPtr *glyphs);
525
526	/* exa_offscreen.c */
527	void
528	ExaOffscreenSwapOut (ScreenPtr pScreen);
529
530	void
531	ExaOffscreenSwapIn (ScreenPtr pScreen);
532
533	ExaOffscreenArea*
534	ExaOffscreenDefragment (ScreenPtr pScreen);
535
536	Bool
537	exaOffscreenInit(ScreenPtr pScreen);
538
539	void
540	ExaOffscreenFini (ScreenPtr pScreen);
541
542	/* exa.c */
543	Bool
544	ExaDoPrepareAccess(PixmapPtr pPixmap, int index);
545
546	void
547	exaPrepareAccess(DrawablePtr pDrawable, int index);
548
549	void
550	exaFinishAccess(DrawablePtr pDrawable, int index);
551
552	void
553	exaDestroyPixmap(PixmapPtr pPixmap);
554
555	void
556	exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2);
557
558	void
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	exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
573	int w, int h, int bpp);
574
575	void
576	exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
577	int w, int h, int bpp);
578
579	void
580	exaDoMigration (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
581
582	Bool
583	exaPixmapIsPinned (PixmapPtr pPix);
584
585	extern const GCFuncs exaGCFuncs;
586
587	/* exa_classic.c */
588	PixmapPtr
589	exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
590	unsigned usage_hint);
591
592	Bool
593	exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int depth,
594	int bitsPerPixel, int devKind, pointer pPixData);
595
596	Bool
597	exaDestroyPixmap_classic (PixmapPtr pPixmap);
598
599	Bool
600	exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
601
602	/* exa_driver.c */
603	PixmapPtr
604	exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
605	unsigned usage_hint);
606
607	Bool
608	exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height, int depth,
609	int bitsPerPixel, int devKind, pointer pPixData);
610
611	Bool
612	exaDestroyPixmap_driver (PixmapPtr pPixmap);
613
614	Bool
615	exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
616
617	/* exa_mixed.c */
618	PixmapPtr
619	exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
620	unsigned usage_hint);
621
622	Bool
623	exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
624	int bitsPerPixel, int devKind, pointer pPixData);
625
626	Bool
627	exaDestroyPixmap_mixed(PixmapPtr pPixmap);
628
629	Bool
630	exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
631
632	/* exa_migration_mixed.c */
633	void
634	exaCreateDriverPixmap_mixed(PixmapPtr pPixmap);
635
636	void
637	exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
638
639	void
640	exaMoveInPixmap_mixed(PixmapPtr pPixmap);
641
642	void
643	exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure);
644
645	void
646	exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);
647
648	/* exa_render.c */
649	Bool
650	exaOpReadsDestination (CARD8 op);
651
652	void
653	exaComposite(CARD8 op,
654	PicturePtr pSrc,
655	PicturePtr pMask,
656	PicturePtr pDst,
657	INT16 xSrc,
658	INT16 ySrc,
659	INT16 xMask,
660	INT16 yMask,
661	INT16 xDst,
662	INT16 yDst,
663	CARD16 width,
664	CARD16 height);
665
666	void
667	exaCompositeRects(CARD8 op,
668	PicturePtr Src,
669	PicturePtr pMask,
670	PicturePtr pDst,
671	int nrect,
672	ExaCompositeRectPtr rects);
673
674	void
675	exaTrapezoids (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
676	PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
677	int ntrap, xTrapezoid *traps);
678
679	void
680	exaTriangles (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
681	PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
682	int ntri, xTriangle *tris);
683
684	/* exa_glyph.c */
685	void
686	exaGlyphsInit(ScreenPtr pScreen);
687
688	void
689	exaGlyphsFini (ScreenPtr pScreen);
690
691	void
692	exaGlyphs (CARD8 op,
693	PicturePtr pSrc,
694	PicturePtr pDst,
695	PictFormatPtr maskFormat,
696	INT16 xSrc,
697	INT16 ySrc,
698	int nlist,
699	GlyphListPtr list,
700	GlyphPtr *glyphs);
701
702	/* exa_migration_classic.c */
703	void
704	exaCopyDirtyToSys (ExaMigrationPtr migrate);
705
706	void
707	exaCopyDirtyToFb (ExaMigrationPtr migrate);
708
709	void
710	exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
711
712	void
713	exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area);
714
715	void
716	exaMoveOutPixmap_classic (PixmapPtr pPixmap);
717
718	void
719	exaMoveInPixmap_classic (PixmapPtr pPixmap);
720
721	void
722	exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);
723
724	#endif /* EXAPRIV_H */

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

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

Download in other formats: