pixman/pixman.h

   1 /***********************************************************
   2
   3 Copyright 1987, 1998  The Open Group
   4
   5 Permission to use, copy, modify, distribute, and sell this software and its
   6 documentation for any purpose is hereby granted without fee, provided that
   7 the above copyright notice appear in all copies and that both that
   8 copyright notice and this permission notice appear in supporting
   9 documentation.
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  18 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20
  21 Except as contained in this notice, the name of The Open Group shall not be
  22 used in advertising or otherwise to promote the sale, use or other dealings
  23 in this Software without prior written authorization from The Open Group.
  24
  25 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  26
  27                         All Rights Reserved
  28
  29 Permission to use, copy, modify, and distribute this software and its
  30 documentation for any purpose and without fee is hereby granted,
  31 provided that the above copyright notice appear in all copies and that
  32 both that copyright notice and this permission notice appear in
  33 supporting documentation, and that the name of Digital not be
  34 used in advertising or publicity pertaining to distribution of the
  35 software without specific, written prior permission.
  36
  37 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  38 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  39 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  40 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  41 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  42 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  43 SOFTWARE.
  44
  45 ******************************************************************/
  46 /*
  47  * Copyright © 1998, 2004 Keith Packard
  48  * Copyright   2007 Red Hat, Inc.
  49  *
  50  * Permission to use, copy, modify, distribute, and sell this software and its
  51  * documentation for any purpose is hereby granted without fee, provided that
  52  * the above copyright notice appear in all copies and that both that
  53  * copyright notice and this permission notice appear in supporting
  54  * documentation, and that the name of Keith Packard not be used in
  55  * advertising or publicity pertaining to distribution of the software without
  56  * specific, written prior permission.  Keith Packard makes no
  57  * representations about the suitability of this software for any purpose.  It
  58  * is provided "as is" without express or implied warranty.
  59  *
  60  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  61  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  62  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  63  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  64  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  65  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  66  * PERFORMANCE OF THIS SOFTWARE.
  67  */
  68
  69 #ifndef PIXMAN_H__
  70 #define PIXMAN_H__
  71
  72 /*
  73  * Standard integers
  74  */
  75 #if defined (__SVR4) && defined (__sun)
  76 #  include <sys/int_types.h>
  77 #  include <stdint.h>
  78 #elif defined (__OpenBSD__)
  79 #  include <inttypes.h>
  80 #elif defined (_MSC_VER)
  81 typedef __int8 int8_t;
  82 typedef unsigned __int8 uint8_t;
  83 typedef __int16 int16_t;
  84 typedef unsigned __int16 uint16_t;
  85 typedef __int32 int32_t;
  86 typedef unsigned __int32 uint32_t;
  87 typedef __int64 int64_t;
  88 typedef unsigned __int64 uint64_t;
  89 #else
  90 #  include <stdint.h>
  91 #endif
  92
  93 /* GCC visibility */
  94 #if defined(__GNUC__) && __GNUC__ >= 4
  95 #define PIXMAN_EXPORT __attribute__ ((visibility("default")))
  96 #else
  97 #define PIXMAN_EXPORT
  98 #endif
  99
 100 /*
 101  * Boolean
 102  */
 103 typedef int pixman_bool_t;
 104
 105 /*
 106  * Fixpoint numbers
 107  */
 108 typedef int64_t                 pixman_fixed_32_32_t;
 109 typedef pixman_fixed_32_32_t    pixman_fixed_48_16_t;
 110 typedef uint32_t                pixman_fixed_1_31_t;
 111 typedef uint32_t                pixman_fixed_1_16_t;
 112 typedef int32_t                 pixman_fixed_16_16_t;
 113 typedef pixman_fixed_16_16_t    pixman_fixed_t;
 114
 115 #define pixman_fixed_e                  ((pixman_fixed_t) 1)
 116 #define pixman_fixed_1                  (pixman_int_to_fixed(1))
 117 #define pixman_fixed_1_minus_e          (pixman_fixed_1 - pixman_fixed_e)
 118 #define pixman_fixed_to_int(f)          ((int) ((f) >> 16))
 119 #define pixman_int_to_fixed(i)          ((pixman_fixed_t) ((i) << 16))
 120 #define pixman_fixed_to_double(f)       (double) ((f) / (double) pixman_fixed_1)
 121 #define pixman_double_to_fixed(d)       ((pixman_fixed_t) ((d) * 65536.0))
 122 #define pixman_fixed_frac(f)            ((f) & pixman_fixed_1_minus_e)
 123 #define pixman_fixed_floor(f)           ((f) & ~pixman_fixed_1_minus_e)
 124 #define pixman_fixed_ceil(f)            pixman_fixed_floor ((f) + pixman_fixed_1_minus_e)
 125 #define pixman_fixed_fraction(f)        ((f) & pixman_fixed_1_minus_e)
 126 #define pixman_fixed_mod_2(f)           ((f) & (pixman_fixed1 | pixman_fixed_1_minus_e))
 127 #define pixman_max_fixed_48_16          ((pixman_fixed_48_16_t) 0x7fffffff)
 128 #define pixman_min_fixed_48_16          (-((pixman_fixed_48_16_t) 1 << 31))
 129
 130 /*
 131  * Misc structs
 132  */
 133 typedef struct pixman_color pixman_color_t;
 134 typedef struct pixman_point_fixed pixman_point_fixed_t;
 135 typedef struct pixman_line_fixed pixman_line_fixed_t;
 136 typedef struct pixman_vector pixman_vector_t;
 137 typedef struct pixman_transform pixman_transform_t;
 138
 139 struct pixman_color
 140 {
 141     uint16_t    red;
 142     uint16_t    green;
 143     uint16_t    blue;
 144     uint16_t    alpha;
 145 };
 146
 147 struct pixman_point_fixed
 148 {
 149     pixman_fixed_t      x;
 150     pixman_fixed_t      y;
 151 };
 152
 153 struct pixman_line_fixed
 154 {
 155     pixman_point_fixed_t        p1, p2;
 156 };
 157
 158 struct pixman_vector
 159 {
 160     pixman_fixed_t      vector[3];
 161 };
 162
 163 struct pixman_transform
 164 {
 165     pixman_fixed_t      matrix[3][3];
 166 };
 167
 168 PIXMAN_EXPORT
 169 pixman_bool_t pixman_transform_point_3d (pixman_transform_t *transform,
 170                                          pixman_vector_t    *vector);
 171
 172 /* Don't blame me, blame XRender */
 173 typedef enum
 174 {
 175     PIXMAN_REPEAT_NONE,
 176     PIXMAN_REPEAT_NORMAL,
 177     PIXMAN_REPEAT_PAD,
 178     PIXMAN_REPEAT_REFLECT
 179 } pixman_repeat_t;
 180
 181 typedef enum
 182 {
 183     PIXMAN_FILTER_FAST,
 184     PIXMAN_FILTER_GOOD,
 185     PIXMAN_FILTER_BEST,
 186     PIXMAN_FILTER_NEAREST,
 187     PIXMAN_FILTER_BILINEAR,
 188     PIXMAN_FILTER_CONVOLUTION
 189 } pixman_filter_t;
 190
 191 typedef enum
 192 {
 193     PIXMAN_OP_CLEAR                     = 0x00,
 194     PIXMAN_OP_SRC                       = 0x01,
 195     PIXMAN_OP_DST                       = 0x02,
 196     PIXMAN_OP_OVER                      = 0x03,
 197     PIXMAN_OP_OVER_REVERSE              = 0x04,
 198     PIXMAN_OP_IN                        = 0x05,
 199     PIXMAN_OP_IN_REVERSE                = 0x06,
 200     PIXMAN_OP_OUT                       = 0x07,
 201     PIXMAN_OP_OUT_REVERSE               = 0x08,
 202     PIXMAN_OP_ATOP                      = 0x09,
 203     PIXMAN_OP_ATOP_REVERSE              = 0x0a,
 204     PIXMAN_OP_XOR                       = 0x0b,
 205     PIXMAN_OP_ADD                       = 0x0c,
 206     PIXMAN_OP_SATURATE                  = 0x0d,
 207
 208     PIXMAN_OP_DISJOINT_CLEAR            = 0x10,
 209     PIXMAN_OP_DISJOINT_SRC              = 0x11,
 210     PIXMAN_OP_DISJOINT_DST              = 0x12,
 211     PIXMAN_OP_DISJOINT_OVER             = 0x13,
 212     PIXMAN_OP_DISJOINT_OVER_REVERSE     = 0x14,
 213     PIXMAN_OP_DISJOINT_IN               = 0x15,
 214     PIXMAN_OP_DISJOINT_IN_REVERSE       = 0x16,
 215     PIXMAN_OP_DISJOINT_OUT              = 0x17,
 216     PIXMAN_OP_DISJOINT_OUT_REVERSE      = 0x18,
 217     PIXMAN_OP_DISJOINT_ATOP             = 0x19,
 218     PIXMAN_OP_DISJOINT_ATOP_REVERSE     = 0x1a,
 219     PIXMAN_OP_DISJOINT_XOR              = 0x1b,
 220
 221     PIXMAN_OP_CONJOINT_CLEAR            = 0x20,
 222     PIXMAN_OP_CONJOINT_SRC              = 0x21,
 223     PIXMAN_OP_CONJOINT_DST              = 0x22,
 224     PIXMAN_OP_CONJOINT_OVER             = 0x23,
 225     PIXMAN_OP_CONJOINT_OVER_REVERSE     = 0x24,
 226     PIXMAN_OP_CONJOINT_IN               = 0x25,
 227     PIXMAN_OP_CONJOINT_IN_REVERSE       = 0x26,
 228     PIXMAN_OP_CONJOINT_OUT              = 0x27,
 229     PIXMAN_OP_CONJOINT_OUT_REVERSE      = 0x28,
 230     PIXMAN_OP_CONJOINT_ATOP             = 0x29,
 231     PIXMAN_OP_CONJOINT_ATOP_REVERSE     = 0x2a,
 232     PIXMAN_OP_CONJOINT_XOR              = 0x2b,
 233
 234     PIXMAN_OP_NONE
 235 } pixman_op_t;
 236
 237 /*
 238  * Regions
 239  */
 240 typedef struct pixman_region16_data     pixman_region16_data_t;
 241 typedef struct pixman_box16             pixman_box16_t;
 242 typedef struct pixman_rectangle16       pixman_rectangle16_t;
 243 typedef struct pixman_region16          pixman_region16_t;
 244
 245 struct pixman_region16_data {
 246     long                size;
 247     long                numRects;
 248 /*  pixman_box16_t      rects[size];   in memory but not explicitly declared */
 249 };
 250
 251 struct pixman_rectangle16
 252 {
 253     int16_t x, y;
 254     uint16_t width, height;
 255 };
 256
 257 struct pixman_box16
 258 {
 259     int16_t x1, y1, x2, y2;
 260 };
 261
 262 struct pixman_region16
 263 {
 264     pixman_box16_t          extents;
 265     pixman_region16_data_t  *data;
 266 };
 267
 268 typedef enum
 269 {
 270     PIXMAN_REGION_OUT,
 271     PIXMAN_REGION_IN,
 272     PIXMAN_REGION_PART
 273 } pixman_region_overlap_t;
 274
 275 /* This function exists only to make it possible to preserve the X ABI - it should
 276  * go away at first opportunity.
 277  */
 278 PIXMAN_EXPORT
 279 void                    pixman_region_set_static_pointers (pixman_box16_t *empty_box,
 280                                                            pixman_region16_data_t *empty_data,
 281                                                            pixman_region16_data_t *broken_data);
 282
 283 /* creation/destruction */
 284 PIXMAN_EXPORT
 285 void                    pixman_region_init              (pixman_region16_t *region);
 286 PIXMAN_EXPORT
 287 void                    pixman_region_init_rect         (pixman_region16_t *region,
 288                                                          int                x,
 289                                                          int                y,
 290                                                          unsigned int       width,
 291                                                          unsigned int       height);
 292 PIXMAN_EXPORT
 293 void                    pixman_region_init_with_extents (pixman_region16_t *region,
 294                                                          pixman_box16_t    *extents);
 295 PIXMAN_EXPORT
 296 void                    pixman_region_fini              (pixman_region16_t *region);
 297
 298 /* manipulation */
 299 PIXMAN_EXPORT
 300 void                    pixman_region_translate  (pixman_region16_t *region,
 301                                                   int                x,
 302                                                   int                y);
 303 PIXMAN_EXPORT
 304 pixman_bool_t           pixman_region_copy       (pixman_region16_t *dest,
 305                                                   pixman_region16_t *source);
 306 PIXMAN_EXPORT
 307 pixman_bool_t           pixman_region_intersect  (pixman_region16_t *newReg,
 308                                                   pixman_region16_t *reg1,
 309                                                   pixman_region16_t *reg2);
 310 PIXMAN_EXPORT
 311 pixman_bool_t           pixman_region_union      (pixman_region16_t *newReg,
 312                                                   pixman_region16_t *reg1,
 313                                                   pixman_region16_t *reg2);
 314 PIXMAN_EXPORT
 315 pixman_bool_t           pixman_region_union_rect (pixman_region16_t *dest,
 316                                                   pixman_region16_t *source,
 317                                                   int                x,
 318                                                   int                y,
 319                                                   unsigned int       width,
 320                                                   unsigned int       height);
 321 PIXMAN_EXPORT
 322 pixman_bool_t           pixman_region_subtract   (pixman_region16_t *regD,
 323                                                   pixman_region16_t *regM,
 324                                                   pixman_region16_t *regS);
 325 PIXMAN_EXPORT
 326 pixman_bool_t           pixman_region_inverse    (pixman_region16_t *newReg,
 327                                                   pixman_region16_t *reg1,
 328                                                   pixman_box16_t    *invRect);
 329 PIXMAN_EXPORT
 330 pixman_bool_t           pixman_region_contains_point (pixman_region16_t *region,
 331                                                       int x, int y, pixman_box16_t *box);
 332 PIXMAN_EXPORT
 333 pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *pixman_region16_t,
 334                                                           pixman_box16_t *prect);
 335 PIXMAN_EXPORT
 336 pixman_bool_t           pixman_region_not_empty (pixman_region16_t *region);
 337 PIXMAN_EXPORT
 338 pixman_box16_t *        pixman_region_extents (pixman_region16_t *region);
 339 PIXMAN_EXPORT
 340 int                     pixman_region_n_rects (pixman_region16_t *region);
 341 PIXMAN_EXPORT
 342 pixman_box16_t *        pixman_region_rectangles (pixman_region16_t *region,
 343                                                   int               *n_rects);
 344 PIXMAN_EXPORT
 345 pixman_bool_t           pixman_region_equal (pixman_region16_t *region1,
 346                                              pixman_region16_t *region2);
 347 PIXMAN_EXPORT
 348 pixman_bool_t           pixman_region_selfcheck (pixman_region16_t *region);
 349 PIXMAN_EXPORT
 350 void                    pixman_region_reset (pixman_region16_t *region, pixman_box16_t *box);
 351 PIXMAN_EXPORT
 352 pixman_bool_t           pixman_region_init_rects (pixman_region16_t *region,
 353                                                   pixman_box16_t *boxes, int count);
 354
 355 /* Copy / Fill */
 356 PIXMAN_EXPORT
 357 pixman_bool_t pixman_blt (uint32_t *src_bits,
 358                           uint32_t *dst_bits,
 359                           int src_stride,
 360                           int dst_stride,
 361                           int src_bpp,
 362                           int dst_bpp,
 363                           int src_x, int src_y,
 364                           int dst_x, int dst_y,
 365                           int width, int height);
 366 PIXMAN_EXPORT
 367 pixman_bool_t pixman_fill (uint32_t *bits,
 368                            int stride,
 369                            int bpp,
 370                            int x,
 371                            int y,
 372                            int width,
 373                            int height,
 374                            uint32_t _xor);
 375 /*
 376  * Images
 377  */
 378 typedef  union pixman_image             pixman_image_t;
 379 typedef struct pixman_indexed           pixman_indexed_t;
 380 typedef struct pixman_gradient_stop     pixman_gradient_stop_t;
 381
 382 typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
 383 typedef void     (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
 384
 385 struct pixman_gradient_stop {
 386     pixman_fixed_t x;
 387     pixman_color_t color;
 388 };
 389
 390 #define PIXMAN_MAX_INDEXED  256 /* XXX depth must be <= 8 */
 391
 392 #if PIXMAN_MAX_INDEXED <= 256
 393 typedef uint8_t pixman_index_type;
 394 #endif
 395
 396 struct pixman_indexed
 397 {
 398     pixman_bool_t       color;
 399     uint32_t            rgba[PIXMAN_MAX_INDEXED];
 400     pixman_index_type   ent[32768];
 401 };
 402
 403 /*
 404  * While the protocol is generous in format support, the
 405  * sample implementation allows only packed RGB and GBR
 406  * representations for data to simplify software rendering,
 407  */
 408 #define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) |  \
 409                                          ((type) << 16) | \
 410                                          ((a) << 12) |    \
 411                                          ((r) << 8) |     \
 412                                          ((g) << 4) |     \
 413                                          ((b)))
 414
 415 #define PIXMAN_FORMAT_BPP(f)    (((f) >> 24)       )
 416 #define PIXMAN_FORMAT_TYPE(f)   (((f) >> 16) & 0xff)
 417 #define PIXMAN_FORMAT_A(f)      (((f) >> 12) & 0x0f)
 418 #define PIXMAN_FORMAT_R(f)      (((f) >>  8) & 0x0f)
 419 #define PIXMAN_FORMAT_G(f)      (((f) >>  4) & 0x0f)
 420 #define PIXMAN_FORMAT_B(f)      (((f)      ) & 0x0f)
 421 #define PIXMAN_FORMAT_RGB(f)    (((f)      ) & 0xfff)
 422 #define PIXMAN_FORMAT_VIS(f)    (((f)      ) & 0xffff)
 423 #define PIXMAN_FORMAT_DEPTH(f)  (PIXMAN_FORMAT_A(f) +   \
 424                                  PIXMAN_FORMAT_R(f) +   \
 425                                  PIXMAN_FORMAT_G(f) +   \
 426                                  PIXMAN_FORMAT_B(f))
 427
 428 #define PIXMAN_TYPE_OTHER       0
 429 #define PIXMAN_TYPE_A           1
 430 #define PIXMAN_TYPE_ARGB        2
 431 #define PIXMAN_TYPE_ABGR        3
 432 #define PIXMAN_TYPE_COLOR       4
 433 #define PIXMAN_TYPE_GRAY        5
 434 #define PIXMAN_TYPE_YUY2        6
 435 #define PIXMAN_TYPE_YV12        7
 436
 437 #define PIXMAN_FORMAT_COLOR(f)  (PIXMAN_FORMAT_TYPE(f) & 2)
 438
 439 /* 32bpp formats */
 440 typedef enum {
 441     PIXMAN_a8r8g8b8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8),
 442     PIXMAN_x8r8g8b8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8),
 443     PIXMAN_a8b8g8r8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8),
 444     PIXMAN_x8b8g8r8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,8,8,8),
 445
 446 /* 24bpp formats */
 447     PIXMAN_r8g8b8 =     PIXMAN_FORMAT(24,PIXMAN_TYPE_ARGB,0,8,8,8),
 448     PIXMAN_b8g8r8 =     PIXMAN_FORMAT(24,PIXMAN_TYPE_ABGR,0,8,8,8),
 449
 450 /* 16bpp formats */
 451     PIXMAN_r5g6b5 =     PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,6,5),
 452     PIXMAN_b5g6r5 =     PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,6,5),
 453
 454     PIXMAN_a1r5g5b5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,1,5,5,5),
 455     PIXMAN_x1r5g5b5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,5,5),
 456     PIXMAN_a1b5g5r5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,1,5,5,5),
 457     PIXMAN_x1b5g5r5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,5,5),
 458     PIXMAN_a4r4g4b4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,4,4,4,4),
 459     PIXMAN_x4r4g4b4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,4,4,4),
 460     PIXMAN_a4b4g4r4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,4,4,4,4),
 461     PIXMAN_x4b4g4r4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,4,4,4),
 462
 463 /* 8bpp formats */
 464     PIXMAN_a8 =         PIXMAN_FORMAT(8,PIXMAN_TYPE_A,8,0,0,0),
 465     PIXMAN_r3g3b2 =     PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,0,3,3,2),
 466     PIXMAN_b2g3r3 =     PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,0,3,3,2),
 467     PIXMAN_a2r2g2b2 =   PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,2,2,2,2),
 468     PIXMAN_a2b2g2r2 =   PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,2,2,2,2),
 469
 470     PIXMAN_c8 =         PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
 471     PIXMAN_g8 =         PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
 472
 473     PIXMAN_x4a4 =       PIXMAN_FORMAT(8,PIXMAN_TYPE_A,4,0,0,0),
 474
 475     PIXMAN_x4c4 =       PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
 476     PIXMAN_x4g4 =       PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
 477
 478 /* 4bpp formats */
 479     PIXMAN_a4 =         PIXMAN_FORMAT(4,PIXMAN_TYPE_A,4,0,0,0),
 480     PIXMAN_r1g2b1 =     PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,0,1,2,1),
 481     PIXMAN_b1g2r1 =     PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,0,1,2,1),
 482     PIXMAN_a1r1g1b1 =   PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,1,1,1,1),
 483     PIXMAN_a1b1g1r1 =   PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,1,1,1,1),
 484
 485     PIXMAN_c4 =         PIXMAN_FORMAT(4,PIXMAN_TYPE_COLOR,0,0,0,0),
 486     PIXMAN_g4 =         PIXMAN_FORMAT(4,PIXMAN_TYPE_GRAY,0,0,0,0),
 487
 488 /* 1bpp formats */
 489     PIXMAN_a1 =         PIXMAN_FORMAT(1,PIXMAN_TYPE_A,1,0,0,0),
 490
 491     PIXMAN_g1 =         PIXMAN_FORMAT(1,PIXMAN_TYPE_GRAY,0,0,0,0),
 492
 493 /* YUV formats */
 494     PIXMAN_yuy2 =       PIXMAN_FORMAT(16,PIXMAN_TYPE_YUY2,0,0,0,0),
 495     PIXMAN_yv12 =       PIXMAN_FORMAT(12,PIXMAN_TYPE_YV12,0,0,0,0),
 496 } pixman_format_code_t;
 497
 498 /* Constructors */
 499 PIXMAN_EXPORT
 500 pixman_image_t *pixman_image_create_solid_fill       (pixman_color_t               *color);
 501 PIXMAN_EXPORT
 502 pixman_image_t *pixman_image_create_linear_gradient  (pixman_point_fixed_t         *p1,
 503                                                       pixman_point_fixed_t         *p2,
 504                                                       const pixman_gradient_stop_t *stops,
 505                                                       int                           n_stops);
 506 PIXMAN_EXPORT
 507 pixman_image_t *pixman_image_create_radial_gradient  (pixman_point_fixed_t         *inner,
 508                                                       pixman_point_fixed_t         *outer,
 509                                                       pixman_fixed_t                inner_radius,
 510                                                       pixman_fixed_t                outer_radius,
 511                                                       const pixman_gradient_stop_t *stops,
 512                                                       int                           n_stops);
 513 PIXMAN_EXPORT
 514 pixman_image_t *pixman_image_create_conical_gradient (pixman_point_fixed_t         *center,
 515                                                       pixman_fixed_t                angle,
 516                                                       const pixman_gradient_stop_t *stops,
 517                                                       int                           n_stops);
 518 PIXMAN_EXPORT
 519 pixman_image_t *pixman_image_create_bits             (pixman_format_code_t          format,
 520                                                       int                           width,
 521                                                       int                           height,
 522                                                       uint32_t                     *bits,
 523                                                       int                           rowstride_bytes);
 524
 525 /* Destructor */
 526 PIXMAN_EXPORT
 527 pixman_image_t *pixman_image_ref                     (pixman_image_t               *image);
 528 PIXMAN_EXPORT
 529 pixman_bool_t   pixman_image_unref                   (pixman_image_t               *image);
 530
 531
 532 /* Set properties */
 533 PIXMAN_EXPORT
 534 pixman_bool_t   pixman_image_set_clip_region         (pixman_image_t               *image,
 535                                                       pixman_region16_t            *region);
 536 PIXMAN_EXPORT
 537 void            pixman_image_set_has_client_clip     (pixman_image_t               *image,
 538                                                       pixman_bool_t                 clien_clip);
 539 PIXMAN_EXPORT
 540 pixman_bool_t   pixman_image_set_transform           (pixman_image_t               *image,
 541                                                       const pixman_transform_t     *transform);
 542 PIXMAN_EXPORT
 543 void            pixman_image_set_repeat              (pixman_image_t               *image,
 544                                                       pixman_repeat_t               repeat);
 545 PIXMAN_EXPORT
 546 pixman_bool_t   pixman_image_set_filter              (pixman_image_t               *image,
 547                                                       pixman_filter_t               filter,
 548                                                       const pixman_fixed_t         *filter_params,
 549                                                       int                           n_filter_params);
 550 PIXMAN_EXPORT
 551 void            pixman_image_set_filter_params       (pixman_image_t               *image,
 552                                                       pixman_fixed_t               *params,
 553                                                       int                           n_params);
 554 PIXMAN_EXPORT
 555 void            pixman_image_set_source_clipping     (pixman_image_t               *image,
 556                                                       pixman_bool_t                 source_clipping);
 557 PIXMAN_EXPORT
 558 void            pixman_image_set_alpha_map           (pixman_image_t               *image,
 559                                                       pixman_image_t               *alpha_map,
 560                                                       int16_t                       x,
 561                                                       int16_t                       y);
 562 PIXMAN_EXPORT
 563 void            pixman_image_set_component_alpha     (pixman_image_t               *image,
 564                                                       pixman_bool_t                 component_alpha);
 565 PIXMAN_EXPORT
 566 void            pixman_image_set_accessors           (pixman_image_t               *image,
 567                                                       pixman_read_memory_func_t     read_func,
 568                                                       pixman_write_memory_func_t    write_func);
 569 PIXMAN_EXPORT
 570 void            pixman_image_set_indexed             (pixman_image_t               *image,
 571                                                       const pixman_indexed_t       *indexed);
 572 PIXMAN_EXPORT
 573 uint32_t       *pixman_image_get_data                (pixman_image_t               *image);
 574 PIXMAN_EXPORT
 575 int             pixman_image_get_width               (pixman_image_t               *image);
 576 PIXMAN_EXPORT
 577 int             pixman_image_get_height              (pixman_image_t               *image);
 578 PIXMAN_EXPORT
 579 int             pixman_image_get_stride              (pixman_image_t               *image);
 580 PIXMAN_EXPORT
 581 int             pixman_image_get_depth               (pixman_image_t               *image);
 582 PIXMAN_EXPORT
 583 pixman_bool_t   pixman_image_fill_rectangles         (pixman_op_t                   op,
 584                                                       pixman_image_t               *image,
 585                                                       pixman_color_t               *color,
 586                                                       int                           n_rects,
 587                                                       const pixman_rectangle16_t           *rects);
 588
 589 /* Composite */
 590 PIXMAN_EXPORT
 591 pixman_bool_t   pixman_compute_composite_region (pixman_region16_t *    pRegion,
 592                                                  pixman_image_t *       pSrc,
 593                                                  pixman_image_t *       pMask,
 594                                                  pixman_image_t *       pDst,
 595                                                  int16_t                xSrc,
 596                                                  int16_t                ySrc,
 597                                                  int16_t                xMask,
 598                                                  int16_t                yMask,
 599                                                  int16_t                xDst,
 600                                                  int16_t                yDst,
 601                                                  uint16_t               width,
 602                                                  uint16_t               height);
 603 PIXMAN_EXPORT
 604 void            pixman_image_composite          (pixman_op_t                op,
 605                                                  pixman_image_t            *src,
 606                                                  pixman_image_t               *mask,
 607                                                  pixman_image_t               *dest,
 608                                                  int16_t                       src_x,
 609                                                  int16_t                       src_y,
 610                                                  int16_t                       mask_x,
 611                                                  int16_t                       mask_y,
 612                                                  int16_t                       dest_x,
 613                                                  int16_t                       dest_y,
 614                                                  uint16_t                      width,
 615                                                  uint16_t                      height);
 616
 617 /*
 618  * Trapezoids
 619  */
 620 typedef struct pixman_edge pixman_edge_t;
 621 typedef struct pixman_trapezoid pixman_trapezoid_t;
 622 typedef struct pixman_trap pixman_trap_t;
 623 typedef struct pixman_span_fix pixman_span_fix_t;
 624
 625 /*
 626  * An edge structure.  This represents a single polygon edge
 627  * and can be quickly stepped across small or large gaps in the
 628  * sample grid
 629  */
 630 struct pixman_edge
 631 {
 632     pixman_fixed_t      x;
 633     pixman_fixed_t      e;
 634     pixman_fixed_t   stepx;
 635     pixman_fixed_t   signdx;
 636     pixman_fixed_t   dy;
 637     pixman_fixed_t   dx;
 638
 639     pixman_fixed_t   stepx_small;
 640     pixman_fixed_t   stepx_big;
 641     pixman_fixed_t   dx_small;
 642     pixman_fixed_t   dx_big;
 643 };
 644
 645 struct pixman_trapezoid
 646 {
 647     pixman_fixed_t  top, bottom;
 648     pixman_line_fixed_t left, right;
 649 };
 650
 651
 652 /* whether 't' is a well defined not obviously empty trapezoid */
 653 #define pixman_trapezoid_valid(t)                               \
 654     ((t)->left.p1.y != (t)->left.p2.y &&                           \
 655      (t)->right.p1.y != (t)->right.p2.y &&                         \
 656      (int) ((t)->bottom - (t)->top) > 0)
 657
 658 struct pixman_span_fix
 659 {
 660     pixman_fixed_t      l, r, y;
 661 };
 662
 663 struct pixman_trap
 664 {
 665     pixman_span_fix_t   top, bot;
 666 };
 667
 668 PIXMAN_EXPORT
 669 pixman_fixed_t pixman_sample_ceil_y        (pixman_fixed_t       y,
 670                                             int                  bpp);
 671 PIXMAN_EXPORT
 672 pixman_fixed_t pixman_sample_floor_y       (pixman_fixed_t       y,
 673                                             int                  bpp);
 674 PIXMAN_EXPORT
 675 void           pixman_edge_step            (pixman_edge_t       *e,
 676                                             int                  n);
 677 PIXMAN_EXPORT
 678 void           pixman_edge_init            (pixman_edge_t       *e,
 679                                             int                  bpp,
 680                                             pixman_fixed_t       y_start,
 681                                             pixman_fixed_t       x_top,
 682                                             pixman_fixed_t       y_top,
 683                                             pixman_fixed_t       x_bot,
 684                                             pixman_fixed_t       y_bot);
 685 PIXMAN_EXPORT
 686 void           pixman_line_fixed_edge_init (pixman_edge_t       *e,
 687                                             int                  bpp,
 688                                             pixman_fixed_t       y,
 689                                             const pixman_line_fixed_t *line,
 690                                             int                  x_off,
 691                                             int                  y_off);
 692 PIXMAN_EXPORT
 693 void           pixman_rasterize_edges      (pixman_image_t      *image,
 694                                             pixman_edge_t       *l,
 695                                             pixman_edge_t       *r,
 696                                             pixman_fixed_t       t,
 697                                             pixman_fixed_t       b);
 698 PIXMAN_EXPORT
 699 void           pixman_add_traps            (pixman_image_t      *image,
 700                                             int16_t              x_off,
 701                                             int16_t              y_off,
 702                                             int                  ntrap,
 703                                             pixman_trap_t       *traps);
 704 PIXMAN_EXPORT
 705 void           pixman_add_trapezoids       (pixman_image_t      *image,
 706                                             int16_t              x_off,
 707                                             int                  y_off,
 708                                             int                  ntraps,
 709                                             const pixman_trapezoid_t  *traps);
 710 PIXMAN_EXPORT
 711 void           pixman_rasterize_trapezoid  (pixman_image_t      *image,
 712                                             const pixman_trapezoid_t  *trap,
 713                                             int                  x_off,
 714                                             int                  y_off);
 715
 716 #endif /* PIXMAN_H__ */