pixman/pixman-private.h

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