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