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