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 #include "pixman.h"
   9 #include <time.h>
  10 #include <assert.h>
  11
  12 #include "pixman-compiler.h"
  13
  14 /*
  15  * Images
  16  */
  17 typedef struct image_common image_common_t;
  18 typedef struct source_image source_image_t;
  19 typedef struct solid_fill solid_fill_t;
  20 typedef struct gradient gradient_t;
  21 typedef struct linear_gradient linear_gradient_t;
  22 typedef struct horizontal_gradient horizontal_gradient_t;
  23 typedef struct vertical_gradient vertical_gradient_t;
  24 typedef struct conical_gradient conical_gradient_t;
  25 typedef struct radial_gradient radial_gradient_t;
  26 typedef struct bits_image bits_image_t;
  27 typedef struct circle circle_t;
  28
  29 typedef void (*fetch_scanline_t) (pixman_image_t *image,
  30                                   int             x,
  31                                   int             y,
  32                                   int             width,
  33                                   uint32_t       *buffer,
  34                                   const uint32_t *mask,
  35                                   uint32_t        mask_bits);
  36
  37 typedef uint32_t (*fetch_pixel_32_t) (bits_image_t *image,
  38                                       int           x,
  39                                       int           y);
  40
  41 typedef uint64_t (*fetch_pixel_64_t) (bits_image_t *image,
  42                                       int           x,
  43                                       int           y);
  44
  45 typedef void (*store_scanline_t) (bits_image_t *  image,
  46                                   int             x,
  47                                   int             y,
  48                                   int             width,
  49                                   const uint32_t *values);
  50
  51 typedef enum
  52 {
  53     BITS,
  54     LINEAR,
  55     CONICAL,
  56     RADIAL,
  57     SOLID
  58 } image_type_t;
  59
  60 typedef enum
  61 {
  62     SOURCE_IMAGE_CLASS_UNKNOWN,
  63     SOURCE_IMAGE_CLASS_HORIZONTAL,
  64     SOURCE_IMAGE_CLASS_VERTICAL,
  65 } source_image_class_t;
  66
  67 typedef source_image_class_t (*classify_func_t) (pixman_image_t *image,
  68                                                 int             x,
  69                                                 int             y,
  70                                                 int             width,
  71                                                 int             height);
  72 typedef void (*property_changed_func_t) (pixman_image_t *image);
  73
  74 struct image_common
  75 {
  76     image_type_t                type;
  77     int32_t                     ref_count;
  78     pixman_region32_t           clip_region;
  79     pixman_bool_t               have_clip_region;   /* FALSE if there is no clip */
  80     pixman_bool_t               client_clip;        /* Whether the source clip was
  81                                                        set by a client */
  82     pixman_bool_t               clip_sources;       /* Whether the clip applies when
  83                                                      * the image is used as a source
  84                                                      */
  85     pixman_bool_t               need_workaround;
  86     pixman_transform_t *        transform;
  87     pixman_repeat_t             repeat;
  88     pixman_filter_t             filter;
  89     pixman_fixed_t *            filter_params;
  90     int                         n_filter_params;
  91     bits_image_t *              alpha_map;
  92     int                         alpha_origin_x;
  93     int                         alpha_origin_y;
  94     pixman_bool_t               component_alpha;
  95     classify_func_t             classify;
  96     property_changed_func_t     property_changed;
  97     fetch_scanline_t            get_scanline_32;
  98     fetch_scanline_t            get_scanline_64;
  99
 100     pixman_image_destroy_func_t destroy_func;
 101     void *                      destroy_data;
 102 };
 103
 104 struct source_image
 105 {
 106     image_common_t common;
 107     source_image_class_t class;
 108 };
 109
 110 struct solid_fill
 111 {
 112     source_image_t common;
 113     uint32_t       color;    /* FIXME: shouldn't this be a pixman_color_t? */
 114 };
 115
 116 struct gradient
 117 {
 118     source_image_t          common;
 119     int                     n_stops;
 120     pixman_gradient_stop_t *stops;
 121     int                     stop_range;
 122     uint32_t *              color_table;
 123     int                     color_table_size;
 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     double     cdx;
 147     double     cdy;
 148     double     dr;
 149     double     A;
 150 };
 151
 152 struct conical_gradient
 153 {
 154     gradient_t           common;
 155     pixman_point_fixed_t center;
 156     pixman_fixed_t       angle;
 157 };
 158
 159 struct bits_image
 160 {
 161     image_common_t             common;
 162     pixman_format_code_t       format;
 163     const pixman_indexed_t *   indexed;
 164     int                        width;
 165     int                        height;
 166     uint32_t *                 bits;
 167     uint32_t *                 free_me;
 168     int                        rowstride;  /* in number of uint32_t's */
 169
 170     /* Fetch a pixel, disregarding alpha maps, transformations etc. */
 171     fetch_pixel_32_t           fetch_pixel_raw_32;
 172     fetch_pixel_64_t           fetch_pixel_raw_64;
 173
 174     /* Fetch a pixel, taking alpha maps into account */
 175     fetch_pixel_32_t           fetch_pixel_32;
 176     fetch_pixel_64_t           fetch_pixel_64;
 177
 178     /* Fetch raw scanlines, with no regard for transformations, alpha maps etc. */
 179     fetch_scanline_t           fetch_scanline_raw_32;
 180     fetch_scanline_t           fetch_scanline_raw_64;
 181
 182     /* Store scanlines with no regard for alpha maps */
 183     store_scanline_t           store_scanline_raw_32;
 184     store_scanline_t           store_scanline_raw_64;
 185
 186     /* Store a scanline, taking alpha maps into account */
 187     store_scanline_t           store_scanline_32;
 188     store_scanline_t           store_scanline_64;
 189
 190     /* Used for indirect access to the bits */
 191     pixman_read_memory_func_t  read_func;
 192     pixman_write_memory_func_t write_func;
 193 };
 194
 195 union pixman_image
 196 {
 197     image_type_t       type;
 198     image_common_t     common;
 199     bits_image_t       bits;
 200     source_image_t     source;
 201     gradient_t         gradient;
 202     linear_gradient_t  linear;
 203     conical_gradient_t conical;
 204     radial_gradient_t  radial;
 205     solid_fill_t       solid;
 206 };
 207
 208
 209 void
 210 _pixman_bits_image_setup_raw_accessors (bits_image_t *image);
 211
 212 void
 213 _pixman_image_get_scanline_generic_64  (pixman_image_t *image,
 214                                         int             x,
 215                                         int             y,
 216                                         int             width,
 217                                         uint32_t *      buffer,
 218                                         const uint32_t *mask,
 219                                         uint32_t        mask_bits);
 220
 221 source_image_class_t
 222 _pixman_image_classify (pixman_image_t *image,
 223                         int             x,
 224                         int             y,
 225                         int             width,
 226                         int             height);
 227
 228 void
 229 _pixman_image_get_scanline_32 (pixman_image_t *image,
 230                                int             x,
 231                                int             y,
 232                                int             width,
 233                                uint32_t *      buffer,
 234                                const uint32_t *mask,
 235                                uint32_t        mask_bits);
 236
 237 /* Even thought the type of buffer is uint32_t *, the function actually expects
 238  * a uint64_t *buffer.
 239  */
 240 void
 241 _pixman_image_get_scanline_64 (pixman_image_t *image,
 242                                int             x,
 243                                int             y,
 244                                int             width,
 245                                uint32_t *      buffer,
 246                                const uint32_t *unused,
 247                                uint32_t        unused2);
 248
 249 void
 250 _pixman_image_store_scanline_32 (bits_image_t *  image,
 251                                  int             x,
 252                                  int             y,
 253                                  int             width,
 254                                  const uint32_t *buffer);
 255 void
 256 _pixman_image_fetch_pixels (bits_image_t *image,
 257                             uint32_t *    buffer,
 258                             int           n_pixels);
 259
 260 /* Even though the type of buffer is uint32_t *, the function
 261  * actually expects a uint64_t *buffer.
 262  */
 263 void
 264 _pixman_image_store_scanline_64 (bits_image_t *  image,
 265                                  int             x,
 266                                  int             y,
 267                                  int             width,
 268                                  const uint32_t *buffer);
 269
 270 pixman_image_t *
 271 _pixman_image_allocate (void);
 272
 273 pixman_bool_t
 274 _pixman_init_gradient (gradient_t *                  gradient,
 275                        const pixman_gradient_stop_t *stops,
 276                        int                           n_stops);
 277 void
 278 _pixman_image_reset_clip_region (pixman_image_t *image);
 279
 280 pixman_bool_t
 281 _pixman_image_is_opaque (pixman_image_t *image);
 282
 283 pixman_bool_t
 284 _pixman_image_is_solid (pixman_image_t *image);
 285
 286 uint32_t
 287 _pixman_image_get_solid (pixman_image_t *     image,
 288                          pixman_format_code_t format);
 289
 290 #define PIXMAN_IMAGE_GET_LINE(image, x, y, type, out_stride, line, mul) \
 291     do                                                                  \
 292     {                                                                   \
 293         uint32_t *__bits__;                                             \
 294         int       __stride__;                                           \
 295                                                                         \
 296         __bits__ = image->bits.bits;                                    \
 297         __stride__ = image->bits.rowstride;                             \
 298         (out_stride) =                                                  \
 299             __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type); \
 300         (line) =                                                        \
 301             ((type *) __bits__) + (out_stride) * (y) + (mul) * (x);     \
 302     } while (0)
 303
 304 /*
 305  * Gradient walker
 306  */
 307 typedef struct
 308 {
 309     uint32_t                left_ag;
 310     uint32_t                left_rb;
 311     uint32_t                right_ag;
 312     uint32_t                right_rb;
 313     int32_t                 left_x;
 314     int32_t                 right_x;
 315     int32_t                 stepper;
 316
 317     pixman_gradient_stop_t *stops;
 318     int                     num_stops;
 319     unsigned int            spread;
 320
 321     int                     need_reset;
 322 } pixman_gradient_walker_t;
 323
 324 void
 325 _pixman_gradient_walker_init (pixman_gradient_walker_t *walker,
 326                               gradient_t *              gradient,
 327                               unsigned int              spread);
 328
 329 void
 330 _pixman_gradient_walker_reset (pixman_gradient_walker_t *walker,
 331                                pixman_fixed_32_32_t      pos);
 332
 333 uint32_t
 334 _pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
 335                                pixman_fixed_32_32_t      x);
 336
 337 /*
 338  * Edges
 339  */
 340
 341 #define MAX_ALPHA(n)    ((1 << (n)) - 1)
 342 #define N_Y_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)
 343 #define N_X_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)
 344
 345 #define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC (n))
 346 #define STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
 347
 348 #define Y_FRAC_FIRST(n) (STEP_Y_SMALL (n) / 2)
 349 #define Y_FRAC_LAST(n)  (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
 350
 351 #define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC (n))
 352 #define STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
 353
 354 #define X_FRAC_FIRST(n) (STEP_X_SMALL (n) / 2)
 355 #define X_FRAC_LAST(n)  (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
 356
 357 #define RENDER_SAMPLES_X(x, n)                                          \
 358     ((n) == 1? 0 : (pixman_fixed_frac (x) +                             \
 359                     X_FRAC_FIRST (n)) / STEP_X_SMALL (n))
 360
 361 void
 362 pixman_rasterize_edges_accessors (pixman_image_t *image,
 363                                   pixman_edge_t * l,
 364                                   pixman_edge_t * r,
 365                                   pixman_fixed_t  t,
 366                                   pixman_fixed_t  b);
 367
 368 /*
 369  * Implementations
 370  */
 371
 372 typedef struct pixman_implementation_t pixman_implementation_t;
 373
 374 typedef void (*pixman_combine_32_func_t) (pixman_implementation_t *imp,
 375                                           pixman_op_t              op,
 376                                           uint32_t *               dest,
 377                                           const uint32_t *         src,
 378                                           const uint32_t *         mask,
 379                                           int                      width);
 380
 381 typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,
 382                                           pixman_op_t              op,
 383                                           uint64_t *               dest,
 384                                           const uint64_t *         src,
 385                                           const uint64_t *         mask,
 386                                           int                      width);
 387
 388 typedef void (*pixman_composite_func_t) (pixman_implementation_t *imp,
 389                                          pixman_op_t              op,
 390                                          pixman_image_t *         src,
 391                                          pixman_image_t *         mask,
 392                                          pixman_image_t *         dest,
 393                                          int32_t                  src_x,
 394                                          int32_t                  src_y,
 395                                          int32_t                  mask_x,
 396                                          int32_t                  mask_y,
 397                                          int32_t                  dest_x,
 398                                          int32_t                  dest_y,
 399                                          int32_t                  width,
 400                                          int32_t                  height);
 401 typedef pixman_bool_t (*pixman_blt_func_t) (pixman_implementation_t *imp,
 402                                             uint32_t *               src_bits,
 403                                             uint32_t *               dst_bits,
 404                                             int                      src_stride,
 405                                             int                      dst_stride,
 406                                             int                      src_bpp,
 407                                             int                      dst_bpp,
 408                                             int                      src_x,
 409                                             int                      src_y,
 410                                             int                      dst_x,
 411                                             int                      dst_y,
 412                                             int                      width,
 413                                             int                      height);
 414 typedef pixman_bool_t (*pixman_fill_func_t) (pixman_implementation_t *imp,
 415                                              uint32_t *               bits,
 416                                              int                      stride,
 417                                              int                      bpp,
 418                                              int                      x,
 419                                              int                      y,
 420                                              int                      width,
 421                                              int                      height,
 422                                              uint32_t                 xor);
 423
 424 void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);
 425 void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);
 426
 427 struct pixman_implementation_t
 428 {
 429     pixman_implementation_t *toplevel;
 430     pixman_implementation_t *delegate;
 431
 432     pixman_composite_func_t  composite;
 433     pixman_blt_func_t        blt;
 434     pixman_fill_func_t       fill;
 435
 436     pixman_combine_32_func_t combine_32[PIXMAN_OP_LAST];
 437     pixman_combine_32_func_t combine_32_ca[PIXMAN_OP_LAST];
 438     pixman_combine_64_func_t combine_64[PIXMAN_OP_LAST];
 439     pixman_combine_64_func_t combine_64_ca[PIXMAN_OP_LAST];
 440 };
 441
 442 pixman_implementation_t *
 443 _pixman_implementation_create (pixman_implementation_t *delegate);
 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 void
 474 _pixman_implementation_composite (pixman_implementation_t *imp,
 475                                   pixman_op_t              op,
 476                                   pixman_image_t *         src,
 477                                   pixman_image_t *         mask,
 478                                   pixman_image_t *         dest,
 479                                   int32_t                  src_x,
 480                                   int32_t                  src_y,
 481                                   int32_t                  mask_x,
 482                                   int32_t                  mask_y,
 483                                   int32_t                  dest_x,
 484                                   int32_t                  dest_y,
 485                                   int32_t                  width,
 486                                   int32_t                  height);
 487
 488 pixman_bool_t
 489 _pixman_implementation_blt (pixman_implementation_t *imp,
 490                             uint32_t *               src_bits,
 491                             uint32_t *               dst_bits,
 492                             int                      src_stride,
 493                             int                      dst_stride,
 494                             int                      src_bpp,
 495                             int                      dst_bpp,
 496                             int                      src_x,
 497                             int                      src_y,
 498                             int                      dst_x,
 499                             int                      dst_y,
 500                             int                      width,
 501                             int                      height);
 502
 503 pixman_bool_t
 504 _pixman_implementation_fill (pixman_implementation_t *imp,
 505                              uint32_t *               bits,
 506                              int                      stride,
 507                              int                      bpp,
 508                              int                      x,
 509                              int                      y,
 510                              int                      width,
 511                              int                      height,
 512                              uint32_t                 xor);
 513
 514 /* Specific implementations */
 515 pixman_implementation_t *
 516 _pixman_implementation_create_general (void);
 517
 518 pixman_implementation_t *
 519 _pixman_implementation_create_fast_path (void);
 520
 521 #ifdef USE_MMX
 522 pixman_implementation_t *
 523 _pixman_implementation_create_mmx (void);
 524 #endif
 525
 526 #ifdef USE_SSE2
 527 pixman_implementation_t *
 528 _pixman_implementation_create_sse2 (void);
 529 #endif
 530
 531 #ifdef USE_ARM_SIMD
 532 pixman_implementation_t *
 533 _pixman_implementation_create_arm_simd (void);
 534 #endif
 535
 536 #ifdef USE_ARM_NEON
 537 pixman_implementation_t *
 538 _pixman_implementation_create_arm_neon (void);
 539 #endif
 540
 541 #ifdef USE_VMX
 542 pixman_implementation_t *
 543 _pixman_implementation_create_vmx (void);
 544 #endif
 545
 546 pixman_implementation_t *
 547 _pixman_choose_implementation (void);
 548
 549
 550
 551 /*
 552  * Utilities
 553  */
 554
 555 /* These "formats" both have depth 0, so they
 556  * will never clash with any real ones
 557  */
 558 #define PIXMAN_null             PIXMAN_FORMAT (0, 0, 0, 0, 0, 0)
 559 #define PIXMAN_solid            PIXMAN_FORMAT (0, 1, 0, 0, 0, 0)
 560
 561 #define NEED_COMPONENT_ALPHA            (1 << 0)
 562 #define NEED_PIXBUF                     (1 << 1)
 563 #define NEED_SOLID_MASK                 (1 << 2)
 564
 565 typedef struct
 566 {
 567     pixman_op_t             op;
 568     pixman_format_code_t    src_format;
 569     pixman_format_code_t    mask_format;
 570     pixman_format_code_t    dest_format;
 571     pixman_composite_func_t func;
 572     uint32_t                flags;
 573 } pixman_fast_path_t;
 574
 575 /* Memory allocation helpers */
 576 void *
 577 pixman_malloc_ab (unsigned int n, unsigned int b);
 578
 579 void *
 580 pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);
 581
 582 pixman_bool_t
 583 pixman_multiply_overflows_int (unsigned int a, unsigned int b);
 584
 585 pixman_bool_t
 586 pixman_addition_overflows_int (unsigned int a, unsigned int b);
 587
 588 /* Compositing utilities */
 589 pixman_bool_t
 590 _pixman_run_fast_path (const pixman_fast_path_t *paths,
 591                        pixman_implementation_t * imp,
 592                        pixman_op_t               op,
 593                        pixman_image_t *          src,
 594                        pixman_image_t *          mask,
 595                        pixman_image_t *          dest,
 596                        int32_t                   src_x,
 597                        int32_t                   src_y,
 598                        int32_t                   mask_x,
 599                        int32_t                   mask_y,
 600                        int32_t                   dest_x,
 601                        int32_t                   dest_y,
 602                        int32_t                   width,
 603                        int32_t                   height);
 604
 605 void
 606 _pixman_walk_composite_region (pixman_implementation_t *imp,
 607                                pixman_op_t              op,
 608                                pixman_image_t *         src_image,
 609                                pixman_image_t *         mask_image,
 610                                pixman_image_t *         dst_image,
 611                                int16_t                  src_x,
 612                                int16_t                  src_y,
 613                                int16_t                  mask_x,
 614                                int16_t                  mask_y,
 615                                int16_t                  dest_x,
 616                                int16_t                  dest_y,
 617                                uint16_t                 width,
 618                                uint16_t                 height,
 619                                pixman_composite_func_t  composite_rect);
 620
 621 void
 622 pixman_expand (uint64_t *           dst,
 623                const uint32_t *     src,
 624                pixman_format_code_t format,
 625                int                  width);
 626
 627 void
 628 pixman_contract (uint32_t *      dst,
 629                  const uint64_t *src,
 630                  int             width);
 631
 632
 633 /* Region Helpers */
 634 pixman_bool_t
 635 pixman_region32_copy_from_region16 (pixman_region32_t *dst,
 636                                     pixman_region16_t *src);
 637
 638 pixman_bool_t
 639 pixman_region16_copy_from_region32 (pixman_region16_t *dst,
 640                                     pixman_region32_t *src);
 641
 642
 643 /* Misc macros */
 644
 645 #ifndef FALSE
 646 #   define FALSE 0
 647 #endif
 648
 649 #ifndef TRUE
 650 #   define TRUE 1
 651 #endif
 652
 653 #ifndef MIN
 654 #  define MIN(a, b) ((a < b) ? a : b)
 655 #endif
 656
 657 #ifndef MAX
 658 #  define MAX(a, b) ((a > b) ? a : b)
 659 #endif
 660
 661 /* Integer division that rounds towards -infinity */
 662 #define DIV(a, b)                                          \
 663     ((((a) < 0) == ((b) < 0)) ? (a) / (b) :                \
 664      ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
 665
 666 /* Modulus that produces the remainder wrt. DIV */
 667 #define MOD(a, b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
 668
 669 #define CLIP(v, low, high) ((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))
 670
 671 /* Conversion between 8888 and 0565 */
 672
 673 #define CONVERT_8888_TO_0565(s)                                         \
 674     ((((s) >> 3) & 0x001f) |                                            \
 675      (((s) >> 5) & 0x07e0) |                                            \
 676      (((s) >> 8) & 0xf800))
 677
 678 #define CONVERT_0565_TO_0888(s)                                         \
 679     (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) |                       \
 680      ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) |                   \
 681      ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
 682
 683 #define PIXMAN_FORMAT_IS_WIDE(f)                                        \
 684     (PIXMAN_FORMAT_A (f) > 8 ||                                         \
 685      PIXMAN_FORMAT_R (f) > 8 ||                                         \
 686      PIXMAN_FORMAT_G (f) > 8 ||                                         \
 687      PIXMAN_FORMAT_B (f) > 8)
 688
 689 /*
 690  * Various debugging code
 691  */
 692
 693 #undef DEBUG
 694 #define DEBUG 0
 695
 696 #if DEBUG
 697
 698 #define return_if_fail(expr)                                            \
 699     do                                                                  \
 700     {                                                                   \
 701         if (!(expr))                                                    \
 702         {                                                               \
 703             fprintf (stderr, "In %s: %s failed\n", FUNC, # expr);       \
 704             return;                                                     \
 705         }                                                               \
 706     }                                                                   \
 707     while (0)
 708
 709 #define return_val_if_fail(expr, retval)                                \
 710     do                                                                  \
 711     {                                                                   \
 712         if (!(expr))                                                    \
 713         {                                                               \
 714             fprintf (stderr, "In %s: %s failed\n", FUNC, # expr);       \
 715             return (retval);                                            \
 716         }                                                               \
 717     }                                                                   \
 718     while (0)
 719
 720 #else
 721
 722 #define return_if_fail(expr)                                            \
 723     do                                                                  \
 724     {                                                                   \
 725         if (!(expr))                                                    \
 726             return;                                                     \
 727     }                                                                   \
 728     while (0)
 729
 730 #define return_val_if_fail(expr, retval)                                \
 731     do                                                                  \
 732     {                                                                   \
 733         if (!(expr))                                                    \
 734             return (retval);                                            \
 735     }                                                                   \
 736     while (0)
 737
 738 #endif
 739
 740 /*
 741  * Timers
 742  */
 743
 744 #ifdef PIXMAN_TIMERS
 745
 746 static inline uint64_t
 747 oil_profile_stamp_rdtsc (void)
 748 {
 749     uint64_t ts;
 750
 751     __asm__ __volatile__ ("rdtsc\n" : "=A" (ts));
 752     return ts;
 753 }
 754
 755 #define OIL_STAMP oil_profile_stamp_rdtsc
 756
 757 typedef struct pixman_timer_t pixman_timer_t;
 758
 759 struct pixman_timer_t
 760 {
 761     int             initialized;
 762     const char *    name;
 763     uint64_t        n_times;
 764     uint64_t        total;
 765     pixman_timer_t *next;
 766 };
 767
 768 extern int timer_defined;
 769
 770 void pixman_timer_register (pixman_timer_t *timer);
 771
 772 #define TIMER_BEGIN(tname)                                              \
 773     {                                                                   \
 774         static pixman_timer_t timer ## tname;                           \
 775         uint64_t              begin ## tname;                           \
 776                                                                         \
 777         if (!timer ## tname.initialized)                                \
 778         {                                                               \
 779             timer ## tname.initialized = 1;                             \
 780             timer ## tname.name = # tname;                              \
 781             pixman_timer_register (&timer ## tname);                    \
 782         }                                                               \
 783                                                                         \
 784         timer ## tname.n_times++;                                       \
 785         begin ## tname = OIL_STAMP ();
 786
 787 #define TIMER_END(tname)                                                \
 788     timer ## tname.total += OIL_STAMP () - begin ## tname;              \
 789     }
 790
 791 #endif /* PIXMAN_TIMERS */
 792
 793 #endif /* PIXMAN_PRIVATE_H */