The Tor Browser / file comparison

comparison: gfx/cairo/libpixman/src/pixman.h

gfx/cairo/libpixman/src/pixman.h

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial