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