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