WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/pixman/pixman.h

Rev	Author	Line No.	Line
4349	Serge	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
		73
		74	#ifdef __cplusplus
		75	#define PIXMAN_BEGIN_DECLS extern "C" {
		76	#define PIXMAN_END_DECLS }
		77	#else
		78	#define PIXMAN_BEGIN_DECLS
		79	#define PIXMAN_END_DECLS
		80	#endif
		81
		82	PIXMAN_BEGIN_DECLS
		83
		84	/*
		85	* Standard integers
		86	*/
		87
		88	#if !defined (PIXMAN_DONT_DEFINE_STDINT)
		89
		90	#if defined (_SVR4) \|\| defined (SVR4) \|\| defined (__OpenBSD__) \|\| defined (_sgi) \|\| defined (__sun) \|\| defined (sun) \|\| defined (__digital__) \|\| defined (__HP_cc)
		91	# include
		92	/* VS 2010 (_MSC_VER 1600) has stdint.h */
		93	#elif defined (_MSC_VER) && _MSC_VER < 1600
		94	typedef __int8 int8_t;
		95	typedef unsigned __int8 uint8_t;
		96	typedef __int16 int16_t;
		97	typedef unsigned __int16 uint16_t;
		98	typedef __int32 int32_t;
		99	typedef unsigned __int32 uint32_t;
		100	typedef __int64 int64_t;
		101	typedef unsigned __int64 uint64_t;
		102	#elif defined (_AIX)
		103	# include
		104	#else
		105	# include
		106	#endif
		107
		108	#endif
		109
		110	/*
		111	* Boolean
		112	*/
		113	typedef int pixman_bool_t;
		114
		115	/*
		116	* Fixpoint numbers
		117	*/
		118	typedef int64_t pixman_fixed_32_32_t;
		119	typedef pixman_fixed_32_32_t pixman_fixed_48_16_t;
		120	typedef uint32_t pixman_fixed_1_31_t;
		121	typedef uint32_t pixman_fixed_1_16_t;
		122	typedef int32_t pixman_fixed_16_16_t;
		123	typedef pixman_fixed_16_16_t pixman_fixed_t;
		124
		125	#define pixman_fixed_e ((pixman_fixed_t) 1)
		126	#define pixman_fixed_1 (pixman_int_to_fixed(1))
		127	#define pixman_fixed_1_minus_e (pixman_fixed_1 - pixman_fixed_e)
		128	#define pixman_fixed_minus_1 (pixman_int_to_fixed(-1))
		129	#define pixman_fixed_to_int(f) ((int) ((f) >> 16))
		130	#define pixman_int_to_fixed(i) ((pixman_fixed_t) ((i) << 16))
		131	#define pixman_fixed_to_double(f) (double) ((f) / (double) pixman_fixed_1)
		132	#define pixman_double_to_fixed(d) ((pixman_fixed_t) ((d) * 65536.0))
		133	#define pixman_fixed_frac(f) ((f) & pixman_fixed_1_minus_e)
		134	#define pixman_fixed_floor(f) ((f) & ~pixman_fixed_1_minus_e)
		135	#define pixman_fixed_ceil(f) pixman_fixed_floor ((f) + pixman_fixed_1_minus_e)
		136	#define pixman_fixed_fraction(f) ((f) & pixman_fixed_1_minus_e)
		137	#define pixman_fixed_mod_2(f) ((f) & (pixman_fixed1 \| pixman_fixed_1_minus_e))
		138	#define pixman_max_fixed_48_16 ((pixman_fixed_48_16_t) 0x7fffffff)
		139	#define pixman_min_fixed_48_16 (-((pixman_fixed_48_16_t) 1 << 31))
		140
		141	/*
		142	* Misc structs
		143	*/
		144	typedef struct pixman_color pixman_color_t;
		145	typedef struct pixman_point_fixed pixman_point_fixed_t;
		146	typedef struct pixman_line_fixed pixman_line_fixed_t;
		147	typedef struct pixman_vector pixman_vector_t;
		148	typedef struct pixman_transform pixman_transform_t;
		149
		150	struct pixman_color
		151	{
		152	uint16_t red;
		153	uint16_t green;
		154	uint16_t blue;
		155	uint16_t alpha;
		156	};
		157
		158	struct pixman_point_fixed
		159	{
		160	pixman_fixed_t x;
		161	pixman_fixed_t y;
		162	};
		163
		164	struct pixman_line_fixed
		165	{
		166	pixman_point_fixed_t p1, p2;
		167	};
		168
		169	/*
		170	* Fixed point matrices
		171	*/
		172
		173	struct pixman_vector
		174	{
		175	pixman_fixed_t vector[3];
		176	};
		177
		178	struct pixman_transform
		179	{
		180	pixman_fixed_t matrix[3][3];
		181	};
		182
		183	/* forward declaration (sorry) */
		184	struct pixman_box16;
		185	typedef union pixman_image pixman_image_t;
		186
		187	void pixman_transform_init_identity (struct pixman_transform *matrix);
		188	pixman_bool_t pixman_transform_point_3d (const struct pixman_transform *transform,
		189	struct pixman_vector *vector);
		190	pixman_bool_t pixman_transform_point (const struct pixman_transform *transform,
		191	struct pixman_vector *vector);
		192	pixman_bool_t pixman_transform_multiply (struct pixman_transform *dst,
		193	const struct pixman_transform *l,
		194	const struct pixman_transform *r);
		195	void pixman_transform_init_scale (struct pixman_transform *t,
		196	pixman_fixed_t sx,
		197	pixman_fixed_t sy);
		198	pixman_bool_t pixman_transform_scale (struct pixman_transform *forward,
		199	struct pixman_transform *reverse,
		200	pixman_fixed_t sx,
		201	pixman_fixed_t sy);
		202	void pixman_transform_init_rotate (struct pixman_transform *t,
		203	pixman_fixed_t cos,
		204	pixman_fixed_t sin);
		205	pixman_bool_t pixman_transform_rotate (struct pixman_transform *forward,
		206	struct pixman_transform *reverse,
		207	pixman_fixed_t c,
		208	pixman_fixed_t s);
		209	void pixman_transform_init_translate (struct pixman_transform *t,
		210	pixman_fixed_t tx,
		211	pixman_fixed_t ty);
		212	pixman_bool_t pixman_transform_translate (struct pixman_transform *forward,
		213	struct pixman_transform *reverse,
		214	pixman_fixed_t tx,
		215	pixman_fixed_t ty);
		216	pixman_bool_t pixman_transform_bounds (const struct pixman_transform *matrix,
		217	struct pixman_box16 *b);
		218	pixman_bool_t pixman_transform_invert (struct pixman_transform *dst,
		219	const struct pixman_transform *src);
		220	pixman_bool_t pixman_transform_is_identity (const struct pixman_transform *t);
		221	pixman_bool_t pixman_transform_is_scale (const struct pixman_transform *t);
		222	pixman_bool_t pixman_transform_is_int_translate (const struct pixman_transform *t);
		223	pixman_bool_t pixman_transform_is_inverse (const struct pixman_transform *a,
		224	const struct pixman_transform *b);
		225
		226	/*
		227	* Floating point matrices
		228	*/
		229	typedef struct pixman_f_transform pixman_f_transform_t;
		230	typedef struct pixman_f_vector pixman_f_vector_t;
		231
		232	struct pixman_f_vector
		233	{
		234	double v[3];
		235	};
		236
		237	struct pixman_f_transform
		238	{
		239	double m[3][3];
		240	};
		241
		242	pixman_bool_t pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
		243	const struct pixman_f_transform *ft);
		244	void pixman_f_transform_from_pixman_transform (struct pixman_f_transform *ft,
		245	const struct pixman_transform *t);
		246	pixman_bool_t pixman_f_transform_invert (struct pixman_f_transform *dst,
		247	const struct pixman_f_transform *src);
		248	pixman_bool_t pixman_f_transform_point (const struct pixman_f_transform *t,
		249	struct pixman_f_vector *v);
		250	void pixman_f_transform_point_3d (const struct pixman_f_transform *t,
		251	struct pixman_f_vector *v);
		252	void pixman_f_transform_multiply (struct pixman_f_transform *dst,
		253	const struct pixman_f_transform *l,
		254	const struct pixman_f_transform *r);
		255	void pixman_f_transform_init_scale (struct pixman_f_transform *t,
		256	double sx,
		257	double sy);
		258	pixman_bool_t pixman_f_transform_scale (struct pixman_f_transform *forward,
		259	struct pixman_f_transform *reverse,
		260	double sx,
		261	double sy);
		262	void pixman_f_transform_init_rotate (struct pixman_f_transform *t,
		263	double cos,
		264	double sin);
		265	pixman_bool_t pixman_f_transform_rotate (struct pixman_f_transform *forward,
		266	struct pixman_f_transform *reverse,
		267	double c,
		268	double s);
		269	void pixman_f_transform_init_translate (struct pixman_f_transform *t,
		270	double tx,
		271	double ty);
		272	pixman_bool_t pixman_f_transform_translate (struct pixman_f_transform *forward,
		273	struct pixman_f_transform *reverse,
		274	double tx,
		275	double ty);
		276	pixman_bool_t pixman_f_transform_bounds (const struct pixman_f_transform *t,
		277	struct pixman_box16 *b);
		278	void pixman_f_transform_init_identity (struct pixman_f_transform *t);
		279
		280	typedef enum
		281	{
		282	PIXMAN_REPEAT_NONE,
		283	PIXMAN_REPEAT_NORMAL,
		284	PIXMAN_REPEAT_PAD,
		285	PIXMAN_REPEAT_REFLECT
		286	} pixman_repeat_t;
		287
		288	typedef enum
		289	{
		290	PIXMAN_FILTER_FAST,
		291	PIXMAN_FILTER_GOOD,
		292	PIXMAN_FILTER_BEST,
		293	PIXMAN_FILTER_NEAREST,
		294	PIXMAN_FILTER_BILINEAR,
		295	PIXMAN_FILTER_CONVOLUTION,
		296
		297	/* The SEPARABLE_CONVOLUTION filter takes the following parameters:
		298	*
		299	* width: integer given as 16.16 fixpoint number
		300	* height: integer given as 16.16 fixpoint number
		301	* x_phase_bits: integer given as 16.16 fixpoint
		302	* y_phase_bits: integer given as 16.16 fixpoint
		303	* xtables: (1 << x_phase_bits) tables of size width
		304	* ytables: (1 << y_phase_bits) tables of size height
		305	*
		306	* When sampling at (x, y), the location is first rounded to one of
		307	* n_x_phases * n_y_phases subpixel positions. These subpixel positions
		308	* determine an xtable and a ytable to use.
		309	*
		310	* Conceptually a width x height matrix is then formed in which each entry
		311	* is the product of the corresponding entries in the x and y tables.
		312	* This matrix is then aligned with the image pixels such that its center
		313	* is as close as possible to the subpixel location chosen earlier. Then
		314	* the image is convolved with the matrix and the resulting pixel returned.
		315	*/
		316	PIXMAN_FILTER_SEPARABLE_CONVOLUTION
		317	} pixman_filter_t;
		318
		319	typedef enum
		320	{
		321	PIXMAN_OP_CLEAR = 0x00,
		322	PIXMAN_OP_SRC = 0x01,
		323	PIXMAN_OP_DST = 0x02,
		324	PIXMAN_OP_OVER = 0x03,
		325	PIXMAN_OP_OVER_REVERSE = 0x04,
		326	PIXMAN_OP_IN = 0x05,
		327	PIXMAN_OP_IN_REVERSE = 0x06,
		328	PIXMAN_OP_OUT = 0x07,
		329	PIXMAN_OP_OUT_REVERSE = 0x08,
		330	PIXMAN_OP_ATOP = 0x09,
		331	PIXMAN_OP_ATOP_REVERSE = 0x0a,
		332	PIXMAN_OP_XOR = 0x0b,
		333	PIXMAN_OP_ADD = 0x0c,
		334	PIXMAN_OP_SATURATE = 0x0d,
		335
		336	PIXMAN_OP_DISJOINT_CLEAR = 0x10,
		337	PIXMAN_OP_DISJOINT_SRC = 0x11,
		338	PIXMAN_OP_DISJOINT_DST = 0x12,
		339	PIXMAN_OP_DISJOINT_OVER = 0x13,
		340	PIXMAN_OP_DISJOINT_OVER_REVERSE = 0x14,
		341	PIXMAN_OP_DISJOINT_IN = 0x15,
		342	PIXMAN_OP_DISJOINT_IN_REVERSE = 0x16,
		343	PIXMAN_OP_DISJOINT_OUT = 0x17,
		344	PIXMAN_OP_DISJOINT_OUT_REVERSE = 0x18,
		345	PIXMAN_OP_DISJOINT_ATOP = 0x19,
		346	PIXMAN_OP_DISJOINT_ATOP_REVERSE = 0x1a,
		347	PIXMAN_OP_DISJOINT_XOR = 0x1b,
		348
		349	PIXMAN_OP_CONJOINT_CLEAR = 0x20,
		350	PIXMAN_OP_CONJOINT_SRC = 0x21,
		351	PIXMAN_OP_CONJOINT_DST = 0x22,
		352	PIXMAN_OP_CONJOINT_OVER = 0x23,
		353	PIXMAN_OP_CONJOINT_OVER_REVERSE = 0x24,
		354	PIXMAN_OP_CONJOINT_IN = 0x25,
		355	PIXMAN_OP_CONJOINT_IN_REVERSE = 0x26,
		356	PIXMAN_OP_CONJOINT_OUT = 0x27,
		357	PIXMAN_OP_CONJOINT_OUT_REVERSE = 0x28,
		358	PIXMAN_OP_CONJOINT_ATOP = 0x29,
		359	PIXMAN_OP_CONJOINT_ATOP_REVERSE = 0x2a,
		360	PIXMAN_OP_CONJOINT_XOR = 0x2b,
		361
		362	PIXMAN_OP_MULTIPLY = 0x30,
		363	PIXMAN_OP_SCREEN = 0x31,
		364	PIXMAN_OP_OVERLAY = 0x32,
		365	PIXMAN_OP_DARKEN = 0x33,
		366	PIXMAN_OP_LIGHTEN = 0x34,
		367	PIXMAN_OP_COLOR_DODGE = 0x35,
		368	PIXMAN_OP_COLOR_BURN = 0x36,
		369	PIXMAN_OP_HARD_LIGHT = 0x37,
		370	PIXMAN_OP_SOFT_LIGHT = 0x38,
		371	PIXMAN_OP_DIFFERENCE = 0x39,
		372	PIXMAN_OP_EXCLUSION = 0x3a,
		373	PIXMAN_OP_HSL_HUE = 0x3b,
		374	PIXMAN_OP_HSL_SATURATION = 0x3c,
		375	PIXMAN_OP_HSL_COLOR = 0x3d,
		376	PIXMAN_OP_HSL_LUMINOSITY = 0x3e
		377
		378	#ifdef PIXMAN_USE_INTERNAL_API
		379	,
		380	PIXMAN_N_OPERATORS,
		381	PIXMAN_OP_NONE = PIXMAN_N_OPERATORS
		382	#endif
		383	} pixman_op_t;
		384
		385	/*
		386	* Regions
		387	*/
		388	typedef struct pixman_region16_data pixman_region16_data_t;
		389	typedef struct pixman_box16 pixman_box16_t;
		390	typedef struct pixman_rectangle16 pixman_rectangle16_t;
		391	typedef struct pixman_region16 pixman_region16_t;
		392
		393	struct pixman_region16_data {
		394	long size;
		395	long numRects;
		396	/* pixman_box16_t rects[size]; in memory but not explicitly declared */
		397	};
		398
		399	struct pixman_rectangle16
		400	{
		401	int16_t x, y;
		402	uint16_t width, height;
		403	};
		404
		405	struct pixman_box16
		406	{
		407	int16_t x1, y1, x2, y2;
		408	};
		409
		410	struct pixman_region16
		411	{
		412	pixman_box16_t extents;
		413	pixman_region16_data_t *data;
		414	};
		415
		416	typedef enum
		417	{
		418	PIXMAN_REGION_OUT,
		419	PIXMAN_REGION_IN,
		420	PIXMAN_REGION_PART
		421	} pixman_region_overlap_t;
		422
		423	/* This function exists only to make it possible to preserve
		424	* the X ABI - it should go away at first opportunity.
		425	*/
		426	void pixman_region_set_static_pointers (pixman_box16_t *empty_box,
		427	pixman_region16_data_t *empty_data,
		428	pixman_region16_data_t *broken_data);
		429
		430	/* creation/destruction */
		431	void pixman_region_init (pixman_region16_t *region);
		432	void pixman_region_init_rect (pixman_region16_t *region,
		433	int x,
		434	int y,
		435	unsigned int width,
		436	unsigned int height);
		437	pixman_bool_t pixman_region_init_rects (pixman_region16_t *region,
		438	const pixman_box16_t *boxes,
		439	int count);
		440	void pixman_region_init_with_extents (pixman_region16_t *region,
		441	pixman_box16_t *extents);
		442	void pixman_region_init_from_image (pixman_region16_t *region,
		443	pixman_image_t *image);
		444	void pixman_region_fini (pixman_region16_t *region);
		445
		446
		447	/* manipulation */
		448	void pixman_region_translate (pixman_region16_t *region,
		449	int x,
		450	int y);
		451	pixman_bool_t pixman_region_copy (pixman_region16_t *dest,
		452	pixman_region16_t *source);
		453	pixman_bool_t pixman_region_intersect (pixman_region16_t *new_reg,
		454	pixman_region16_t *reg1,
		455	pixman_region16_t *reg2);
		456	pixman_bool_t pixman_region_union (pixman_region16_t *new_reg,
		457	pixman_region16_t *reg1,
		458	pixman_region16_t *reg2);
		459	pixman_bool_t pixman_region_union_rect (pixman_region16_t *dest,
		460	pixman_region16_t *source,
		461	int x,
		462	int y,
		463	unsigned int width,
		464	unsigned int height);
		465	pixman_bool_t pixman_region_intersect_rect (pixman_region16_t *dest,
		466	pixman_region16_t *source,
		467	int x,
		468	int y,
		469	unsigned int width,
		470	unsigned int height);
		471	pixman_bool_t pixman_region_subtract (pixman_region16_t *reg_d,
		472	pixman_region16_t *reg_m,
		473	pixman_region16_t *reg_s);
		474	pixman_bool_t pixman_region_inverse (pixman_region16_t *new_reg,
		475	pixman_region16_t *reg1,
		476	pixman_box16_t *inv_rect);
		477	pixman_bool_t pixman_region_contains_point (pixman_region16_t *region,
		478	int x,
		479	int y,
		480	pixman_box16_t *box);
		481	pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *region,
		482	pixman_box16_t *prect);
		483	pixman_bool_t pixman_region_not_empty (pixman_region16_t *region);
		484	pixman_box16_t * pixman_region_extents (pixman_region16_t *region);
		485	int pixman_region_n_rects (pixman_region16_t *region);
		486	pixman_box16_t * pixman_region_rectangles (pixman_region16_t *region,
		487	int *n_rects);
		488	pixman_bool_t pixman_region_equal (pixman_region16_t *region1,
		489	pixman_region16_t *region2);
		490	pixman_bool_t pixman_region_selfcheck (pixman_region16_t *region);
		491	void pixman_region_reset (pixman_region16_t *region,
		492	pixman_box16_t *box);
		493	void pixman_region_clear (pixman_region16_t *region);
		494	/*
		495	* 32 bit regions
		496	*/
		497	typedef struct pixman_region32_data pixman_region32_data_t;
		498	typedef struct pixman_box32 pixman_box32_t;
		499	typedef struct pixman_rectangle32 pixman_rectangle32_t;
		500	typedef struct pixman_region32 pixman_region32_t;
		501
		502	struct pixman_region32_data {
		503	long size;
		504	long numRects;
		505	/* pixman_box32_t rects[size]; in memory but not explicitly declared */
		506	};
		507
		508	struct pixman_rectangle32
		509	{
		510	int32_t x, y;
		511	uint32_t width, height;
		512	};
		513
		514	struct pixman_box32
		515	{
		516	int32_t x1, y1, x2, y2;
		517	};
		518
		519	struct pixman_region32
		520	{
		521	pixman_box32_t extents;
		522	pixman_region32_data_t *data;
		523	};
		524
		525	/* creation/destruction */
		526	void pixman_region32_init (pixman_region32_t *region);
		527	void pixman_region32_init_rect (pixman_region32_t *region,
		528	int x,
		529	int y,
		530	unsigned int width,
		531	unsigned int height);
		532	pixman_bool_t pixman_region32_init_rects (pixman_region32_t *region,
		533	const pixman_box32_t *boxes,
		534	int count);
		535	void pixman_region32_init_with_extents (pixman_region32_t *region,
		536	pixman_box32_t *extents);
		537	void pixman_region32_init_from_image (pixman_region32_t *region,
		538	pixman_image_t *image);
		539	void pixman_region32_fini (pixman_region32_t *region);
		540
		541
		542	/* manipulation */
		543	void pixman_region32_translate (pixman_region32_t *region,
		544	int x,
		545	int y);
		546	pixman_bool_t pixman_region32_copy (pixman_region32_t *dest,
		547	pixman_region32_t *source);
		548	pixman_bool_t pixman_region32_intersect (pixman_region32_t *new_reg,
		549	pixman_region32_t *reg1,
		550	pixman_region32_t *reg2);
		551	pixman_bool_t pixman_region32_union (pixman_region32_t *new_reg,
		552	pixman_region32_t *reg1,
		553	pixman_region32_t *reg2);
		554	pixman_bool_t pixman_region32_intersect_rect (pixman_region32_t *dest,
		555	pixman_region32_t *source,
		556	int x,
		557	int y,
		558	unsigned int width,
		559	unsigned int height);
		560	pixman_bool_t pixman_region32_union_rect (pixman_region32_t *dest,
		561	pixman_region32_t *source,
		562	int x,
		563	int y,
		564	unsigned int width,
		565	unsigned int height);
		566	pixman_bool_t pixman_region32_subtract (pixman_region32_t *reg_d,
		567	pixman_region32_t *reg_m,
		568	pixman_region32_t *reg_s);
		569	pixman_bool_t pixman_region32_inverse (pixman_region32_t *new_reg,
		570	pixman_region32_t *reg1,
		571	pixman_box32_t *inv_rect);
		572	pixman_bool_t pixman_region32_contains_point (pixman_region32_t *region,
		573	int x,
		574	int y,
		575	pixman_box32_t *box);
		576	pixman_region_overlap_t pixman_region32_contains_rectangle (pixman_region32_t *region,
		577	pixman_box32_t *prect);
		578	pixman_bool_t pixman_region32_not_empty (pixman_region32_t *region);
		579	pixman_box32_t * pixman_region32_extents (pixman_region32_t *region);
		580	int pixman_region32_n_rects (pixman_region32_t *region);
		581	pixman_box32_t * pixman_region32_rectangles (pixman_region32_t *region,
		582	int *n_rects);
		583	pixman_bool_t pixman_region32_equal (pixman_region32_t *region1,
		584	pixman_region32_t *region2);
		585	pixman_bool_t pixman_region32_selfcheck (pixman_region32_t *region);
		586	void pixman_region32_reset (pixman_region32_t *region,
		587	pixman_box32_t *box);
		588	void pixman_region32_clear (pixman_region32_t *region);
		589
		590
		591	/* Copy / Fill / Misc */
		592	pixman_bool_t pixman_blt (uint32_t *src_bits,
		593	uint32_t *dst_bits,
		594	int src_stride,
		595	int dst_stride,
		596	int src_bpp,
		597	int dst_bpp,
		598	int src_x,
		599	int src_y,
		600	int dest_x,
		601	int dest_y,
		602	int width,
		603	int height);
		604	pixman_bool_t pixman_fill (uint32_t *bits,
		605	int stride,
		606	int bpp,
		607	int x,
		608	int y,
		609	int width,
		610	int height,
		611	uint32_t _xor);
		612
		613	int pixman_version (void);
		614	const char* pixman_version_string (void);
		615
		616	/*
		617	* Images
		618	*/
		619	typedef struct pixman_indexed pixman_indexed_t;
		620	typedef struct pixman_gradient_stop pixman_gradient_stop_t;
		621
		622	typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
		623	typedef void (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
		624
		625	typedef void (* pixman_image_destroy_func_t) (pixman_image_t image, void data);
		626
		627	struct pixman_gradient_stop {
		628	pixman_fixed_t x;
		629	pixman_color_t color;
		630	};
		631
		632	#define PIXMAN_MAX_INDEXED 256 /* XXX depth must be <= 8 */
		633
		634	#if PIXMAN_MAX_INDEXED <= 256
		635	typedef uint8_t pixman_index_type;
		636	#endif
		637
		638	struct pixman_indexed
		639	{
		640	pixman_bool_t color;
		641	uint32_t rgba[PIXMAN_MAX_INDEXED];
		642	pixman_index_type ent[32768];
		643	};
		644
		645	/*
		646	* While the protocol is generous in format support, the
		647	* sample implementation allows only packed RGB and GBR
		648	* representations for data to simplify software rendering,
		649	*/
		650	#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) \| \
		651	((type) << 16) \| \
		652	((a) << 12) \| \
		653	((r) << 8) \| \
		654	((g) << 4) \| \
		655	((b)))
		656
		657	#define PIXMAN_FORMAT_BPP(f) (((f) >> 24) )
		658	#define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0xff)
		659	#define PIXMAN_FORMAT_A(f) (((f) >> 12) & 0x0f)
		660	#define PIXMAN_FORMAT_R(f) (((f) >> 8) & 0x0f)
		661	#define PIXMAN_FORMAT_G(f) (((f) >> 4) & 0x0f)
		662	#define PIXMAN_FORMAT_B(f) (((f) ) & 0x0f)
		663	#define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff)
		664	#define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff)
		665	#define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \
		666	PIXMAN_FORMAT_R(f) + \
		667	PIXMAN_FORMAT_G(f) + \
		668	PIXMAN_FORMAT_B(f))
		669
		670	#define PIXMAN_TYPE_OTHER 0
		671	#define PIXMAN_TYPE_A 1
		672	#define PIXMAN_TYPE_ARGB 2
		673	#define PIXMAN_TYPE_ABGR 3
		674	#define PIXMAN_TYPE_COLOR 4
		675	#define PIXMAN_TYPE_GRAY 5
		676	#define PIXMAN_TYPE_YUY2 6
		677	#define PIXMAN_TYPE_YV12 7
		678	#define PIXMAN_TYPE_BGRA 8
		679	#define PIXMAN_TYPE_RGBA 9
		680	#define PIXMAN_TYPE_ARGB_SRGB 10
		681
		682	#define PIXMAN_FORMAT_COLOR(f) \
		683	(PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ARGB \|\| \
		684	PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ABGR \|\| \
		685	PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_BGRA \|\| \
		686	PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_RGBA)
		687
		688	/* 32bpp formats */
		689	typedef enum {
		690	PIXMAN_a8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8),
		691	PIXMAN_x8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8),
		692	PIXMAN_a8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8),
		693	PIXMAN_x8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,8,8,8),
		694	PIXMAN_b8g8r8a8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_BGRA,8,8,8,8),
		695	PIXMAN_b8g8r8x8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_BGRA,0,8,8,8),
		696	PIXMAN_r8g8b8a8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_RGBA,8,8,8,8),
		697	PIXMAN_r8g8b8x8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_RGBA,0,8,8,8),
		698	PIXMAN_x14r6g6b6 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,6,6,6),
		699	PIXMAN_x2r10g10b10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,10,10,10),
		700	PIXMAN_a2r10g10b10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,2,10,10,10),
		701	PIXMAN_x2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,10,10,10),
		702	PIXMAN_a2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,2,10,10,10),
		703
		704	/* sRGB formats */
		705	PIXMAN_a8r8g8b8_sRGB = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB_SRGB,8,8,8,8),
		706
		707	/* 24bpp formats */
		708	PIXMAN_r8g8b8 = PIXMAN_FORMAT(24,PIXMAN_TYPE_ARGB,0,8,8,8),
		709	PIXMAN_b8g8r8 = PIXMAN_FORMAT(24,PIXMAN_TYPE_ABGR,0,8,8,8),
		710
		711	/* 16bpp formats */
		712	PIXMAN_r5g6b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,6,5),
		713	PIXMAN_b5g6r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,6,5),
		714
		715	PIXMAN_a1r5g5b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,1,5,5,5),
		716	PIXMAN_x1r5g5b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,5,5),
		717	PIXMAN_a1b5g5r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,1,5,5,5),
		718	PIXMAN_x1b5g5r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,5,5),
		719	PIXMAN_a4r4g4b4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,4,4,4,4),
		720	PIXMAN_x4r4g4b4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,4,4,4),
		721	PIXMAN_a4b4g4r4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,4,4,4,4),
		722	PIXMAN_x4b4g4r4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,4,4,4),
		723
		724	/* 8bpp formats */
		725	PIXMAN_a8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_A,8,0,0,0),
		726	PIXMAN_r3g3b2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,0,3,3,2),
		727	PIXMAN_b2g3r3 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,0,3,3,2),
		728	PIXMAN_a2r2g2b2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,2,2,2,2),
		729	PIXMAN_a2b2g2r2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,2,2,2,2),
		730
		731	PIXMAN_c8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
		732	PIXMAN_g8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
		733
		734	PIXMAN_x4a4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_A,4,0,0,0),
		735
		736	PIXMAN_x4c4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
		737	PIXMAN_x4g4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
		738
		739	/* 4bpp formats */
		740	PIXMAN_a4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_A,4,0,0,0),
		741	PIXMAN_r1g2b1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,0,1,2,1),
		742	PIXMAN_b1g2r1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,0,1,2,1),
		743	PIXMAN_a1r1g1b1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,1,1,1,1),
		744	PIXMAN_a1b1g1r1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,1,1,1,1),
		745
		746	PIXMAN_c4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_COLOR,0,0,0,0),
		747	PIXMAN_g4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_GRAY,0,0,0,0),
		748
		749	/* 1bpp formats */
		750	PIXMAN_a1 = PIXMAN_FORMAT(1,PIXMAN_TYPE_A,1,0,0,0),
		751
		752	PIXMAN_g1 = PIXMAN_FORMAT(1,PIXMAN_TYPE_GRAY,0,0,0,0),
		753
		754	/* YUV formats */
		755	PIXMAN_yuy2 = PIXMAN_FORMAT(16,PIXMAN_TYPE_YUY2,0,0,0,0),
		756	PIXMAN_yv12 = PIXMAN_FORMAT(12,PIXMAN_TYPE_YV12,0,0,0,0)
		757	} pixman_format_code_t;
		758
		759	/* Querying supported format values. */
		760	pixman_bool_t pixman_format_supported_destination (pixman_format_code_t format);
		761	pixman_bool_t pixman_format_supported_source (pixman_format_code_t format);
		762
		763	/* Constructors */
		764	pixman_image_t pixman_image_create_solid_fill (const pixman_color_t color);
		765	pixman_image_t pixman_image_create_linear_gradient (const pixman_point_fixed_t p1,
		766	const pixman_point_fixed_t *p2,
		767	const pixman_gradient_stop_t *stops,
		768	int n_stops);
		769	pixman_image_t pixman_image_create_radial_gradient (const pixman_point_fixed_t inner,
		770	const pixman_point_fixed_t *outer,
		771	pixman_fixed_t inner_radius,
		772	pixman_fixed_t outer_radius,
		773	const pixman_gradient_stop_t *stops,
		774	int n_stops);
		775	pixman_image_t pixman_image_create_conical_gradient (const pixman_point_fixed_t center,
		776	pixman_fixed_t angle,
		777	const pixman_gradient_stop_t *stops,
		778	int n_stops);
		779	pixman_image_t *pixman_image_create_bits (pixman_format_code_t format,
		780	int width,
		781	int height,
		782	uint32_t *bits,
		783	int rowstride_bytes);
		784	pixman_image_t *pixman_image_create_bits_no_clear (pixman_format_code_t format,
		785	int width,
		786	int height,
		787	uint32_t * bits,
		788	int rowstride_bytes);
		789
		790	/* Destructor */
		791	pixman_image_t pixman_image_ref (pixman_image_t image);
		792	pixman_bool_t pixman_image_unref (pixman_image_t *image);
		793
		794	void pixman_image_set_destroy_function (pixman_image_t *image,
		795	pixman_image_destroy_func_t function,
		796	void *data);
		797	void * pixman_image_get_destroy_data (pixman_image_t *image);
		798
		799	/* Set properties */
		800	pixman_bool_t pixman_image_set_clip_region (pixman_image_t *image,
		801	pixman_region16_t *region);
		802	pixman_bool_t pixman_image_set_clip_region32 (pixman_image_t *image,
		803	pixman_region32_t *region);
		804	void pixman_image_set_has_client_clip (pixman_image_t *image,
		805	pixman_bool_t clien_clip);
		806	pixman_bool_t pixman_image_set_transform (pixman_image_t *image,
		807	const pixman_transform_t *transform);
		808	void pixman_image_set_repeat (pixman_image_t *image,
		809	pixman_repeat_t repeat);
		810	pixman_bool_t pixman_image_set_filter (pixman_image_t *image,
		811	pixman_filter_t filter,
		812	const pixman_fixed_t *filter_params,
		813	int n_filter_params);
		814	void pixman_image_set_source_clipping (pixman_image_t *image,
		815	pixman_bool_t source_clipping);
		816	void pixman_image_set_alpha_map (pixman_image_t *image,
		817	pixman_image_t *alpha_map,
		818	int16_t x,
		819	int16_t y);
		820	void pixman_image_set_component_alpha (pixman_image_t *image,
		821	pixman_bool_t component_alpha);
		822	pixman_bool_t pixman_image_get_component_alpha (pixman_image_t *image);
		823	void pixman_image_set_accessors (pixman_image_t *image,
		824	pixman_read_memory_func_t read_func,
		825	pixman_write_memory_func_t write_func);
		826	void pixman_image_set_indexed (pixman_image_t *image,
		827	const pixman_indexed_t *indexed);
		828	uint32_t pixman_image_get_data (pixman_image_t image);
		829	int pixman_image_get_width (pixman_image_t *image);
		830	int pixman_image_get_height (pixman_image_t *image);
		831	int pixman_image_get_stride (pixman_image_t image); / in bytes */
		832	int pixman_image_get_depth (pixman_image_t *image);
		833	pixman_format_code_t pixman_image_get_format (pixman_image_t *image);
		834
		835	typedef enum
		836	{
		837	PIXMAN_KERNEL_IMPULSE,
		838	PIXMAN_KERNEL_BOX,
		839	PIXMAN_KERNEL_LINEAR,
		840	PIXMAN_KERNEL_CUBIC,
		841	PIXMAN_KERNEL_GAUSSIAN,
		842	PIXMAN_KERNEL_LANCZOS2,
		843	PIXMAN_KERNEL_LANCZOS3,
		844	PIXMAN_KERNEL_LANCZOS3_STRETCHED /* Jim Blinn's 'nice' filter */
		845	} pixman_kernel_t;
		846
		847	/* Create the parameter list for a SEPARABLE_CONVOLUTION filter
		848	* with the given kernels and scale parameters.
		849	*/
		850	pixman_fixed_t *
		851	pixman_filter_create_separable_convolution (int *n_values,
		852	pixman_fixed_t scale_x,
		853	pixman_fixed_t scale_y,
		854	pixman_kernel_t reconstruct_x,
		855	pixman_kernel_t reconstruct_y,
		856	pixman_kernel_t sample_x,
		857	pixman_kernel_t sample_y,
		858	int subsample_bits_x,
		859	int subsample_bits_y);
		860
		861	pixman_bool_t pixman_image_fill_rectangles (pixman_op_t op,
		862	pixman_image_t *image,
		863	const pixman_color_t *color,
		864	int n_rects,
		865	const pixman_rectangle16_t *rects);
		866	pixman_bool_t pixman_image_fill_boxes (pixman_op_t op,
		867	pixman_image_t *dest,
		868	const pixman_color_t *color,
		869	int n_boxes,
		870	const pixman_box32_t *boxes);
		871
		872	/* Composite */
		873	pixman_bool_t pixman_compute_composite_region (pixman_region16_t *region,
		874	pixman_image_t *src_image,
		875	pixman_image_t *mask_image,
		876	pixman_image_t *dest_image,
		877	int16_t src_x,
		878	int16_t src_y,
		879	int16_t mask_x,
		880	int16_t mask_y,
		881	int16_t dest_x,
		882	int16_t dest_y,
		883	uint16_t width,
		884	uint16_t height);
		885	void pixman_image_composite (pixman_op_t op,
		886	pixman_image_t *src,
		887	pixman_image_t *mask,
		888	pixman_image_t *dest,
		889	int16_t src_x,
		890	int16_t src_y,
		891	int16_t mask_x,
		892	int16_t mask_y,
		893	int16_t dest_x,
		894	int16_t dest_y,
		895	uint16_t width,
		896	uint16_t height);
		897	void pixman_image_composite32 (pixman_op_t op,
		898	pixman_image_t *src,
		899	pixman_image_t *mask,
		900	pixman_image_t *dest,
		901	int32_t src_x,
		902	int32_t src_y,
		903	int32_t mask_x,
		904	int32_t mask_y,
		905	int32_t dest_x,
		906	int32_t dest_y,
		907	int32_t width,
		908	int32_t height);
		909
		910	/* Executive Summary: This function is a no-op that only exists
		911	* for historical reasons.
		912	*
		913	* There used to be a bug in the X server where it would rely on
		914	* out-of-bounds accesses when it was asked to composite with a
		915	* window as the source. It would create a pixman image pointing
		916	* to some bogus position in memory, but then set a clip region
		917	* to the position where the actual bits were.
		918	*
		919	* Due to a bug in old versions of pixman, where it would not clip
		920	* against the image bounds when a clip region was set, this would
		921	* actually work. So when the pixman bug was fixed, a workaround was
		922	* added to allow certain out-of-bound accesses. This function disabled
		923	* those workarounds.
		924	*
		925	* Since 0.21.2, pixman doesn't do these workarounds anymore, so now this
		926	* function is a no-op.
		927	*/
		928	void pixman_disable_out_of_bounds_workaround (void);
		929
		930	/*
		931	* Glyphs
		932	*/
		933	typedef struct pixman_glyph_cache_t pixman_glyph_cache_t;
		934	typedef struct
		935	{
		936	int x, y;
		937	const void *glyph;
		938	} pixman_glyph_t;
		939
		940	pixman_glyph_cache_t *pixman_glyph_cache_create (void);
		941	void pixman_glyph_cache_destroy (pixman_glyph_cache_t *cache);
		942	void pixman_glyph_cache_freeze (pixman_glyph_cache_t *cache);
		943	void pixman_glyph_cache_thaw (pixman_glyph_cache_t *cache);
		944	const void * pixman_glyph_cache_lookup (pixman_glyph_cache_t *cache,
		945	void *font_key,
		946	void *glyph_key);
		947	const void * pixman_glyph_cache_insert (pixman_glyph_cache_t *cache,
		948	void *font_key,
		949	void *glyph_key,
		950	int origin_x,
		951	int origin_y,
		952	pixman_image_t *glyph_image);
		953	void pixman_glyph_cache_remove (pixman_glyph_cache_t *cache,
		954	void *font_key,
		955	void *glyph_key);
		956	void pixman_glyph_get_extents (pixman_glyph_cache_t *cache,
		957	int n_glyphs,
		958	pixman_glyph_t *glyphs,
		959	pixman_box32_t *extents);
		960	pixman_format_code_t pixman_glyph_get_mask_format (pixman_glyph_cache_t *cache,
		961	int n_glyphs,
		962	const pixman_glyph_t *glyphs);
		963	void pixman_composite_glyphs (pixman_op_t op,
		964	pixman_image_t *src,
		965	pixman_image_t *dest,
		966	pixman_format_code_t mask_format,
		967	int32_t src_x,
		968	int32_t src_y,
		969	int32_t mask_x,
		970	int32_t mask_y,
		971	int32_t dest_x,
		972	int32_t dest_y,
		973	int32_t width,
		974	int32_t height,
		975	pixman_glyph_cache_t *cache,
		976	int n_glyphs,
		977	const pixman_glyph_t *glyphs);
		978	void pixman_composite_glyphs_no_mask (pixman_op_t op,
		979	pixman_image_t *src,
		980	pixman_image_t *dest,
		981	int32_t src_x,
		982	int32_t src_y,
		983	int32_t dest_x,
		984	int32_t dest_y,
		985	pixman_glyph_cache_t *cache,
		986	int n_glyphs,
		987	const pixman_glyph_t *glyphs);
		988
		989	/*
		990	* Trapezoids
		991	*/
		992	typedef struct pixman_edge pixman_edge_t;
		993	typedef struct pixman_trapezoid pixman_trapezoid_t;
		994	typedef struct pixman_trap pixman_trap_t;
		995	typedef struct pixman_span_fix pixman_span_fix_t;
		996	typedef struct pixman_triangle pixman_triangle_t;
		997
		998	/*
		999	* An edge structure. This represents a single polygon edge
		1000	* and can be quickly stepped across small or large gaps in the
		1001	* sample grid
		1002	*/
		1003	struct pixman_edge
		1004	{
		1005	pixman_fixed_t x;
		1006	pixman_fixed_t e;
		1007	pixman_fixed_t stepx;
		1008	pixman_fixed_t signdx;
		1009	pixman_fixed_t dy;
		1010	pixman_fixed_t dx;
		1011
		1012	pixman_fixed_t stepx_small;
		1013	pixman_fixed_t stepx_big;
		1014	pixman_fixed_t dx_small;
		1015	pixman_fixed_t dx_big;
		1016	};
		1017
		1018	struct pixman_trapezoid
		1019	{
		1020	pixman_fixed_t top, bottom;
		1021	pixman_line_fixed_t left, right;
		1022	};
		1023
		1024	struct pixman_triangle
		1025	{
		1026	pixman_point_fixed_t p1, p2, p3;
		1027	};
		1028
		1029	/* whether 't' is a well defined not obviously empty trapezoid */
		1030	#define pixman_trapezoid_valid(t) \
		1031	((t)->left.p1.y != (t)->left.p2.y && \
		1032	(t)->right.p1.y != (t)->right.p2.y && \
		1033	(int) ((t)->bottom - (t)->top) > 0)
		1034
		1035	struct pixman_span_fix
		1036	{
		1037	pixman_fixed_t l, r, y;
		1038	};
		1039
		1040	struct pixman_trap
		1041	{
		1042	pixman_span_fix_t top, bot;
		1043	};
		1044
		1045	pixman_fixed_t pixman_sample_ceil_y (pixman_fixed_t y,
		1046	int bpp);
		1047	pixman_fixed_t pixman_sample_floor_y (pixman_fixed_t y,
		1048	int bpp);
		1049	void pixman_edge_step (pixman_edge_t *e,
		1050	int n);
		1051	void pixman_edge_init (pixman_edge_t *e,
		1052	int bpp,
		1053	pixman_fixed_t y_start,
		1054	pixman_fixed_t x_top,
		1055	pixman_fixed_t y_top,
		1056	pixman_fixed_t x_bot,
		1057	pixman_fixed_t y_bot);
		1058	void pixman_line_fixed_edge_init (pixman_edge_t *e,
		1059	int bpp,
		1060	pixman_fixed_t y,
		1061	const pixman_line_fixed_t *line,
		1062	int x_off,
		1063	int y_off);
		1064	void pixman_rasterize_edges (pixman_image_t *image,
		1065	pixman_edge_t *l,
		1066	pixman_edge_t *r,
		1067	pixman_fixed_t t,
		1068	pixman_fixed_t b);
		1069	void pixman_add_traps (pixman_image_t *image,
		1070	int16_t x_off,
		1071	int16_t y_off,
		1072	int ntrap,
		1073	const pixman_trap_t *traps);
		1074	void pixman_add_trapezoids (pixman_image_t *image,
		1075	int16_t x_off,
		1076	int y_off,
		1077	int ntraps,
		1078	const pixman_trapezoid_t *traps);
		1079	void pixman_rasterize_trapezoid (pixman_image_t *image,
		1080	const pixman_trapezoid_t *trap,
		1081	int x_off,
		1082	int y_off);
		1083	void pixman_composite_trapezoids (pixman_op_t op,
		1084	pixman_image_t * src,
		1085	pixman_image_t * dst,
		1086	pixman_format_code_t mask_format,
		1087	int x_src,
		1088	int y_src,
		1089	int x_dst,
		1090	int y_dst,
		1091	int n_traps,
		1092	const pixman_trapezoid_t * traps);
		1093	void pixman_composite_triangles (pixman_op_t op,
		1094	pixman_image_t * src,
		1095	pixman_image_t * dst,
		1096	pixman_format_code_t mask_format,
		1097	int x_src,
		1098	int y_src,
		1099	int x_dst,
		1100	int y_dst,
		1101	int n_tris,
		1102	const pixman_triangle_t * tris);
		1103	void pixman_add_triangles (pixman_image_t *image,
		1104	int32_t x_off,
		1105	int32_t y_off,
		1106	int n_tris,
		1107	const pixman_triangle_t *tris);
		1108
		1109	PIXMAN_END_DECLS
		1110
		1111	#endif /* PIXMAN_H__ */

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/pixman/pixman.h @ 5366 – Rev 4349