pixman.h@ 43030

Last change on this file since 43030 was 17242, checked in by vboxsync, 16 years ago
Additions/x11/x11include: removed svn:keywords properties from all files under this directory as per SvnKeywords on the wiki. Hopefully this is finally correct
Property svn:eol-style set to `native`
File size: 32.2 KB

Line
1	/***********************************************************
2
3	Copyright 1987, 1998 The Open Group
4
5	Permission to use, copy, modify, distribute, and sell this software and its
6	documentation for any purpose is hereby granted without fee, provided that
7	the above copyright notice appear in all copies and that both that
8	copyright notice and this permission notice appear in supporting
9	documentation.
10
11	The above copyright notice and this permission notice shall be included in
12	all copies or substantial portions of the Software.
13
14	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17	OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18	AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21	Except as contained in this notice, the name of The Open Group shall not be
22	used in advertising or otherwise to promote the sale, use or other dealings
23	in this Software without prior written authorization from The Open Group.
24
25	Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
26
27	All Rights Reserved
28
29	Permission to use, copy, modify, and distribute this software and its
30	documentation for any purpose and without fee is hereby granted,
31	provided that the above copyright notice appear in all copies and that
32	both that copyright notice and this permission notice appear in
33	supporting documentation, and that the name of Digital not be
34	used in advertising or publicity pertaining to distribution of the
35	software without specific, written prior permission.
36
37	DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
38	ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
39	DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
40	ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
41	WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
42	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
43	SOFTWARE.
44
45	******************************************************************/
46	/*
47	* Copyright © 1998, 2004 Keith Packard
48	* Copyright 2007 Red Hat, Inc.
49	*
50	* Permission to use, copy, modify, distribute, and sell this software and its
51	* documentation for any purpose is hereby granted without fee, provided that
52	* the above copyright notice appear in all copies and that both that
53	* copyright notice and this permission notice appear in supporting
54	* documentation, and that the name of Keith Packard not be used in
55	* advertising or publicity pertaining to distribution of the software without
56	* specific, written prior permission. Keith Packard makes no
57	* representations about the suitability of this software for any purpose. It
58	* is provided "as is" without express or implied warranty.
59	*
60	* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
61	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
62	* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
63	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
64	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
65	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
66	* PERFORMANCE OF THIS SOFTWARE.
67	*/
68
69	#ifndef PIXMAN_H__
70	#define PIXMAN_H__
71
72	#include <pixman-version.h>
73
74	/*
75	* Standard integers
76	*/
77	#if defined (_SVR4) \|\| defined (SVR4) \|\| defined (__OpenBSD__) \|\| defined (_sgi) \|\| defined (__sun) \|\| defined (sun) \|\| defined (__digital__)
78	# include <inttypes.h>
79	#elif defined (_MSC_VER)
80	typedef __int8 int8_t;
81	typedef unsigned __int8 uint8_t;
82	typedef __int16 int16_t;
83	typedef unsigned __int16 uint16_t;
84	typedef __int32 int32_t;
85	typedef unsigned __int32 uint32_t;
86	typedef __int64 int64_t;
87	typedef unsigned __int64 uint64_t;
88	#elif defined (_AIX)
89	# include <sys/inttypes.h>
90	#else
91	# include <stdint.h>
92	#endif
93
94	/*
95	* Boolean
96	*/
97	typedef int pixman_bool_t;
98
99	/*
100	* Fixpoint numbers
101	*/
102	typedef int64_t pixman_fixed_32_32_t;
103	typedef pixman_fixed_32_32_t pixman_fixed_48_16_t;
104	typedef uint32_t pixman_fixed_1_31_t;
105	typedef uint32_t pixman_fixed_1_16_t;
106	typedef int32_t pixman_fixed_16_16_t;
107	typedef pixman_fixed_16_16_t pixman_fixed_t;
108
109	#define pixman_fixed_e ((pixman_fixed_t) 1)
110	#define pixman_fixed_1 (pixman_int_to_fixed(1))
111	#define pixman_fixed_1_minus_e (pixman_fixed_1 - pixman_fixed_e)
112	#define pixman_fixed_to_int(f) ((int) ((f) >> 16))
113	#define pixman_int_to_fixed(i) ((pixman_fixed_t) ((i) << 16))
114	#define pixman_fixed_to_double(f) (double) ((f) / (double) pixman_fixed_1)
115	#define pixman_double_to_fixed(d) ((pixman_fixed_t) ((d) * 65536.0))
116	#define pixman_fixed_frac(f) ((f) & pixman_fixed_1_minus_e)
117	#define pixman_fixed_floor(f) ((f) & ~pixman_fixed_1_minus_e)
118	#define pixman_fixed_ceil(f) pixman_fixed_floor ((f) + pixman_fixed_1_minus_e)
119	#define pixman_fixed_fraction(f) ((f) & pixman_fixed_1_minus_e)
120	#define pixman_fixed_mod_2(f) ((f) & (pixman_fixed1 \| pixman_fixed_1_minus_e))
121	#define pixman_max_fixed_48_16 ((pixman_fixed_48_16_t) 0x7fffffff)
122	#define pixman_min_fixed_48_16 (-((pixman_fixed_48_16_t) 1 << 31))
123
124	/*
125	* Misc structs
126	*/
127	typedef struct pixman_color pixman_color_t;
128	typedef struct pixman_point_fixed pixman_point_fixed_t;
129	typedef struct pixman_line_fixed pixman_line_fixed_t;
130	typedef struct pixman_vector pixman_vector_t;
131	typedef struct pixman_transform pixman_transform_t;
132
133	struct pixman_color
134	{
135	uint16_t red;
136	uint16_t green;
137	uint16_t blue;
138	uint16_t alpha;
139	};
140
141	struct pixman_point_fixed
142	{
143	pixman_fixed_t x;
144	pixman_fixed_t y;
145	};
146
147	struct pixman_line_fixed
148	{
149	pixman_point_fixed_t p1, p2;
150	};
151
152	/*
153	* Fixed point matrices
154	*/
155
156	struct pixman_vector
157	{
158	pixman_fixed_t vector[3];
159	};
160
161	struct pixman_transform
162	{
163	pixman_fixed_t matrix[3][3];
164	};
165
166	/* forward declaration (sorry) */
167	struct pixman_box16;
168
169	void
170	pixman_transform_init_identity(struct pixman_transform *matrix);
171
172	pixman_bool_t
173	pixman_transform_point_3d (const struct pixman_transform *transform,
174	struct pixman_vector *vector);
175
176	pixman_bool_t
177	pixman_transform_point(const struct pixman_transform *transform,
178	struct pixman_vector *vector);
179
180	pixman_bool_t
181	pixman_transform_multiply (struct pixman_transform *dst,
182	const struct pixman_transform *l,
183	const struct pixman_transform *r);
184
185	void
186	pixman_transform_init_scale (struct pixman_transform *t,
187	pixman_fixed_t sx,
188	pixman_fixed_t sy);
189
190	pixman_bool_t
191	pixman_transform_scale(struct pixman_transform *forward,
192	struct pixman_transform *reverse,
193	pixman_fixed_t sx, pixman_fixed_t sy);
194
195	void
196	pixman_transform_init_rotate(struct pixman_transform *t,
197	pixman_fixed_t cos,
198	pixman_fixed_t sin);
199
200	pixman_bool_t
201	pixman_transform_rotate(struct pixman_transform *forward,
202	struct pixman_transform *reverse,
203	pixman_fixed_t c, pixman_fixed_t s);
204
205	void
206	pixman_transform_init_translate(struct pixman_transform *t,
207	pixman_fixed_t tx, pixman_fixed_t ty);
208
209
210	pixman_bool_t
211	pixman_transform_translate(struct pixman_transform *forward,
212	struct pixman_transform *reverse,
213	pixman_fixed_t tx, pixman_fixed_t ty);
214
215	pixman_bool_t
216	pixman_transform_bounds(const struct pixman_transform *matrix,
217	struct pixman_box16 *b);
218
219
220	pixman_bool_t
221	pixman_transform_invert (struct pixman_transform *dst,
222	const struct pixman_transform *src);
223
224	pixman_bool_t
225	pixman_transform_is_identity(const struct pixman_transform *t);
226
227	pixman_bool_t
228	pixman_transform_is_scale(const struct pixman_transform *t);
229
230	pixman_bool_t
231	pixman_transform_is_int_translate(const struct pixman_transform *t);
232
233	pixman_bool_t
234	pixman_transform_is_inverse (const struct pixman_transform *a,
235	const struct pixman_transform *b);
236
237
238	/*
239	* Floating point matrices
240	*/
241	struct pixman_f_vector {
242	double v[3];
243	};
244
245	struct pixman_f_transform {
246	double m[3][3];
247	};
248
249	pixman_bool_t
250	pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
251	const struct pixman_f_transform *ft);
252
253	void
254	pixman_f_transform_from_pixman_transform (struct pixman_f_transform *ft,
255	const struct pixman_transform *t);
256
257	pixman_bool_t
258	pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
259	const struct pixman_f_transform *ft);
260
261	pixman_bool_t
262	pixman_f_transform_invert (struct pixman_f_transform *dst,
263	const struct pixman_f_transform *src);
264
265	pixman_bool_t
266	pixman_f_transform_point (const struct pixman_f_transform *t,
267	struct pixman_f_vector *v);
268
269	void
270	pixman_f_transform_point_3d (const struct pixman_f_transform *t,
271	struct pixman_f_vector *v);
272
273
274	void
275	pixman_f_transform_multiply (struct pixman_f_transform *dst,
276	const struct pixman_f_transform *l,
277	const struct pixman_f_transform *r);
278
279	void
280	pixman_f_transform_init_scale (struct pixman_f_transform *t, double sx, double sy);
281
282	pixman_bool_t
283	pixman_f_transform_scale (struct pixman_f_transform *forward,
284	struct pixman_f_transform *reverse,
285	double sx, double sy);
286
287	void
288	pixman_f_transform_init_rotate (struct pixman_f_transform *t, double cos, double sin);
289
290	pixman_bool_t
291	pixman_f_transform_rotate (struct pixman_f_transform *forward,
292	struct pixman_f_transform *reverse,
293	double c, double s);
294
295	void
296	pixman_f_transform_init_translate (struct pixman_f_transform *t, double tx, double ty);
297
298	pixman_bool_t
299	pixman_f_transform_translate (struct pixman_f_transform *forward,
300	struct pixman_f_transform *reverse,
301	double tx, double ty);
302
303	pixman_bool_t
304	pixman_f_transform_bounds (const struct pixman_f_transform t, struct pixman_box16 b);
305
306	void
307	pixman_f_transform_init_identity (struct pixman_f_transform *t);
308
309	/* Don't blame me, blame XRender */
310	typedef enum
311	{
312	PIXMAN_REPEAT_NONE,
313	PIXMAN_REPEAT_NORMAL,
314	PIXMAN_REPEAT_PAD,
315	PIXMAN_REPEAT_REFLECT
316	} pixman_repeat_t;
317
318	typedef enum
319	{
320	PIXMAN_FILTER_FAST,
321	PIXMAN_FILTER_GOOD,
322	PIXMAN_FILTER_BEST,
323	PIXMAN_FILTER_NEAREST,
324	PIXMAN_FILTER_BILINEAR,
325	PIXMAN_FILTER_CONVOLUTION
326	} pixman_filter_t;
327
328	typedef enum
329	{
330	PIXMAN_OP_CLEAR = 0x00,
331	PIXMAN_OP_SRC = 0x01,
332	PIXMAN_OP_DST = 0x02,
333	PIXMAN_OP_OVER = 0x03,
334	PIXMAN_OP_OVER_REVERSE = 0x04,
335	PIXMAN_OP_IN = 0x05,
336	PIXMAN_OP_IN_REVERSE = 0x06,
337	PIXMAN_OP_OUT = 0x07,
338	PIXMAN_OP_OUT_REVERSE = 0x08,
339	PIXMAN_OP_ATOP = 0x09,
340	PIXMAN_OP_ATOP_REVERSE = 0x0a,
341	PIXMAN_OP_XOR = 0x0b,
342	PIXMAN_OP_ADD = 0x0c,
343	PIXMAN_OP_SATURATE = 0x0d,
344
345	PIXMAN_OP_DISJOINT_CLEAR = 0x10,
346	PIXMAN_OP_DISJOINT_SRC = 0x11,
347	PIXMAN_OP_DISJOINT_DST = 0x12,
348	PIXMAN_OP_DISJOINT_OVER = 0x13,
349	PIXMAN_OP_DISJOINT_OVER_REVERSE = 0x14,
350	PIXMAN_OP_DISJOINT_IN = 0x15,
351	PIXMAN_OP_DISJOINT_IN_REVERSE = 0x16,
352	PIXMAN_OP_DISJOINT_OUT = 0x17,
353	PIXMAN_OP_DISJOINT_OUT_REVERSE = 0x18,
354	PIXMAN_OP_DISJOINT_ATOP = 0x19,
355	PIXMAN_OP_DISJOINT_ATOP_REVERSE = 0x1a,
356	PIXMAN_OP_DISJOINT_XOR = 0x1b,
357
358	PIXMAN_OP_CONJOINT_CLEAR = 0x20,
359	PIXMAN_OP_CONJOINT_SRC = 0x21,
360	PIXMAN_OP_CONJOINT_DST = 0x22,
361	PIXMAN_OP_CONJOINT_OVER = 0x23,
362	PIXMAN_OP_CONJOINT_OVER_REVERSE = 0x24,
363	PIXMAN_OP_CONJOINT_IN = 0x25,
364	PIXMAN_OP_CONJOINT_IN_REVERSE = 0x26,
365	PIXMAN_OP_CONJOINT_OUT = 0x27,
366	PIXMAN_OP_CONJOINT_OUT_REVERSE = 0x28,
367	PIXMAN_OP_CONJOINT_ATOP = 0x29,
368	PIXMAN_OP_CONJOINT_ATOP_REVERSE = 0x2a,
369	PIXMAN_OP_CONJOINT_XOR = 0x2b,
370
371	PIXMAN_OP_NONE
372	} pixman_op_t;
373
374	/*
375	* Regions
376	*/
377	typedef struct pixman_region16_data pixman_region16_data_t;
378	typedef struct pixman_box16 pixman_box16_t;
379	typedef struct pixman_rectangle16 pixman_rectangle16_t;
380	typedef struct pixman_region16 pixman_region16_t;
381
382	struct pixman_region16_data {
383	long size;
384	long numRects;
385	/* pixman_box16_t rects[size]; in memory but not explicitly declared */
386	};
387
388	struct pixman_rectangle16
389	{
390	int16_t x, y;
391	uint16_t width, height;
392	};
393
394	struct pixman_box16
395	{
396	int16_t x1, y1, x2, y2;
397	};
398
399	struct pixman_region16
400	{
401	pixman_box16_t extents;
402	pixman_region16_data_t *data;
403	};
404
405	typedef enum
406	{
407	PIXMAN_REGION_OUT,
408	PIXMAN_REGION_IN,
409	PIXMAN_REGION_PART
410	} pixman_region_overlap_t;
411
412	/* This function exists only to make it possible to preserve the X ABI - it should
413	* go away at first opportunity.
414	*/
415	void pixman_region_set_static_pointers (pixman_box16_t *empty_box,
416	pixman_region16_data_t *empty_data,
417	pixman_region16_data_t *broken_data);
418
419
420	/* creation/destruction */
421	void pixman_region_init (pixman_region16_t *region);
422	void pixman_region_init_rect (pixman_region16_t *region,
423	int x,
424	int y,
425	unsigned int width,
426	unsigned int height);
427	pixman_bool_t pixman_region_init_rects (pixman_region16_t *region,
428	pixman_box16_t *boxes,
429	int count);
430	void pixman_region_init_with_extents (pixman_region16_t *region,
431	pixman_box16_t *extents);
432	void pixman_region_fini (pixman_region16_t *region);
433
434
435	/* manipulation */
436	void pixman_region_translate (pixman_region16_t *region,
437	int x,
438	int y);
439	pixman_bool_t pixman_region_copy (pixman_region16_t *dest,
440	pixman_region16_t *source);
441	pixman_bool_t pixman_region_intersect (pixman_region16_t *newReg,
442	pixman_region16_t *reg1,
443	pixman_region16_t *reg2);
444	pixman_bool_t pixman_region_union (pixman_region16_t *newReg,
445	pixman_region16_t *reg1,
446	pixman_region16_t *reg2);
447	pixman_bool_t pixman_region_union_rect (pixman_region16_t *dest,
448	pixman_region16_t *source,
449	int x,
450	int y,
451	unsigned int width,
452	unsigned int height);
453	pixman_bool_t pixman_region_subtract (pixman_region16_t *regD,
454	pixman_region16_t *regM,
455	pixman_region16_t *regS);
456	pixman_bool_t pixman_region_inverse (pixman_region16_t *newReg,
457	pixman_region16_t *reg1,
458	pixman_box16_t *invRect);
459	pixman_bool_t pixman_region_contains_point (pixman_region16_t *region,
460	int x,
461	int y,
462	pixman_box16_t *box);
463	pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *pixman_region16_t,
464	pixman_box16_t *prect);
465	pixman_bool_t pixman_region_not_empty (pixman_region16_t *region);
466	pixman_box16_t * pixman_region_extents (pixman_region16_t *region);
467	int pixman_region_n_rects (pixman_region16_t *region);
468	pixman_box16_t * pixman_region_rectangles (pixman_region16_t *region,
469	int *n_rects);
470	pixman_bool_t pixman_region_equal (pixman_region16_t *region1,
471	pixman_region16_t *region2);
472	pixman_bool_t pixman_region_selfcheck (pixman_region16_t *region);
473	void pixman_region_reset (pixman_region16_t *region,
474	pixman_box16_t *box);
475
476	/*
477	* 32 bit regions
478	*/
479	typedef struct pixman_region32_data pixman_region32_data_t;
480	typedef struct pixman_box32 pixman_box32_t;
481	typedef struct pixman_rectangle32 pixman_rectangle32_t;
482	typedef struct pixman_region32 pixman_region32_t;
483
484	struct pixman_region32_data {
485	long size;
486	long numRects;
487	/* pixman_box32_t rects[size]; in memory but not explicitly declared */
488	};
489
490	struct pixman_rectangle32
491	{
492	int32_t x, y;
493	uint32_t width, height;
494	};
495
496	struct pixman_box32
497	{
498	int32_t x1, y1, x2, y2;
499	};
500
501	struct pixman_region32
502	{
503	pixman_box32_t extents;
504	pixman_region32_data_t *data;
505	};
506
507	/* creation/destruction */
508	void pixman_region32_init (pixman_region32_t *region);
509	void pixman_region32_init_rect (pixman_region32_t *region,
510	int x,
511	int y,
512	unsigned int width,
513	unsigned int height);
514	pixman_bool_t pixman_region32_init_rects (pixman_region32_t *region,
515	pixman_box32_t *boxes,
516	int count);
517	void pixman_region32_init_with_extents (pixman_region32_t *region,
518	pixman_box32_t *extents);
519	void pixman_region32_fini (pixman_region32_t *region);
520
521
522	/* manipulation */
523	void pixman_region32_translate (pixman_region32_t *region,
524	int x,
525	int y);
526	pixman_bool_t pixman_region32_copy (pixman_region32_t *dest,
527	pixman_region32_t *source);
528	pixman_bool_t pixman_region32_intersect (pixman_region32_t *newReg,
529	pixman_region32_t *reg1,
530	pixman_region32_t *reg2);
531	pixman_bool_t pixman_region32_union (pixman_region32_t *newReg,
532	pixman_region32_t *reg1,
533	pixman_region32_t *reg2);
534	pixman_bool_t pixman_region32_union_rect (pixman_region32_t *dest,
535	pixman_region32_t *source,
536	int x,
537	int y,
538	unsigned int width,
539	unsigned int height);
540	pixman_bool_t pixman_region32_subtract (pixman_region32_t *regD,
541	pixman_region32_t *regM,
542	pixman_region32_t *regS);
543	pixman_bool_t pixman_region32_inverse (pixman_region32_t *newReg,
544	pixman_region32_t *reg1,
545	pixman_box32_t *invRect);
546	pixman_bool_t pixman_region32_contains_point (pixman_region32_t *region,
547	int x,
548	int y,
549	pixman_box32_t *box);
550	pixman_region_overlap_t pixman_region32_contains_rectangle (pixman_region32_t *region,
551	pixman_box32_t *prect);
552	pixman_bool_t pixman_region32_not_empty (pixman_region32_t *region);
553	pixman_box32_t * pixman_region32_extents (pixman_region32_t *region);
554	int pixman_region32_n_rects (pixman_region32_t *region);
555	pixman_box32_t * pixman_region32_rectangles (pixman_region32_t *region,
556	int *n_rects);
557	pixman_bool_t pixman_region32_equal (pixman_region32_t *region1,
558	pixman_region32_t *region2);
559	pixman_bool_t pixman_region32_selfcheck (pixman_region32_t *region);
560	void pixman_region32_reset (pixman_region32_t *region,
561	pixman_box32_t *box);
562
563
564	/* Copy / Fill / Misc */
565	pixman_bool_t pixman_blt (uint32_t *src_bits,
566	uint32_t *dst_bits,
567	int src_stride,
568	int dst_stride,
569	int src_bpp,
570	int dst_bpp,
571	int src_x,
572	int src_y,
573	int dst_x,
574	int dst_y,
575	int width,
576	int height);
577	pixman_bool_t pixman_fill (uint32_t *bits,
578	int stride,
579	int bpp,
580	int x,
581	int y,
582	int width,
583	int height,
584	uint32_t _xor);
585
586	int pixman_version (void);
587	const char* pixman_version_string (void);
588
589	/*
590	* Images
591	*/
592	typedef union pixman_image pixman_image_t;
593	typedef struct pixman_indexed pixman_indexed_t;
594	typedef struct pixman_gradient_stop pixman_gradient_stop_t;
595
596	typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
597	typedef void (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
598
599	struct pixman_gradient_stop {
600	pixman_fixed_t x;
601	pixman_color_t color;
602	};
603
604	#define PIXMAN_MAX_INDEXED 256 /* XXX depth must be <= 8 */
605
606	#if PIXMAN_MAX_INDEXED <= 256
607	typedef uint8_t pixman_index_type;
608	#endif
609
610	struct pixman_indexed
611	{
612	pixman_bool_t color;
613	uint32_t rgba[PIXMAN_MAX_INDEXED];
614	pixman_index_type ent[32768];
615	};
616
617	/*
618	* While the protocol is generous in format support, the
619	* sample implementation allows only packed RGB and GBR
620	* representations for data to simplify software rendering,
621	*/
622	#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) \| \
623	((type) << 16) \| \
624	((a) << 12) \| \
625	((r) << 8) \| \
626	((g) << 4) \| \
627	((b)))
628
629	#define PIXMAN_FORMAT_BPP(f) (((f) >> 24) )
630	#define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0xff)
631	#define PIXMAN_FORMAT_A(f) (((f) >> 12) & 0x0f)
632	#define PIXMAN_FORMAT_R(f) (((f) >> 8) & 0x0f)
633	#define PIXMAN_FORMAT_G(f) (((f) >> 4) & 0x0f)
634	#define PIXMAN_FORMAT_B(f) (((f) ) & 0x0f)
635	#define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff)
636	#define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff)
637	#define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \
638	PIXMAN_FORMAT_R(f) + \
639	PIXMAN_FORMAT_G(f) + \
640	PIXMAN_FORMAT_B(f))
641
642	#define PIXMAN_TYPE_OTHER 0
643	#define PIXMAN_TYPE_A 1
644	#define PIXMAN_TYPE_ARGB 2
645	#define PIXMAN_TYPE_ABGR 3
646	#define PIXMAN_TYPE_COLOR 4
647	#define PIXMAN_TYPE_GRAY 5
648	#define PIXMAN_TYPE_YUY2 6
649	#define PIXMAN_TYPE_YV12 7
650
651	#define PIXMAN_FORMAT_COLOR(f) (PIXMAN_FORMAT_TYPE(f) & 2)
652
653	/* 32bpp formats */
654	typedef enum {
655	PIXMAN_a8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8),
656	PIXMAN_x8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8),
657	PIXMAN_a8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8),
658	PIXMAN_x8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,8,8,8),
659	PIXMAN_x2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,10,10,10),
660	PIXMAN_a2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,2,10,10,10),
661
662	/* 24bpp formats */
663	PIXMAN_r8g8b8 = PIXMAN_FORMAT(24,PIXMAN_TYPE_ARGB,0,8,8,8),
664	PIXMAN_b8g8r8 = PIXMAN_FORMAT(24,PIXMAN_TYPE_ABGR,0,8,8,8),
665
666	/* 16bpp formats */
667	PIXMAN_r5g6b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,6,5),
668	PIXMAN_b5g6r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,6,5),
669
670	PIXMAN_a1r5g5b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,1,5,5,5),
671	PIXMAN_x1r5g5b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,5,5),
672	PIXMAN_a1b5g5r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,1,5,5,5),
673	PIXMAN_x1b5g5r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,5,5),
674	PIXMAN_a4r4g4b4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,4,4,4,4),
675	PIXMAN_x4r4g4b4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,4,4,4),
676	PIXMAN_a4b4g4r4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,4,4,4,4),
677	PIXMAN_x4b4g4r4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,4,4,4),
678
679	/* 8bpp formats */
680	PIXMAN_a8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_A,8,0,0,0),
681	PIXMAN_r3g3b2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,0,3,3,2),
682	PIXMAN_b2g3r3 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,0,3,3,2),
683	PIXMAN_a2r2g2b2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,2,2,2,2),
684	PIXMAN_a2b2g2r2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,2,2,2,2),
685
686	PIXMAN_c8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
687	PIXMAN_g8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
688
689	PIXMAN_x4a4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_A,4,0,0,0),
690
691	PIXMAN_x4c4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
692	PIXMAN_x4g4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
693
694	/* 4bpp formats */
695	PIXMAN_a4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_A,4,0,0,0),
696	PIXMAN_r1g2b1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,0,1,2,1),
697	PIXMAN_b1g2r1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,0,1,2,1),
698	PIXMAN_a1r1g1b1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,1,1,1,1),
699	PIXMAN_a1b1g1r1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,1,1,1,1),
700
701	PIXMAN_c4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_COLOR,0,0,0,0),
702	PIXMAN_g4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_GRAY,0,0,0,0),
703
704	/* 1bpp formats */
705	PIXMAN_a1 = PIXMAN_FORMAT(1,PIXMAN_TYPE_A,1,0,0,0),
706
707	PIXMAN_g1 = PIXMAN_FORMAT(1,PIXMAN_TYPE_GRAY,0,0,0,0),
708
709	/* YUV formats */
710	PIXMAN_yuy2 = PIXMAN_FORMAT(16,PIXMAN_TYPE_YUY2,0,0,0,0),
711	PIXMAN_yv12 = PIXMAN_FORMAT(12,PIXMAN_TYPE_YV12,0,0,0,0)
712	} pixman_format_code_t;
713
714	/* Querying supported format values. */
715	pixman_bool_t pixman_format_supported_destination (pixman_format_code_t format);
716	pixman_bool_t pixman_format_supported_source (pixman_format_code_t format);
717
718	/* Constructors */
719	pixman_image_t pixman_image_create_solid_fill (pixman_color_t color);
720	pixman_image_t pixman_image_create_linear_gradient (pixman_point_fixed_t p1,
721	pixman_point_fixed_t *p2,
722	const pixman_gradient_stop_t *stops,
723	int n_stops);
724	pixman_image_t pixman_image_create_radial_gradient (pixman_point_fixed_t inner,
725	pixman_point_fixed_t *outer,
726	pixman_fixed_t inner_radius,
727	pixman_fixed_t outer_radius,
728	const pixman_gradient_stop_t *stops,
729	int n_stops);
730	pixman_image_t pixman_image_create_conical_gradient (pixman_point_fixed_t center,
731	pixman_fixed_t angle,
732	const pixman_gradient_stop_t *stops,
733	int n_stops);
734	pixman_image_t *pixman_image_create_bits (pixman_format_code_t format,
735	int width,
736	int height,
737	uint32_t *bits,
738	int rowstride_bytes);
739
740	/* Destructor */
741	pixman_image_t pixman_image_ref (pixman_image_t image);
742	pixman_bool_t pixman_image_unref (pixman_image_t *image);
743
744
745	/* Set properties */
746	pixman_bool_t pixman_image_set_clip_region (pixman_image_t *image,
747	pixman_region16_t *region);
748	pixman_bool_t pixman_image_set_clip_region32 (pixman_image_t *image,
749	pixman_region32_t *region);
750	void pixman_image_set_has_client_clip (pixman_image_t *image,
751	pixman_bool_t clien_clip);
752	pixman_bool_t pixman_image_set_transform (pixman_image_t *image,
753	const pixman_transform_t *transform);
754	void pixman_image_set_repeat (pixman_image_t *image,
755	pixman_repeat_t repeat);
756	pixman_bool_t pixman_image_set_filter (pixman_image_t *image,
757	pixman_filter_t filter,
758	const pixman_fixed_t *filter_params,
759	int n_filter_params);
760	void pixman_image_set_source_clipping (pixman_image_t *image,
761	pixman_bool_t source_clipping);
762	void pixman_image_set_alpha_map (pixman_image_t *image,
763	pixman_image_t *alpha_map,
764	int16_t x,
765	int16_t y);
766	void pixman_image_set_component_alpha (pixman_image_t *image,
767	pixman_bool_t component_alpha);
768	void pixman_image_set_accessors (pixman_image_t *image,
769	pixman_read_memory_func_t read_func,
770	pixman_write_memory_func_t write_func);
771	void pixman_image_set_indexed (pixman_image_t *image,
772	const pixman_indexed_t *indexed);
773	uint32_t pixman_image_get_data (pixman_image_t image);
774	int pixman_image_get_width (pixman_image_t *image);
775	int pixman_image_get_height (pixman_image_t *image);
776	int pixman_image_get_stride (pixman_image_t *image);
777	int pixman_image_get_depth (pixman_image_t *image);
778	pixman_bool_t pixman_image_fill_rectangles (pixman_op_t op,
779	pixman_image_t *image,
780	pixman_color_t *color,
781	int n_rects,
782	const pixman_rectangle16_t *rects);
783
784	/* Composite */
785	pixman_bool_t pixman_compute_composite_region (pixman_region16_t *pRegion,
786	pixman_image_t *pSrc,
787	pixman_image_t *pMask,
788	pixman_image_t *pDst,
789	int16_t xSrc,
790	int16_t ySrc,
791	int16_t xMask,
792	int16_t yMask,
793	int16_t xDst,
794	int16_t yDst,
795	uint16_t width,
796	uint16_t height);
797	void pixman_image_composite (pixman_op_t op,
798	pixman_image_t *src,
799	pixman_image_t *mask,
800	pixman_image_t *dest,
801	int16_t src_x,
802	int16_t src_y,
803	int16_t mask_x,
804	int16_t mask_y,
805	int16_t dest_x,
806	int16_t dest_y,
807	uint16_t width,
808	uint16_t height);
809
810	/*
811	* Trapezoids
812	*/
813	typedef struct pixman_edge pixman_edge_t;
814	typedef struct pixman_trapezoid pixman_trapezoid_t;
815	typedef struct pixman_trap pixman_trap_t;
816	typedef struct pixman_span_fix pixman_span_fix_t;
817
818	/*
819	* An edge structure. This represents a single polygon edge
820	* and can be quickly stepped across small or large gaps in the
821	* sample grid
822	*/
823	struct pixman_edge
824	{
825	pixman_fixed_t x;
826	pixman_fixed_t e;
827	pixman_fixed_t stepx;
828	pixman_fixed_t signdx;
829	pixman_fixed_t dy;
830	pixman_fixed_t dx;
831
832	pixman_fixed_t stepx_small;
833	pixman_fixed_t stepx_big;
834	pixman_fixed_t dx_small;
835	pixman_fixed_t dx_big;
836	};
837
838	struct pixman_trapezoid
839	{
840	pixman_fixed_t top, bottom;
841	pixman_line_fixed_t left, right;
842	};
843
844
845	/* whether 't' is a well defined not obviously empty trapezoid */
846	#define pixman_trapezoid_valid(t) \
847	((t)->left.p1.y != (t)->left.p2.y && \
848	(t)->right.p1.y != (t)->right.p2.y && \
849	(int) ((t)->bottom - (t)->top) > 0)
850
851	struct pixman_span_fix
852	{
853	pixman_fixed_t l, r, y;
854	};
855
856	struct pixman_trap
857	{
858	pixman_span_fix_t top, bot;
859	};
860
861	pixman_fixed_t pixman_sample_ceil_y (pixman_fixed_t y,
862	int bpp);
863	pixman_fixed_t pixman_sample_floor_y (pixman_fixed_t y,
864	int bpp);
865	void pixman_edge_step (pixman_edge_t *e,
866	int n);
867	void pixman_edge_init (pixman_edge_t *e,
868	int bpp,
869	pixman_fixed_t y_start,
870	pixman_fixed_t x_top,
871	pixman_fixed_t y_top,
872	pixman_fixed_t x_bot,
873	pixman_fixed_t y_bot);
874	void pixman_line_fixed_edge_init (pixman_edge_t *e,
875	int bpp,
876	pixman_fixed_t y,
877	const pixman_line_fixed_t *line,
878	int x_off,
879	int y_off);
880	void pixman_rasterize_edges (pixman_image_t *image,
881	pixman_edge_t *l,
882	pixman_edge_t *r,
883	pixman_fixed_t t,
884	pixman_fixed_t b);
885	void pixman_add_traps (pixman_image_t *image,
886	int16_t x_off,
887	int16_t y_off,
888	int ntrap,
889	pixman_trap_t *traps);
890	void pixman_add_trapezoids (pixman_image_t *image,
891	int16_t x_off,
892	int y_off,
893	int ntraps,
894	const pixman_trapezoid_t *traps);
895	void pixman_rasterize_trapezoid (pixman_image_t *image,
896	const pixman_trapezoid_t *trap,
897	int x_off,
898	int y_off);
899
900
901	#endif /* PIXMAN_H__ */

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

source: vbox/trunk/src/VBox/Additions/x11/x11include/1.6/pixman.h@ 43030

Download in other formats: