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