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 uint32_t *(* pixman_iter_get_scanline_t) (pixman_iter_t *iter, const uint32_t *mask);
 187 typedef void      (* pixman_iter_write_back_t)   (pixman_iter_t *iter);
 188
 189 typedef enum
 190 {
 191     ITER_NARROW =               (1 << 0),
 192
 193     /* "Localized alpha" is when the alpha channel is used only to compute
 194      * the alpha value of the destination. This means that the computation
 195      * of the RGB values of the result is independent of the alpha value.
 196      *
 197      * For example, the OVER operator has localized alpha for the
 198      * destination, because the RGB values of the result can be computed
 199      * without knowing the destination alpha. Similarly, ADD has localized
 200      * alpha for both source and destination because the RGB values of the
 201      * result can be computed without knowing the alpha value of source or
 202      * destination.
 203      *
 204      * When he destination is xRGB, this is useful knowledge, because then
 205      * we can treat it as if it were ARGB, which means in some cases we can
 206      * avoid copying it to a temporary buffer.
 207      */
 208     ITER_LOCALIZED_ALPHA =      (1 << 1),
 209     ITER_IGNORE_ALPHA =         (1 << 2),
 210     ITER_IGNORE_RGB =           (1 << 3)
 211 } iter_flags_t;
 212
 213 struct pixman_iter_t
 214 {
 215     /* These are initialized by _pixman_implementation_{src,dest}_init */
 216     pixman_image_t *            image;
 217     uint32_t *                  buffer;
 218     int                         x, y;
 219     int                         width;
 220     int                         height;
 221     iter_flags_t                flags;
 222
 223     /* These function pointers are initialized by the implementation */
 224     pixman_iter_get_scanline_t  get_scanline;
 225     pixman_iter_write_back_t    write_back;
 226
 227     /* These fields are scratch data that implementations can use */
 228     uint8_t *                   bits;
 229     int                         stride;
 230 };
 231
 232 void
 233 _pixman_bits_image_setup_accessors (bits_image_t *image);
 234
 235 void
 236 _pixman_bits_image_src_iter_init (pixman_image_t *image, pixman_iter_t *iter);
 237
 238 void
 239 _pixman_bits_image_dest_iter_init (pixman_image_t *image, pixman_iter_t *iter);
 240
 241 void
 242 _pixman_solid_fill_iter_init (pixman_image_t *image, pixman_iter_t  *iter);
 243
 244 void
 245 _pixman_linear_gradient_iter_init (pixman_image_t *image, pixman_iter_t  *iter);
 246
 247 void
 248 _pixman_radial_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter);
 249
 250 void
 251 _pixman_conical_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter);
 252
 253 void
 254 _pixman_image_init (pixman_image_t *image);
 255
 256 pixman_bool_t
 257 _pixman_bits_image_init (pixman_image_t *     image,
 258                          pixman_format_code_t format,
 259                          int                  width,
 260                          int                  height,
 261                          uint32_t *           bits,
 262                          int                  rowstride);
 263 pixman_bool_t
 264 _pixman_image_fini (pixman_image_t *image);
 265
 266 pixman_image_t *
 267 _pixman_image_allocate (void);
 268
 269 pixman_bool_t
 270 _pixman_init_gradient (gradient_t *                  gradient,
 271                        const pixman_gradient_stop_t *stops,
 272                        int                           n_stops);
 273 void
 274 _pixman_image_reset_clip_region (pixman_image_t *image);
 275
 276 void
 277 _pixman_image_validate (pixman_image_t *image);
 278
 279 #define PIXMAN_IMAGE_GET_LINE(image, x, y, type, out_stride, line, mul) \
 280     do                                                                  \
 281     {                                                                   \
 282         uint32_t *__bits__;                                             \
 283         int       __stride__;                                           \
 284                                                                         \
 285         __bits__ = image->bits.bits;                                    \
 286         __stride__ = image->bits.rowstride;                             \
 287         (out_stride) =                                                  \
 288             __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type); \
 289         (line) =                                                        \
 290             ((type *) __bits__) + (out_stride) * (y) + (mul) * (x);     \
 291     } while (0)
 292
 293 /*
 294  * Gradient walker
 295  */
 296 typedef struct
 297 {
 298     uint32_t                left_ag;
 299     uint32_t                left_rb;
 300     uint32_t                right_ag;
 301     uint32_t                right_rb;
 302     pixman_fixed_t          left_x;
 303     pixman_fixed_t          right_x;
 304     pixman_fixed_t          stepper;
 305
 306     pixman_gradient_stop_t *stops;
 307     int                     num_stops;
 308     pixman_repeat_t         repeat;
 309
 310     pixman_bool_t           need_reset;
 311 } pixman_gradient_walker_t;
 312
 313 void
 314 _pixman_gradient_walker_init (pixman_gradient_walker_t *walker,
 315                               gradient_t *              gradient,
 316                               pixman_repeat_t           repeat);
 317
 318 void
 319 _pixman_gradient_walker_reset (pixman_gradient_walker_t *walker,
 320                                pixman_fixed_48_16_t      pos);
 321
 322 uint32_t
 323 _pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
 324                                pixman_fixed_48_16_t      x);
 325
 326 /*
 327  * Edges
 328  */
 329
 330 #define MAX_ALPHA(n)    ((1 << (n)) - 1)
 331 #define N_Y_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)
 332 #define N_X_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)
 333
 334 #define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC (n))
 335 #define STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
 336
 337 #define Y_FRAC_FIRST(n) (STEP_Y_BIG (n) / 2)
 338 #define Y_FRAC_LAST(n)  (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
 339
 340 #define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC (n))
 341 #define STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
 342
 343 #define X_FRAC_FIRST(n) (STEP_X_BIG (n) / 2)
 344 #define X_FRAC_LAST(n)  (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
 345
 346 #define RENDER_SAMPLES_X(x, n)                                          \
 347     ((n) == 1? 0 : (pixman_fixed_frac (x) +                             \
 348                     X_FRAC_FIRST (n)) / STEP_X_SMALL (n))
 349
 350 void
 351 pixman_rasterize_edges_accessors (pixman_image_t *image,
 352                                   pixman_edge_t * l,
 353                                   pixman_edge_t * r,
 354                                   pixman_fixed_t  t,
 355                                   pixman_fixed_t  b);
 356
 357 /*
 358  * Implementations
 359  */
 360 typedef struct pixman_implementation_t pixman_implementation_t;
 361
 362 typedef struct
 363 {
 364     pixman_op_t              op;
 365     pixman_image_t *         src_image;
 366     pixman_image_t *         mask_image;
 367     pixman_image_t *         dest_image;
 368     int32_t                  src_x;
 369     int32_t                  src_y;
 370     int32_t                  mask_x;
 371     int32_t                  mask_y;
 372     int32_t                  dest_x;
 373     int32_t                  dest_y;
 374     int32_t                  width;
 375     int32_t                  height;
 376
 377     uint32_t                 src_flags;
 378     uint32_t                 mask_flags;
 379     uint32_t                 dest_flags;
 380 } pixman_composite_info_t;
 381
 382 #define PIXMAN_COMPOSITE_ARGS(info)                                     \
 383     MAYBE_UNUSED pixman_op_t        op = info->op;                      \
 384     MAYBE_UNUSED pixman_image_t *   src_image = info->src_image;        \
 385     MAYBE_UNUSED pixman_image_t *   mask_image = info->mask_image;      \
 386     MAYBE_UNUSED pixman_image_t *   dest_image = info->dest_image;      \
 387     MAYBE_UNUSED int32_t            src_x = info->src_x;                \
 388     MAYBE_UNUSED int32_t            src_y = info->src_y;                \
 389     MAYBE_UNUSED int32_t            mask_x = info->mask_x;              \
 390     MAYBE_UNUSED int32_t            mask_y = info->mask_y;              \
 391     MAYBE_UNUSED int32_t            dest_x = info->dest_x;              \
 392     MAYBE_UNUSED int32_t            dest_y = info->dest_y;              \
 393     MAYBE_UNUSED int32_t            width = info->width;                \
 394     MAYBE_UNUSED int32_t            height = info->height
 395
 396 typedef void (*pixman_combine_32_func_t) (pixman_implementation_t *imp,
 397                                           pixman_op_t              op,
 398                                           uint32_t *               dest,
 399                                           const uint32_t *         src,
 400                                           const uint32_t *         mask,
 401                                           int                      width);
 402
 403 typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,
 404                                           pixman_op_t              op,
 405                                           uint64_t *               dest,
 406                                           const uint64_t *         src,
 407                                           const uint64_t *         mask,
 408                                           int                      width);
 409
 410 typedef void (*pixman_composite_func_t) (pixman_implementation_t *imp,
 411                                          pixman_composite_info_t *info);
 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                      dest_x,
 422                                             int                      dest_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
 437 void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);
 438 void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);
 439
 440 typedef struct
 441 {
 442     pixman_op_t             op;
 443     pixman_format_code_t    src_format;
 444     uint32_t                src_flags;
 445     pixman_format_code_t    mask_format;
 446     uint32_t                mask_flags;
 447     pixman_format_code_t    dest_format;
 448     uint32_t                dest_flags;
 449     pixman_composite_func_t func;
 450 } pixman_fast_path_t;
 451
 452 struct pixman_implementation_t
 453 {
 454     pixman_implementation_t *   toplevel;
 455     pixman_implementation_t *   delegate;
 456     const pixman_fast_path_t *  fast_paths;
 457
 458     pixman_blt_func_t           blt;
 459     pixman_fill_func_t          fill;
 460     pixman_iter_init_func_t     src_iter_init;
 461     pixman_iter_init_func_t     dest_iter_init;
 462
 463     pixman_combine_32_func_t    combine_32[PIXMAN_N_OPERATORS];
 464     pixman_combine_32_func_t    combine_32_ca[PIXMAN_N_OPERATORS];
 465     pixman_combine_64_func_t    combine_64[PIXMAN_N_OPERATORS];
 466     pixman_combine_64_func_t    combine_64_ca[PIXMAN_N_OPERATORS];
 467 };
 468
 469 uint32_t
 470 _pixman_image_get_solid (pixman_implementation_t *imp,
 471                          pixman_image_t *         image,
 472                          pixman_format_code_t     format);
 473
 474 pixman_implementation_t *
 475 _pixman_implementation_create (pixman_implementation_t *delegate,
 476                                const pixman_fast_path_t *fast_paths);
 477
 478 void
 479 _pixman_implementation_combine_32 (pixman_implementation_t *imp,
 480                                    pixman_op_t              op,
 481                                    uint32_t *               dest,
 482                                    const uint32_t *         src,
 483                                    const uint32_t *         mask,
 484                                    int                      width);
 485 void
 486 _pixman_implementation_combine_64 (pixman_implementation_t *imp,
 487                                    pixman_op_t              op,
 488                                    uint64_t *               dest,
 489                                    const uint64_t *         src,
 490                                    const uint64_t *         mask,
 491                                    int                      width);
 492 void
 493 _pixman_implementation_combine_32_ca (pixman_implementation_t *imp,
 494                                       pixman_op_t              op,
 495                                       uint32_t *               dest,
 496                                       const uint32_t *         src,
 497                                       const uint32_t *         mask,
 498                                       int                      width);
 499 void
 500 _pixman_implementation_combine_64_ca (pixman_implementation_t *imp,
 501                                       pixman_op_t              op,
 502                                       uint64_t *               dest,
 503                                       const uint64_t *         src,
 504                                       const uint64_t *         mask,
 505                                       int                      width);
 506
 507 pixman_bool_t
 508 _pixman_implementation_blt (pixman_implementation_t *imp,
 509                             uint32_t *               src_bits,
 510                             uint32_t *               dst_bits,
 511                             int                      src_stride,
 512                             int                      dst_stride,
 513                             int                      src_bpp,
 514                             int                      dst_bpp,
 515                             int                      src_x,
 516                             int                      src_y,
 517                             int                      dest_x,
 518                             int                      dest_y,
 519                             int                      width,
 520                             int                      height);
 521
 522 pixman_bool_t
 523 _pixman_implementation_fill (pixman_implementation_t *imp,
 524                              uint32_t *               bits,
 525                              int                      stride,
 526                              int                      bpp,
 527                              int                      x,
 528                              int                      y,
 529                              int                      width,
 530                              int                      height,
 531                              uint32_t                 xor);
 532
 533 void
 534 _pixman_implementation_src_iter_init (pixman_implementation_t       *imp,
 535                                       pixman_iter_t                 *iter,
 536                                       pixman_image_t                *image,
 537                                       int                            x,
 538                                       int                            y,
 539                                       int                            width,
 540                                       int                            height,
 541                                       uint8_t                       *buffer,
 542                                       iter_flags_t                   flags);
 543
 544 void
 545 _pixman_implementation_dest_iter_init (pixman_implementation_t       *imp,
 546                                        pixman_iter_t                 *iter,
 547                                        pixman_image_t                *image,
 548                                        int                            x,
 549                                        int                            y,
 550                                        int                            width,
 551                                        int                            height,
 552                                        uint8_t                       *buffer,
 553                                        iter_flags_t                   flags);
 554
 555 /* Specific implementations */
 556 pixman_implementation_t *
 557 _pixman_implementation_create_general (void);
 558
 559 pixman_implementation_t *
 560 _pixman_implementation_create_fast_path (pixman_implementation_t *fallback);
 561
 562 pixman_implementation_t *
 563 _pixman_implementation_create_noop (pixman_implementation_t *fallback);
 564
 565 #if defined USE_X86_MMX || defined USE_ARM_IWMMXT
 566 pixman_implementation_t *
 567 _pixman_implementation_create_mmx (pixman_implementation_t *fallback);
 568 #endif
 569
 570 #ifdef USE_SSE2
 571 pixman_implementation_t *
 572 _pixman_implementation_create_sse2 (pixman_implementation_t *fallback);
 573 #endif
 574
 575 #ifdef USE_ARM_SIMD
 576 pixman_implementation_t *
 577 _pixman_implementation_create_arm_simd (pixman_implementation_t *fallback);
 578 #endif
 579
 580 #ifdef USE_ARM_NEON
 581 pixman_implementation_t *
 582 _pixman_implementation_create_arm_neon (pixman_implementation_t *fallback);
 583 #endif
 584
 585 #ifdef USE_VMX
 586 pixman_implementation_t *
 587 _pixman_implementation_create_vmx (pixman_implementation_t *fallback);
 588 #endif
 589
 590 pixman_implementation_t *
 591 _pixman_choose_implementation (void);
 592
 593
 594
 595 /*
 596  * Utilities
 597  */
 598 uint32_t *
 599 _pixman_iter_get_scanline_noop (pixman_iter_t *iter, const uint32_t *mask);
 600
 601 /* These "formats" all have depth 0, so they
 602  * will never clash with any real ones
 603  */
 604 #define PIXMAN_null             PIXMAN_FORMAT (0, 0, 0, 0, 0, 0)
 605 #define PIXMAN_solid            PIXMAN_FORMAT (0, 1, 0, 0, 0, 0)
 606 #define PIXMAN_pixbuf           PIXMAN_FORMAT (0, 2, 0, 0, 0, 0)
 607 #define PIXMAN_rpixbuf          PIXMAN_FORMAT (0, 3, 0, 0, 0, 0)
 608 #define PIXMAN_unknown          PIXMAN_FORMAT (0, 4, 0, 0, 0, 0)
 609 #define PIXMAN_any              PIXMAN_FORMAT (0, 5, 0, 0, 0, 0)
 610
 611 #define PIXMAN_OP_any           (PIXMAN_N_OPERATORS + 1)
 612
 613 #define FAST_PATH_ID_TRANSFORM                  (1 <<  0)
 614 #define FAST_PATH_NO_ALPHA_MAP                  (1 <<  1)
 615 #define FAST_PATH_NO_CONVOLUTION_FILTER         (1 <<  2)
 616 #define FAST_PATH_NO_PAD_REPEAT                 (1 <<  3)
 617 #define FAST_PATH_NO_REFLECT_REPEAT             (1 <<  4)
 618 #define FAST_PATH_NO_ACCESSORS                  (1 <<  5)
 619 #define FAST_PATH_NARROW_FORMAT                 (1 <<  6)
 620 #define FAST_PATH_COMPONENT_ALPHA               (1 <<  8)
 621 #define FAST_PATH_SAMPLES_OPAQUE                (1 <<  7)
 622 #define FAST_PATH_UNIFIED_ALPHA                 (1 <<  9)
 623 #define FAST_PATH_SCALE_TRANSFORM               (1 << 10)
 624 #define FAST_PATH_NEAREST_FILTER                (1 << 11)
 625 #define FAST_PATH_HAS_TRANSFORM                 (1 << 12)
 626 #define FAST_PATH_IS_OPAQUE                     (1 << 13)
 627 #define FAST_PATH_NO_NORMAL_REPEAT              (1 << 14)
 628 #define FAST_PATH_NO_NONE_REPEAT                (1 << 15)
 629 #define FAST_PATH_X_UNIT_POSITIVE               (1 << 16)
 630 #define FAST_PATH_AFFINE_TRANSFORM              (1 << 17)
 631 #define FAST_PATH_Y_UNIT_ZERO                   (1 << 18)
 632 #define FAST_PATH_BILINEAR_FILTER               (1 << 19)
 633 #define FAST_PATH_ROTATE_90_TRANSFORM           (1 << 20)
 634 #define FAST_PATH_ROTATE_180_TRANSFORM          (1 << 21)
 635 #define FAST_PATH_ROTATE_270_TRANSFORM          (1 << 22)
 636 #define FAST_PATH_SAMPLES_COVER_CLIP_NEAREST    (1 << 23)
 637 #define FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR   (1 << 24)
 638 #define FAST_PATH_BITS_IMAGE                    (1 << 25)
 639
 640 #define FAST_PATH_PAD_REPEAT                                            \
 641     (FAST_PATH_NO_NONE_REPEAT           |                               \
 642      FAST_PATH_NO_NORMAL_REPEAT         |                               \
 643      FAST_PATH_NO_REFLECT_REPEAT)
 644
 645 #define FAST_PATH_NORMAL_REPEAT                                         \
 646     (FAST_PATH_NO_NONE_REPEAT           |                               \
 647      FAST_PATH_NO_PAD_REPEAT            |                               \
 648      FAST_PATH_NO_REFLECT_REPEAT)
 649
 650 #define FAST_PATH_NONE_REPEAT                                           \
 651     (FAST_PATH_NO_NORMAL_REPEAT         |                               \
 652      FAST_PATH_NO_PAD_REPEAT            |                               \
 653      FAST_PATH_NO_REFLECT_REPEAT)
 654
 655 #define FAST_PATH_REFLECT_REPEAT                                        \
 656     (FAST_PATH_NO_NONE_REPEAT           |                               \
 657      FAST_PATH_NO_NORMAL_REPEAT         |                               \
 658      FAST_PATH_NO_PAD_REPEAT)
 659
 660 #define FAST_PATH_STANDARD_FLAGS                                        \
 661     (FAST_PATH_NO_CONVOLUTION_FILTER    |                               \
 662      FAST_PATH_NO_ACCESSORS             |                               \
 663      FAST_PATH_NO_ALPHA_MAP             |                               \
 664      FAST_PATH_NARROW_FORMAT)
 665
 666 #define FAST_PATH_STD_DEST_FLAGS                                        \
 667     (FAST_PATH_NO_ACCESSORS             |                               \
 668      FAST_PATH_NO_ALPHA_MAP             |                               \
 669      FAST_PATH_NARROW_FORMAT)
 670
 671 #define SOURCE_FLAGS(format)                                            \
 672     (FAST_PATH_STANDARD_FLAGS |                                         \
 673      ((PIXMAN_ ## format == PIXMAN_solid) ?                             \
 674       0 : (FAST_PATH_SAMPLES_COVER_CLIP_NEAREST | FAST_PATH_NEAREST_FILTER | FAST_PATH_ID_TRANSFORM)))
 675
 676 #define MASK_FLAGS(format, extra)                                       \
 677     ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))
 678
 679 #define FAST_PATH(op, src, src_flags, mask, mask_flags, dest, dest_flags, func) \
 680     PIXMAN_OP_ ## op,                                                   \
 681     PIXMAN_ ## src,                                                     \
 682     src_flags,                                                          \
 683     PIXMAN_ ## mask,                                                    \
 684     mask_flags,                                                         \
 685     PIXMAN_ ## dest,                                                    \
 686     dest_flags,                                                         \
 687     func
 688
 689 #define PIXMAN_STD_FAST_PATH(op, src, mask, dest, func)                 \
 690     { FAST_PATH (                                                       \
 691             op,                                                         \
 692             src,  SOURCE_FLAGS (src),                                   \
 693             mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA),           \
 694             dest, FAST_PATH_STD_DEST_FLAGS,                             \
 695             func) }
 696
 697 #define PIXMAN_STD_FAST_PATH_CA(op, src, mask, dest, func)              \
 698     { FAST_PATH (                                                       \
 699             op,                                                         \
 700             src,  SOURCE_FLAGS (src),                                   \
 701             mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA),         \
 702             dest, FAST_PATH_STD_DEST_FLAGS,                             \
 703             func) }
 704
 705 /* Memory allocation helpers */
 706 void *
 707 pixman_malloc_ab (unsigned int n, unsigned int b);
 708
 709 void *
 710 pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);
 711
 712 pixman_bool_t
 713 _pixman_multiply_overflows_size (size_t a, size_t b);
 714
 715 pixman_bool_t
 716 _pixman_multiply_overflows_int (unsigned int a, unsigned int b);
 717
 718 pixman_bool_t
 719 _pixman_addition_overflows_int (unsigned int a, unsigned int b);
 720
 721 /* Compositing utilities */
 722 void
 723 pixman_expand (uint64_t *           dst,
 724                const uint32_t *     src,
 725                pixman_format_code_t format,
 726                int                  width);
 727
 728 void
 729 pixman_contract (uint32_t *      dst,
 730                  const uint64_t *src,
 731                  int             width);
 732
 733 pixman_bool_t
 734 _pixman_lookup_composite_function (pixman_implementation_t     *toplevel,
 735                                    pixman_op_t                  op,
 736                                    pixman_format_code_t         src_format,
 737                                    uint32_t                     src_flags,
 738                                    pixman_format_code_t         mask_format,
 739                                    uint32_t                     mask_flags,
 740                                    pixman_format_code_t         dest_format,
 741                                    uint32_t                     dest_flags,
 742                                    pixman_implementation_t    **out_imp,
 743                                    pixman_composite_func_t     *out_func);
 744
 745 /* Region Helpers */
 746 pixman_bool_t
 747 pixman_region32_copy_from_region16 (pixman_region32_t *dst,
 748                                     pixman_region16_t *src);
 749
 750 pixman_bool_t
 751 pixman_region16_copy_from_region32 (pixman_region16_t *dst,
 752                                     pixman_region32_t *src);
 753
 754
 755 /* Misc macros */
 756
 757 #ifndef FALSE
 758 #   define FALSE 0
 759 #endif
 760
 761 #ifndef TRUE
 762 #   define TRUE 1
 763 #endif
 764
 765 #ifndef MIN
 766 #  define MIN(a, b) ((a < b) ? a : b)
 767 #endif
 768
 769 #ifndef MAX
 770 #  define MAX(a, b) ((a > b) ? a : b)
 771 #endif
 772
 773 /* Integer division that rounds towards -infinity */
 774 #define DIV(a, b)                                          \
 775     ((((a) < 0) == ((b) < 0)) ? (a) / (b) :                \
 776      ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
 777
 778 /* Modulus that produces the remainder wrt. DIV */
 779 #define MOD(a, b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
 780
 781 #define CLIP(v, low, high) ((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))
 782
 783 /* Conversion between 8888 and 0565 */
 784
 785 #define CONVERT_8888_TO_0565(s)                                         \
 786     ((((s) >> 3) & 0x001f) |                                            \
 787      (((s) >> 5) & 0x07e0) |                                            \
 788      (((s) >> 8) & 0xf800))
 789
 790 #define CONVERT_0565_TO_0888(s)                                         \
 791     (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) |                       \
 792      ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) |                   \
 793      ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
 794
 795 #define CONVERT_0565_TO_8888(s) (CONVERT_0565_TO_0888(s) | 0xff000000)
 796
 797 /* Trivial versions that are useful in macros */
 798 #define CONVERT_8888_TO_8888(s) (s)
 799 #define CONVERT_x888_TO_8888(s) ((s) | 0xff000000)
 800 #define CONVERT_0565_TO_0565(s) (s)
 801
 802 #define PIXMAN_FORMAT_IS_WIDE(f)                                        \
 803     (PIXMAN_FORMAT_A (f) > 8 ||                                         \
 804      PIXMAN_FORMAT_R (f) > 8 ||                                         \
 805      PIXMAN_FORMAT_G (f) > 8 ||                                         \
 806      PIXMAN_FORMAT_B (f) > 8)
 807
 808 #ifdef WORDS_BIGENDIAN
 809 #   define SCREEN_SHIFT_LEFT(x,n)       ((x) << (n))
 810 #   define SCREEN_SHIFT_RIGHT(x,n)      ((x) >> (n))
 811 #else
 812 #   define SCREEN_SHIFT_LEFT(x,n)       ((x) >> (n))
 813 #   define SCREEN_SHIFT_RIGHT(x,n)      ((x) << (n))
 814 #endif
 815
 816 static force_inline uint32_t
 817 unorm_to_unorm (uint32_t val, int from_bits, int to_bits)
 818 {
 819     uint32_t result;
 820
 821     if (from_bits == 0)
 822         return 0;
 823
 824     /* Delete any extra bits */
 825     val &= ((1 << from_bits) - 1);
 826
 827     if (from_bits >= to_bits)
 828         return val >> (from_bits - to_bits);
 829
 830     /* Start out with the high bit of val in the high bit of result. */
 831     result = val << (to_bits - from_bits);
 832
 833     /* Copy the bits in result, doubling the number of bits each time, until
 834      * we fill all to_bits. Unrolled manually because from_bits and to_bits
 835      * are usually known statically, so the compiler can turn all of this
 836      * into a few shifts.
 837      */
 838 #define REPLICATE()                                                     \
 839     do                                                                  \
 840     {                                                                   \
 841         if (from_bits < to_bits)                                        \
 842         {                                                               \
 843             result |= result >> from_bits;                              \
 844                                                                         \
 845             from_bits *= 2;                                             \
 846         }                                                               \
 847     }                                                                   \
 848     while (0)
 849
 850     REPLICATE();
 851     REPLICATE();
 852     REPLICATE();
 853     REPLICATE();
 854     REPLICATE();
 855
 856     return result;
 857 }
 858
 859 /*
 860  * Various debugging code
 861  */
 862
 863 #undef DEBUG
 864
 865 #define COMPILE_TIME_ASSERT(x)                                          \
 866     do { typedef int compile_time_assertion [(x)?1:-1]; } while (0)
 867
 868 /* Turn on debugging depending on what type of release this is
 869  */
 870 #if (((PIXMAN_VERSION_MICRO % 2) == 0) && ((PIXMAN_VERSION_MINOR % 2) == 1))
 871
 872 /* Debugging gets turned on for development releases because these
 873  * are the things that end up in bleeding edge distributions such
 874  * as Rawhide etc.
 875  *
 876  * For performance reasons we don't turn it on for stable releases or
 877  * random git checkouts. (Random git checkouts are often used for
 878  * performance work).
 879  */
 880
 881 #    define DEBUG
 882
 883 #endif
 884
 885 #ifdef DEBUG
 886
 887 void
 888 _pixman_log_error (const char *function, const char *message);
 889
 890 #define return_if_fail(expr)                                            \
 891     do                                                                  \
 892     {                                                                   \
 893         if (!(expr))                                                    \
 894         {                                                               \
 895             _pixman_log_error (FUNC, "The expression " # expr " was false"); \
 896             return;                                                     \
 897         }                                                               \
 898     }                                                                   \
 899     while (0)
 900
 901 #define return_val_if_fail(expr, retval)                                \
 902     do                                                                  \
 903     {                                                                   \
 904         if (!(expr))                                                    \
 905         {                                                               \
 906             _pixman_log_error (FUNC, "The expression " # expr " was false"); \
 907             return (retval);                                            \
 908         }                                                               \
 909     }                                                                   \
 910     while (0)
 911
 912 #define critical_if_fail(expr)                                          \
 913     do                                                                  \
 914     {                                                                   \
 915         if (!(expr))                                                    \
 916             _pixman_log_error (FUNC, "The expression " # expr " was false"); \
 917     }                                                                   \
 918     while (0)
 919
 920
 921 #else
 922
 923 #define _pixman_log_error(f,m) do { } while (0)                         \
 924
 925 #define return_if_fail(expr)                                            \
 926     do                                                                  \
 927     {                                                                   \
 928         if (!(expr))                                                    \
 929             return;                                                     \
 930     }                                                                   \
 931     while (0)
 932
 933 #define return_val_if_fail(expr, retval)                                \
 934     do                                                                  \
 935     {                                                                   \
 936         if (!(expr))                                                    \
 937             return (retval);                                            \
 938     }                                                                   \
 939     while (0)
 940
 941 #define critical_if_fail(expr)                                          \
 942     do                                                                  \
 943     {                                                                   \
 944     }                                                                   \
 945     while (0)
 946 #endif
 947
 948 /*
 949  * Timers
 950  */
 951
 952 #ifdef PIXMAN_TIMERS
 953
 954 static inline uint64_t
 955 oil_profile_stamp_rdtsc (void)
 956 {
 957     uint64_t ts;
 958
 959     __asm__ __volatile__ ("rdtsc\n" : "=A" (ts));
 960     return ts;
 961 }
 962
 963 #define OIL_STAMP oil_profile_stamp_rdtsc
 964
 965 typedef struct pixman_timer_t pixman_timer_t;
 966
 967 struct pixman_timer_t
 968 {
 969     int             initialized;
 970     const char *    name;
 971     uint64_t        n_times;
 972     uint64_t        total;
 973     pixman_timer_t *next;
 974 };
 975
 976 extern int timer_defined;
 977
 978 void pixman_timer_register (pixman_timer_t *timer);
 979
 980 #define TIMER_BEGIN(tname)                                              \
 981     {                                                                   \
 982         static pixman_timer_t timer ## tname;                           \
 983         uint64_t              begin ## tname;                           \
 984                                                                         \
 985         if (!timer ## tname.initialized)                                \
 986         {                                                               \
 987             timer ## tname.initialized = 1;                             \
 988             timer ## tname.name = # tname;                              \
 989             pixman_timer_register (&timer ## tname);                    \
 990         }                                                               \
 991                                                                         \
 992         timer ## tname.n_times++;                                       \
 993         begin ## tname = OIL_STAMP ();
 994
 995 #define TIMER_END(tname)                                                \
 996     timer ## tname.total += OIL_STAMP () - begin ## tname;              \
 997     }
 998
 999 #endif /* PIXMAN_TIMERS */
1000
1001 #endif /* PIXMAN_PRIVATE_H */