• file
• revisions
• annotate
• diff
• comparison
• raw

gfx/cairo/libpixman/src/pixman.h@b8a032363ba2 (annotated)

gfx/cairo/libpixman/src/pixman.h

Thu, 22 Jan 2015 13:21:57 +0100

author

Michael Schloh von Bennewitz <michael@schloh.com>

date

Thu, 22 Jan 2015 13:21:57 +0100

branch

TOR_BUG_9701

changeset 15

b8a032363ba2

permissions

-rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

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