d9d19cecc4a67518d4aa9a3ad1b093197519952e
[profile/ivi/pixman.git] / pixman / pixman-private.h
1 #ifndef PACKAGE
2 #  error config.h must be included before pixman-private.h
3 #endif
4
5 #ifndef PIXMAN_PRIVATE_H
6 #define PIXMAN_PRIVATE_H
7
8 #define PIXMAN_DISABLE_DEPRECATED
9 #define PIXMAN_USE_INTERNAL_API
10
11 #include "pixman.h"
12 #include <time.h>
13 #include <assert.h>
14 #include <stdio.h>
15 #include <string.h>
16
17 #include "pixman-compiler.h"
18
19 /*
20  * Images
21  */
22 typedef struct image_common image_common_t;
23 typedef struct solid_fill solid_fill_t;
24 typedef struct gradient gradient_t;
25 typedef struct linear_gradient linear_gradient_t;
26 typedef struct horizontal_gradient horizontal_gradient_t;
27 typedef struct vertical_gradient vertical_gradient_t;
28 typedef struct conical_gradient conical_gradient_t;
29 typedef struct radial_gradient radial_gradient_t;
30 typedef struct bits_image bits_image_t;
31 typedef struct circle circle_t;
32
33 typedef void (*fetch_scanline_t) (pixman_image_t *image,
34                                   int             x,
35                                   int             y,
36                                   int             width,
37                                   uint32_t       *buffer,
38                                   const uint32_t *mask);
39
40 typedef uint32_t (*fetch_pixel_32_t) (bits_image_t *image,
41                                       int           x,
42                                       int           y);
43
44 typedef uint64_t (*fetch_pixel_64_t) (bits_image_t *image,
45                                       int           x,
46                                       int           y);
47
48 typedef void (*store_scanline_t) (bits_image_t *  image,
49                                   int             x,
50                                   int             y,
51                                   int             width,
52                                   const uint32_t *values);
53
54 typedef enum
55 {
56     BITS,
57     LINEAR,
58     CONICAL,
59     RADIAL,
60     SOLID
61 } image_type_t;
62
63 typedef enum
64 {
65     SOURCE_IMAGE_CLASS_UNKNOWN,
66     SOURCE_IMAGE_CLASS_HORIZONTAL,
67 } source_image_class_t;
68
69 typedef source_image_class_t (*classify_func_t) (pixman_image_t *image,
70                                                 int             x,
71                                                 int             y,
72                                                 int             width,
73                                                 int             height);
74 typedef void (*property_changed_func_t) (pixman_image_t *image);
75
76 struct image_common
77 {
78     image_type_t                type;
79     int32_t                     ref_count;
80     pixman_region32_t           clip_region;
81     int32_t                     alpha_count;        /* How many times this image is being used as an alpha map */
82     pixman_bool_t               have_clip_region;   /* FALSE if there is no clip */
83     pixman_bool_t               client_clip;        /* Whether the source clip was
84                                                        set by a client */
85     pixman_bool_t               clip_sources;       /* Whether the clip applies when
86                                                      * the image is used as a source
87                                                      */
88     pixman_bool_t               dirty;
89     pixman_transform_t *        transform;
90     pixman_repeat_t             repeat;
91     pixman_filter_t             filter;
92     pixman_fixed_t *            filter_params;
93     int                         n_filter_params;
94     bits_image_t *              alpha_map;
95     int                         alpha_origin_x;
96     int                         alpha_origin_y;
97     pixman_bool_t               component_alpha;
98     classify_func_t             classify;
99     property_changed_func_t     property_changed;
100     fetch_scanline_t            get_scanline_32;
101     fetch_scanline_t            get_scanline_64;
102
103     pixman_image_destroy_func_t destroy_func;
104     void *                      destroy_data;
105
106     uint32_t                    flags;
107     pixman_format_code_t        extended_format_code;
108 };
109
110 struct solid_fill
111 {
112     image_common_t common;
113     pixman_color_t color;
114     
115     uint32_t       color_32;
116     uint64_t       color_64;
117 };
118
119 struct gradient
120 {
121     image_common_t          common;
122     int                     n_stops;
123     pixman_gradient_stop_t *stops;
124 };
125
126 struct linear_gradient
127 {
128     gradient_t           common;
129     pixman_point_fixed_t p1;
130     pixman_point_fixed_t p2;
131 };
132
133 struct circle
134 {
135     pixman_fixed_t x;
136     pixman_fixed_t y;
137     pixman_fixed_t radius;
138 };
139
140 struct radial_gradient
141 {
142     gradient_t common;
143
144     circle_t   c1;
145     circle_t   c2;
146
147     circle_t   delta;
148     double     a;
149     double     inva;
150     double     mindr;
151 };
152
153 struct conical_gradient
154 {
155     gradient_t           common;
156     pixman_point_fixed_t center;
157     double               angle;
158 };
159
160 struct bits_image
161 {
162     image_common_t             common;
163     pixman_format_code_t       format;
164     const pixman_indexed_t *   indexed;
165     int                        width;
166     int                        height;
167     uint32_t *                 bits;
168     uint32_t *                 free_me;
169     int                        rowstride;  /* in number of uint32_t's */
170
171     fetch_scanline_t           fetch_scanline_32;
172     fetch_pixel_32_t           fetch_pixel_32;
173     store_scanline_t           store_scanline_32;
174
175     fetch_scanline_t           fetch_scanline_64;
176     fetch_pixel_64_t           fetch_pixel_64;
177     store_scanline_t           store_scanline_64;
178
179     /* Used for indirect access to the bits */
180     pixman_read_memory_func_t  read_func;
181     pixman_write_memory_func_t write_func;
182 };
183
184 union pixman_image
185 {
186     image_type_t       type;
187     image_common_t     common;
188     bits_image_t       bits;
189     gradient_t         gradient;
190     linear_gradient_t  linear;
191     conical_gradient_t conical;
192     radial_gradient_t  radial;
193     solid_fill_t       solid;
194 };
195
196 typedef struct pixman_iter_t pixman_iter_t;
197 typedef enum
198 {
199     ITER_NARROW = (1 << 0),
200 } iter_flags_t;
201
202 struct pixman_iter_t
203 {
204     uint32_t *(* get_scanline) (pixman_iter_t *iter, const uint32_t *mask);
205     void      (* write_back)   (pixman_iter_t *iter);
206
207     pixman_image_t *    image;
208     uint32_t *          buffer;
209     int                 x, y;
210     int                 width;
211 };
212
213 void
214 _pixman_bits_image_setup_accessors (bits_image_t *image);
215
216 void
217 _pixman_bits_image_src_iter_init (pixman_image_t *image,
218                                   pixman_iter_t *iter,
219                                   int x, int y, int width, int height,
220                                   uint8_t *buffer, iter_flags_t flags);
221 void
222 _pixman_bits_image_dest_iter_init (pixman_image_t *image,
223                                    pixman_iter_t *iter,
224                                    int x, int y, int width, int height,
225                                    uint8_t *buffer, iter_flags_t flags);
226
227 void
228 _pixman_image_get_scanline_generic_64  (pixman_image_t *image,
229                                         int             x,
230                                         int             y,
231                                         int             width,
232                                         uint32_t *      buffer,
233                                         const uint32_t *mask);
234
235 source_image_class_t
236 _pixman_image_classify (pixman_image_t *image,
237                         int             x,
238                         int             y,
239                         int             width,
240                         int             height);
241
242 void
243 _pixman_image_get_scanline_32 (pixman_image_t *image,
244                                int             x,
245                                int             y,
246                                int             width,
247                                uint32_t *      buffer,
248                                const uint32_t *mask);
249
250 /* Even thought the type of buffer is uint32_t *, the function actually expects
251  * a uint64_t *buffer.
252  */
253 void
254 _pixman_image_get_scanline_64 (pixman_image_t *image,
255                                int             x,
256                                int             y,
257                                int             width,
258                                uint32_t *      buffer,
259                                const uint32_t *unused);
260
261 pixman_image_t *
262 _pixman_image_allocate (void);
263
264 pixman_bool_t
265 _pixman_init_gradient (gradient_t *                  gradient,
266                        const pixman_gradient_stop_t *stops,
267                        int                           n_stops);
268 void
269 _pixman_image_reset_clip_region (pixman_image_t *image);
270
271 void
272 _pixman_image_validate (pixman_image_t *image);
273
274 uint32_t
275 _pixman_image_get_solid (pixman_image_t *     image,
276                          pixman_format_code_t format);
277
278 #define PIXMAN_IMAGE_GET_LINE(image, x, y, type, out_stride, line, mul) \
279     do                                                                  \
280     {                                                                   \
281         uint32_t *__bits__;                                             \
282         int       __stride__;                                           \
283                                                                         \
284         __bits__ = image->bits.bits;                                    \
285         __stride__ = image->bits.rowstride;                             \
286         (out_stride) =                                                  \
287             __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type); \
288         (line) =                                                        \
289             ((type *) __bits__) + (out_stride) * (y) + (mul) * (x);     \
290     } while (0)
291
292 /*
293  * Gradient walker
294  */
295 typedef struct
296 {
297     uint32_t                left_ag;
298     uint32_t                left_rb;
299     uint32_t                right_ag;
300     uint32_t                right_rb;
301     int32_t                 left_x;
302     int32_t                 right_x;
303     int32_t                 stepper;
304
305     pixman_gradient_stop_t *stops;
306     int                     num_stops;
307     unsigned int            spread;
308
309     int                     need_reset;
310 } pixman_gradient_walker_t;
311
312 void
313 _pixman_gradient_walker_init (pixman_gradient_walker_t *walker,
314                               gradient_t *              gradient,
315                               unsigned int              spread);
316
317 void
318 _pixman_gradient_walker_reset (pixman_gradient_walker_t *walker,
319                                pixman_fixed_32_32_t      pos);
320
321 uint32_t
322 _pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
323                                pixman_fixed_32_32_t      x);
324
325 /*
326  * Edges
327  */
328
329 #define MAX_ALPHA(n)    ((1 << (n)) - 1)
330 #define N_Y_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)
331 #define N_X_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)
332
333 #define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC (n))
334 #define STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
335
336 #define Y_FRAC_FIRST(n) (STEP_Y_BIG (n) / 2)
337 #define Y_FRAC_LAST(n)  (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
338
339 #define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC (n))
340 #define STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
341
342 #define X_FRAC_FIRST(n) (STEP_X_BIG (n) / 2)
343 #define X_FRAC_LAST(n)  (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
344
345 #define RENDER_SAMPLES_X(x, n)                                          \
346     ((n) == 1? 0 : (pixman_fixed_frac (x) +                             \
347                     X_FRAC_FIRST (n)) / STEP_X_SMALL (n))
348
349 void
350 pixman_rasterize_edges_accessors (pixman_image_t *image,
351                                   pixman_edge_t * l,
352                                   pixman_edge_t * r,
353                                   pixman_fixed_t  t,
354                                   pixman_fixed_t  b);
355
356 /*
357  * Implementations
358  */
359 typedef struct pixman_implementation_t pixman_implementation_t;
360
361 typedef void (*pixman_combine_32_func_t) (pixman_implementation_t *imp,
362                                           pixman_op_t              op,
363                                           uint32_t *               dest,
364                                           const uint32_t *         src,
365                                           const uint32_t *         mask,
366                                           int                      width);
367
368 typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,
369                                           pixman_op_t              op,
370                                           uint64_t *               dest,
371                                           const uint64_t *         src,
372                                           const uint64_t *         mask,
373                                           int                      width);
374
375 typedef void (*pixman_composite_func_t) (pixman_implementation_t *imp,
376                                          pixman_op_t              op,
377                                          pixman_image_t *         src,
378                                          pixman_image_t *         mask,
379                                          pixman_image_t *         dest,
380                                          int32_t                  src_x,
381                                          int32_t                  src_y,
382                                          int32_t                  mask_x,
383                                          int32_t                  mask_y,
384                                          int32_t                  dest_x,
385                                          int32_t                  dest_y,
386                                          int32_t                  width,
387                                          int32_t                  height);
388 typedef pixman_bool_t (*pixman_blt_func_t) (pixman_implementation_t *imp,
389                                             uint32_t *               src_bits,
390                                             uint32_t *               dst_bits,
391                                             int                      src_stride,
392                                             int                      dst_stride,
393                                             int                      src_bpp,
394                                             int                      dst_bpp,
395                                             int                      src_x,
396                                             int                      src_y,
397                                             int                      dst_x,
398                                             int                      dst_y,
399                                             int                      width,
400                                             int                      height);
401 typedef pixman_bool_t (*pixman_fill_func_t) (pixman_implementation_t *imp,
402                                              uint32_t *               bits,
403                                              int                      stride,
404                                              int                      bpp,
405                                              int                      x,
406                                              int                      y,
407                                              int                      width,
408                                              int                      height,
409                                              uint32_t                 xor);
410
411 void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);
412 void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);
413
414 typedef struct
415 {
416     pixman_op_t             op;
417     pixman_format_code_t    src_format;
418     uint32_t                src_flags;
419     pixman_format_code_t    mask_format;
420     uint32_t                mask_flags;
421     pixman_format_code_t    dest_format;
422     uint32_t                dest_flags;
423     pixman_composite_func_t func;
424 } pixman_fast_path_t;
425
426 struct pixman_implementation_t
427 {
428     pixman_implementation_t *   toplevel;
429     pixman_implementation_t *   delegate;
430     const pixman_fast_path_t *  fast_paths;
431     
432     pixman_blt_func_t           blt;
433     pixman_fill_func_t          fill;
434
435     pixman_combine_32_func_t    combine_32[PIXMAN_N_OPERATORS];
436     pixman_combine_32_func_t    combine_32_ca[PIXMAN_N_OPERATORS];
437     pixman_combine_64_func_t    combine_64[PIXMAN_N_OPERATORS];
438     pixman_combine_64_func_t    combine_64_ca[PIXMAN_N_OPERATORS];
439 };
440
441 pixman_implementation_t *
442 _pixman_implementation_create (pixman_implementation_t *delegate,
443                                const pixman_fast_path_t *fast_paths);
444
445 void
446 _pixman_implementation_combine_32 (pixman_implementation_t *imp,
447                                    pixman_op_t              op,
448                                    uint32_t *               dest,
449                                    const uint32_t *         src,
450                                    const uint32_t *         mask,
451                                    int                      width);
452 void
453 _pixman_implementation_combine_64 (pixman_implementation_t *imp,
454                                    pixman_op_t              op,
455                                    uint64_t *               dest,
456                                    const uint64_t *         src,
457                                    const uint64_t *         mask,
458                                    int                      width);
459 void
460 _pixman_implementation_combine_32_ca (pixman_implementation_t *imp,
461                                       pixman_op_t              op,
462                                       uint32_t *               dest,
463                                       const uint32_t *         src,
464                                       const uint32_t *         mask,
465                                       int                      width);
466 void
467 _pixman_implementation_combine_64_ca (pixman_implementation_t *imp,
468                                       pixman_op_t              op,
469                                       uint64_t *               dest,
470                                       const uint64_t *         src,
471                                       const uint64_t *         mask,
472                                       int                      width);
473
474 pixman_bool_t
475 _pixman_implementation_blt (pixman_implementation_t *imp,
476                             uint32_t *               src_bits,
477                             uint32_t *               dst_bits,
478                             int                      src_stride,
479                             int                      dst_stride,
480                             int                      src_bpp,
481                             int                      dst_bpp,
482                             int                      src_x,
483                             int                      src_y,
484                             int                      dst_x,
485                             int                      dst_y,
486                             int                      width,
487                             int                      height);
488
489 pixman_bool_t
490 _pixman_implementation_fill (pixman_implementation_t *imp,
491                              uint32_t *               bits,
492                              int                      stride,
493                              int                      bpp,
494                              int                      x,
495                              int                      y,
496                              int                      width,
497                              int                      height,
498                              uint32_t                 xor);
499
500 /* Specific implementations */
501 pixman_implementation_t *
502 _pixman_implementation_create_general (void);
503
504 pixman_implementation_t *
505 _pixman_implementation_create_fast_path (void);
506
507 #ifdef USE_MMX
508 pixman_implementation_t *
509 _pixman_implementation_create_mmx (void);
510 #endif
511
512 #ifdef USE_SSE2
513 pixman_implementation_t *
514 _pixman_implementation_create_sse2 (void);
515 #endif
516
517 #ifdef USE_ARM_SIMD
518 pixman_implementation_t *
519 _pixman_implementation_create_arm_simd (void);
520 #endif
521
522 #ifdef USE_ARM_NEON
523 pixman_implementation_t *
524 _pixman_implementation_create_arm_neon (void);
525 #endif
526
527 #ifdef USE_VMX
528 pixman_implementation_t *
529 _pixman_implementation_create_vmx (void);
530 #endif
531
532 pixman_implementation_t *
533 _pixman_choose_implementation (void);
534
535
536
537 /*
538  * Utilities
539  */
540
541 /* These "formats" all have depth 0, so they
542  * will never clash with any real ones
543  */
544 #define PIXMAN_null             PIXMAN_FORMAT (0, 0, 0, 0, 0, 0)
545 #define PIXMAN_solid            PIXMAN_FORMAT (0, 1, 0, 0, 0, 0)
546 #define PIXMAN_pixbuf           PIXMAN_FORMAT (0, 2, 0, 0, 0, 0)
547 #define PIXMAN_rpixbuf          PIXMAN_FORMAT (0, 3, 0, 0, 0, 0)
548 #define PIXMAN_unknown          PIXMAN_FORMAT (0, 4, 0, 0, 0, 0)
549 #define PIXMAN_any              PIXMAN_FORMAT (0, 5, 0, 0, 0, 0)
550
551 #define PIXMAN_OP_any           (PIXMAN_N_OPERATORS + 1)
552
553 #define FAST_PATH_ID_TRANSFORM                  (1 <<  0)
554 #define FAST_PATH_NO_ALPHA_MAP                  (1 <<  1)
555 #define FAST_PATH_NO_CONVOLUTION_FILTER         (1 <<  2)
556 #define FAST_PATH_NO_PAD_REPEAT                 (1 <<  3)
557 #define FAST_PATH_NO_REFLECT_REPEAT             (1 <<  4)
558 #define FAST_PATH_NO_ACCESSORS                  (1 <<  5)
559 #define FAST_PATH_NARROW_FORMAT                 (1 <<  6)
560 #define FAST_PATH_COMPONENT_ALPHA               (1 <<  8)
561 #define FAST_PATH_SAMPLES_OPAQUE                (1 <<  7)
562 #define FAST_PATH_UNIFIED_ALPHA                 (1 <<  9)
563 #define FAST_PATH_SCALE_TRANSFORM               (1 << 10)
564 #define FAST_PATH_NEAREST_FILTER                (1 << 11)
565 #define FAST_PATH_HAS_TRANSFORM                 (1 << 12)
566 #define FAST_PATH_IS_OPAQUE                     (1 << 13)
567 #define FAST_PATH_NO_NORMAL_REPEAT              (1 << 14)
568 #define FAST_PATH_NO_NONE_REPEAT                (1 << 15)
569 #define FAST_PATH_SAMPLES_COVER_CLIP            (1 << 16)
570 #define FAST_PATH_X_UNIT_POSITIVE               (1 << 17)
571 #define FAST_PATH_AFFINE_TRANSFORM              (1 << 18)
572 #define FAST_PATH_Y_UNIT_ZERO                   (1 << 19)
573 #define FAST_PATH_BILINEAR_FILTER               (1 << 20)
574
575 #define FAST_PATH_PAD_REPEAT                                            \
576     (FAST_PATH_NO_NONE_REPEAT           |                               \
577      FAST_PATH_NO_NORMAL_REPEAT         |                               \
578      FAST_PATH_NO_REFLECT_REPEAT)
579
580 #define FAST_PATH_NORMAL_REPEAT                                         \
581     (FAST_PATH_NO_NONE_REPEAT           |                               \
582      FAST_PATH_NO_PAD_REPEAT            |                               \
583      FAST_PATH_NO_REFLECT_REPEAT)
584
585 #define FAST_PATH_NONE_REPEAT                                           \
586     (FAST_PATH_NO_NORMAL_REPEAT         |                               \
587      FAST_PATH_NO_PAD_REPEAT            |                               \
588      FAST_PATH_NO_REFLECT_REPEAT)
589
590 #define FAST_PATH_REFLECT_REPEAT                                        \
591     (FAST_PATH_NO_NONE_REPEAT           |                               \
592      FAST_PATH_NO_NORMAL_REPEAT         |                               \
593      FAST_PATH_NO_PAD_REPEAT)
594
595 #define FAST_PATH_STANDARD_FLAGS                                        \
596     (FAST_PATH_NO_CONVOLUTION_FILTER    |                               \
597      FAST_PATH_NO_ACCESSORS             |                               \
598      FAST_PATH_NO_ALPHA_MAP             |                               \
599      FAST_PATH_NARROW_FORMAT)
600
601 #define FAST_PATH_STD_DEST_FLAGS                                        \
602     (FAST_PATH_NO_ACCESSORS             |                               \
603      FAST_PATH_NO_ALPHA_MAP             |                               \
604      FAST_PATH_NARROW_FORMAT)
605
606 #define SOURCE_FLAGS(format)                                            \
607     (FAST_PATH_STANDARD_FLAGS |                                         \
608      ((PIXMAN_ ## format == PIXMAN_solid) ?                             \
609       0 : (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_ID_TRANSFORM)))
610
611 #define MASK_FLAGS(format, extra)                                       \
612     ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))
613
614 #define FAST_PATH(op, src, src_flags, mask, mask_flags, dest, dest_flags, func) \
615     PIXMAN_OP_ ## op,                                                   \
616     PIXMAN_ ## src,                                                     \
617     src_flags,                                                          \
618     PIXMAN_ ## mask,                                                    \
619     mask_flags,                                                         \
620     PIXMAN_ ## dest,                                                    \
621     dest_flags,                                                         \
622     func
623
624 #define PIXMAN_STD_FAST_PATH(op, src, mask, dest, func)                 \
625     { FAST_PATH (                                                       \
626             op,                                                         \
627             src,  SOURCE_FLAGS (src),                                   \
628             mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA),           \
629             dest, FAST_PATH_STD_DEST_FLAGS,                             \
630             func) }
631
632 #define PIXMAN_STD_FAST_PATH_CA(op, src, mask, dest, func)              \
633     { FAST_PATH (                                                       \
634             op,                                                         \
635             src,  SOURCE_FLAGS (src),                                   \
636             mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA),         \
637             dest, FAST_PATH_STD_DEST_FLAGS,                             \
638             func) }
639
640 /* Memory allocation helpers */
641 void *
642 pixman_malloc_ab (unsigned int n, unsigned int b);
643
644 void *
645 pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);
646
647 pixman_bool_t
648 pixman_multiply_overflows_int (unsigned int a, unsigned int b);
649
650 pixman_bool_t
651 pixman_addition_overflows_int (unsigned int a, unsigned int b);
652
653 /* Compositing utilities */
654 void
655 pixman_expand (uint64_t *           dst,
656                const uint32_t *     src,
657                pixman_format_code_t format,
658                int                  width);
659
660 void
661 pixman_contract (uint32_t *      dst,
662                  const uint64_t *src,
663                  int             width);
664
665
666 /* Region Helpers */
667 pixman_bool_t
668 pixman_region32_copy_from_region16 (pixman_region32_t *dst,
669                                     pixman_region16_t *src);
670
671 pixman_bool_t
672 pixman_region16_copy_from_region32 (pixman_region16_t *dst,
673                                     pixman_region32_t *src);
674
675
676 /* Misc macros */
677
678 #ifndef FALSE
679 #   define FALSE 0
680 #endif
681
682 #ifndef TRUE
683 #   define TRUE 1
684 #endif
685
686 #ifndef MIN
687 #  define MIN(a, b) ((a < b) ? a : b)
688 #endif
689
690 #ifndef MAX
691 #  define MAX(a, b) ((a > b) ? a : b)
692 #endif
693
694 /* Integer division that rounds towards -infinity */
695 #define DIV(a, b)                                          \
696     ((((a) < 0) == ((b) < 0)) ? (a) / (b) :                \
697      ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
698
699 /* Modulus that produces the remainder wrt. DIV */
700 #define MOD(a, b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
701
702 #define CLIP(v, low, high) ((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))
703
704 /* Conversion between 8888 and 0565 */
705
706 #define CONVERT_8888_TO_0565(s)                                         \
707     ((((s) >> 3) & 0x001f) |                                            \
708      (((s) >> 5) & 0x07e0) |                                            \
709      (((s) >> 8) & 0xf800))
710
711 #define CONVERT_0565_TO_0888(s)                                         \
712     (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) |                       \
713      ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) |                   \
714      ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
715
716 #define CONVERT_0565_TO_8888(s) (CONVERT_0565_TO_0888(s) | 0xff000000)
717
718 /* Trivial versions that are useful in macros */
719 #define CONVERT_8888_TO_8888(s) (s)
720 #define CONVERT_0565_TO_0565(s) (s)
721
722 #define PIXMAN_FORMAT_IS_WIDE(f)                                        \
723     (PIXMAN_FORMAT_A (f) > 8 ||                                         \
724      PIXMAN_FORMAT_R (f) > 8 ||                                         \
725      PIXMAN_FORMAT_G (f) > 8 ||                                         \
726      PIXMAN_FORMAT_B (f) > 8)
727
728 #ifdef WORDS_BIGENDIAN
729 #   define SCREEN_SHIFT_LEFT(x,n)       ((x) << (n))
730 #   define SCREEN_SHIFT_RIGHT(x,n)      ((x) >> (n))
731 #else
732 #   define SCREEN_SHIFT_LEFT(x,n)       ((x) >> (n))
733 #   define SCREEN_SHIFT_RIGHT(x,n)      ((x) << (n))
734 #endif
735
736 /*
737  * Various debugging code
738  */
739
740 #undef DEBUG
741
742 #define COMPILE_TIME_ASSERT(x)                                          \
743     do { typedef int compile_time_assertion [(x)?1:-1]; } while (0)
744
745 /* Turn on debugging depending on what type of release this is
746  */
747 #if (((PIXMAN_VERSION_MICRO % 2) == 0) && ((PIXMAN_VERSION_MINOR % 2) == 1))
748
749 /* Debugging gets turned on for development releases because these
750  * are the things that end up in bleeding edge distributions such
751  * as Rawhide etc.
752  *
753  * For performance reasons we don't turn it on for stable releases or
754  * random git checkouts. (Random git checkouts are often used for
755  * performance work).
756  */
757
758 #    define DEBUG
759
760 #endif
761
762 #ifdef DEBUG
763
764 void
765 _pixman_log_error (const char *function, const char *message);
766
767 #define return_if_fail(expr)                                            \
768     do                                                                  \
769     {                                                                   \
770         if (!(expr))                                                    \
771         {                                                               \
772             _pixman_log_error (FUNC, "The expression " # expr " was false"); \
773             return;                                                     \
774         }                                                               \
775     }                                                                   \
776     while (0)
777
778 #define return_val_if_fail(expr, retval)                                \
779     do                                                                  \
780     {                                                                   \
781         if (!(expr))                                                    \
782         {                                                               \
783             _pixman_log_error (FUNC, "The expression " # expr " was false"); \
784             return (retval);                                            \
785         }                                                               \
786     }                                                                   \
787     while (0)
788
789 #define critical_if_fail(expr)                                          \
790     do                                                                  \
791     {                                                                   \
792         if (!(expr))                                                    \
793             _pixman_log_error (FUNC, "The expression " # expr " was false"); \
794     }                                                                   \
795     while (0)
796
797
798 #else
799
800 #define _pixman_log_error(f,m) do { } while (0)                         \
801
802 #define return_if_fail(expr)                                            \
803     do                                                                  \
804     {                                                                   \
805         if (!(expr))                                                    \
806             return;                                                     \
807     }                                                                   \
808     while (0)
809
810 #define return_val_if_fail(expr, retval)                                \
811     do                                                                  \
812     {                                                                   \
813         if (!(expr))                                                    \
814             return (retval);                                            \
815     }                                                                   \
816     while (0)
817
818 #define critical_if_fail(expr)                                          \
819     do                                                                  \
820     {                                                                   \
821     }                                                                   \
822     while (0)
823 #endif
824
825 /*
826  * Timers
827  */
828
829 #ifdef PIXMAN_TIMERS
830
831 static inline uint64_t
832 oil_profile_stamp_rdtsc (void)
833 {
834     uint64_t ts;
835
836     __asm__ __volatile__ ("rdtsc\n" : "=A" (ts));
837     return ts;
838 }
839
840 #define OIL_STAMP oil_profile_stamp_rdtsc
841
842 typedef struct pixman_timer_t pixman_timer_t;
843
844 struct pixman_timer_t
845 {
846     int             initialized;
847     const char *    name;
848     uint64_t        n_times;
849     uint64_t        total;
850     pixman_timer_t *next;
851 };
852
853 extern int timer_defined;
854
855 void pixman_timer_register (pixman_timer_t *timer);
856
857 #define TIMER_BEGIN(tname)                                              \
858     {                                                                   \
859         static pixman_timer_t timer ## tname;                           \
860         uint64_t              begin ## tname;                           \
861                                                                         \
862         if (!timer ## tname.initialized)                                \
863         {                                                               \
864             timer ## tname.initialized = 1;                             \
865             timer ## tname.name = # tname;                              \
866             pixman_timer_register (&timer ## tname);                    \
867         }                                                               \
868                                                                         \
869         timer ## tname.n_times++;                                       \
870         begin ## tname = OIL_STAMP ();
871
872 #define TIMER_END(tname)                                                \
873     timer ## tname.total += OIL_STAMP () - begin ## tname;              \
874     }
875
876 #endif /* PIXMAN_TIMERS */
877
878 #endif /* PIXMAN_PRIVATE_H */