← Back to branch summary

~ubuntu-branches/ubuntu/karmic/virtualbox-ose/karmic-updates

« back to all changes in this revision

Viewing changes to src/VBox/Additions/x11/x11include/1.4/pixman.h

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-09-14 18:25:07 UTC
  • mfrom: (0.4.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090914182507-c98g07mq16hjmn6d
Tags: 3.0.6-dfsg-1ubuntu1
https://launchpad.net/bugs/429697
https://launchpad.net/bugs/267097
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/379878
* Merge from debian unstable (LP: #429697), remaining changes:
  - Enable DKMS support on virtualbox host and guest modules (LP: #267097)
    - Drop virtualbox-ose{-guest,}-modules-* package templates
    - Recommend *-source instead of *-modules packages
    - Replace error messages related to missing/mismatched
      kernel module accordingly
  - Autoload kernel module
    - LOAD_VBOXDRV_MODULE=1 in virtualbox-ose.default
  - Disable update action
    - patches/u01-disable-update-action.dpatch
  - Virtualbox should go in Accessories, not in System tools (LP: #288590)
    - virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add apport hook
    - virtualbox-ose.files/source_virtualbox-ose.py
    - virtualbox-ose.install
  - Add launchpad integration
    - control
    - lpi-bug.xpm
    - patches/u02-lp-integration.dpatch
  - virtualbox, virtualbox-* (names of the upstream proprietary packages)
    conflict with virtualbox-ose (LP: #379878)
* Make debug package depend on normal or guest utils package
* Drop patches/22-pulseaudio-stubs.dpatch (applied upstream)
* Rename Ubuntu specific patches to uXX-*.dpatch
* Fix lintian warnings in maintainer scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Additions/x11/x11include/1.4/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
 
/*
94
 
 * Boolean
95
 
 */
96
 
typedef int pixman_bool_t;
97
 
 
98
 
/*
99
 
 * Fixpoint numbers
100
 
 */
101
 
typedef int64_t                 pixman_fixed_32_32_t;
102
 
typedef pixman_fixed_32_32_t    pixman_fixed_48_16_t;
103
 
typedef uint32_t                pixman_fixed_1_31_t;
104
 
typedef uint32_t                pixman_fixed_1_16_t;
105
 
typedef int32_t                 pixman_fixed_16_16_t;
106
 
typedef pixman_fixed_16_16_t    pixman_fixed_t;
107
 
 
108
 
#define pixman_fixed_e                  ((pixman_fixed_t) 1)
109
 
#define pixman_fixed_1                  (pixman_int_to_fixed(1))
110
 
#define pixman_fixed_1_minus_e          (pixman_fixed_1 - pixman_fixed_e)
111
 
#define pixman_fixed_to_int(f)          ((int) ((f) >> 16))
112
 
#define pixman_int_to_fixed(i)          ((pixman_fixed_t) ((i) << 16))
113
 
#define pixman_fixed_to_double(f)       (double) ((f) / (double) pixman_fixed_1)
114
 
#define pixman_double_to_fixed(d)       ((pixman_fixed_t) ((d) * 65536.0))
115
 
#define pixman_fixed_frac(f)            ((f) & pixman_fixed_1_minus_e)
116
 
#define pixman_fixed_floor(f)           ((f) & ~pixman_fixed_1_minus_e)
117
 
#define pixman_fixed_ceil(f)            pixman_fixed_floor ((f) + pixman_fixed_1_minus_e)
118
 
#define pixman_fixed_fraction(f)        ((f) & pixman_fixed_1_minus_e)
119
 
#define pixman_fixed_mod_2(f)           ((f) & (pixman_fixed1 | pixman_fixed_1_minus_e))
120
 
#define pixman_max_fixed_48_16          ((pixman_fixed_48_16_t) 0x7fffffff)
121
 
#define pixman_min_fixed_48_16          (-((pixman_fixed_48_16_t) 1 << 31))
122
 
 
123
 
/*
124
 
 * Misc structs
125
 
 */
126
 
typedef struct pixman_color pixman_color_t;
127
 
typedef struct pixman_point_fixed pixman_point_fixed_t;
128
 
typedef struct pixman_line_fixed pixman_line_fixed_t;
129
 
typedef struct pixman_vector pixman_vector_t;
130
 
typedef struct pixman_transform pixman_transform_t;
131
 
 
132
 
struct pixman_color
133
 
{
134
 
    uint16_t    red;
135
 
    uint16_t    green;
136
 
    uint16_t    blue;
137
 
    uint16_t    alpha;
138
 
};
139
 
 
140
 
struct pixman_point_fixed
141
 
{
142
 
    pixman_fixed_t      x;
143
 
    pixman_fixed_t      y;
144
 
};
145
 
 
146
 
struct pixman_line_fixed
147
 
{
148
 
    pixman_point_fixed_t        p1, p2;
149
 
};
150
 
 
151
 
struct pixman_vector
152
 
{
153
 
    pixman_fixed_t      vector[3];
154
 
};
155
 
 
156
 
struct pixman_transform
157
 
{
158
 
    pixman_fixed_t      matrix[3][3];
159
 
};
160
 
 
161
 
pixman_bool_t pixman_transform_point_3d (pixman_transform_t *transform,
162
 
                                         pixman_vector_t    *vector);
163
 
 
164
 
/* Don't blame me, blame XRender */
165
 
typedef enum
166
 
{
167
 
    PIXMAN_REPEAT_NONE,
168
 
    PIXMAN_REPEAT_NORMAL,
169
 
    PIXMAN_REPEAT_PAD,
170
 
    PIXMAN_REPEAT_REFLECT
171
 
} pixman_repeat_t;
172
 
 
173
 
typedef enum
174
 
{
175
 
    PIXMAN_FILTER_FAST,
176
 
    PIXMAN_FILTER_GOOD,
177
 
    PIXMAN_FILTER_BEST,
178
 
    PIXMAN_FILTER_NEAREST,
179
 
    PIXMAN_FILTER_BILINEAR,
180
 
    PIXMAN_FILTER_CONVOLUTION
181
 
} pixman_filter_t;
182
 
 
183
 
typedef enum
184
 
{
185
 
    PIXMAN_OP_CLEAR                     = 0x00,
186
 
    PIXMAN_OP_SRC                       = 0x01,
187
 
    PIXMAN_OP_DST                       = 0x02,
188
 
    PIXMAN_OP_OVER                      = 0x03,
189
 
    PIXMAN_OP_OVER_REVERSE              = 0x04,
190
 
    PIXMAN_OP_IN                        = 0x05,
191
 
    PIXMAN_OP_IN_REVERSE                = 0x06,
192
 
    PIXMAN_OP_OUT                       = 0x07,
193
 
    PIXMAN_OP_OUT_REVERSE               = 0x08,
194
 
    PIXMAN_OP_ATOP                      = 0x09,
195
 
    PIXMAN_OP_ATOP_REVERSE              = 0x0a,
196
 
    PIXMAN_OP_XOR                       = 0x0b,
197
 
    PIXMAN_OP_ADD                       = 0x0c,
198
 
    PIXMAN_OP_SATURATE                  = 0x0d,
199
 
 
200
 
    PIXMAN_OP_DISJOINT_CLEAR            = 0x10,
201
 
    PIXMAN_OP_DISJOINT_SRC              = 0x11,
202
 
    PIXMAN_OP_DISJOINT_DST              = 0x12,
203
 
    PIXMAN_OP_DISJOINT_OVER             = 0x13,
204
 
    PIXMAN_OP_DISJOINT_OVER_REVERSE     = 0x14,
205
 
    PIXMAN_OP_DISJOINT_IN               = 0x15,
206
 
    PIXMAN_OP_DISJOINT_IN_REVERSE       = 0x16,
207
 
    PIXMAN_OP_DISJOINT_OUT              = 0x17,
208
 
    PIXMAN_OP_DISJOINT_OUT_REVERSE      = 0x18,
209
 
    PIXMAN_OP_DISJOINT_ATOP             = 0x19,
210
 
    PIXMAN_OP_DISJOINT_ATOP_REVERSE     = 0x1a,
211
 
    PIXMAN_OP_DISJOINT_XOR              = 0x1b,
212
 
 
213
 
    PIXMAN_OP_CONJOINT_CLEAR            = 0x20,
214
 
    PIXMAN_OP_CONJOINT_SRC              = 0x21,
215
 
    PIXMAN_OP_CONJOINT_DST              = 0x22,
216
 
    PIXMAN_OP_CONJOINT_OVER             = 0x23,
217
 
    PIXMAN_OP_CONJOINT_OVER_REVERSE     = 0x24,
218
 
    PIXMAN_OP_CONJOINT_IN               = 0x25,
219
 
    PIXMAN_OP_CONJOINT_IN_REVERSE       = 0x26,
220
 
    PIXMAN_OP_CONJOINT_OUT              = 0x27,
221
 
    PIXMAN_OP_CONJOINT_OUT_REVERSE      = 0x28,
222
 
    PIXMAN_OP_CONJOINT_ATOP             = 0x29,
223
 
    PIXMAN_OP_CONJOINT_ATOP_REVERSE     = 0x2a,
224
 
    PIXMAN_OP_CONJOINT_XOR              = 0x2b
225
 
} pixman_op_t;
226
 
 
227
 
/*
228
 
 * Regions
229
 
 */
230
 
typedef struct pixman_region16_data     pixman_region16_data_t;
231
 
typedef struct pixman_box16             pixman_box16_t;
232
 
typedef struct pixman_rectangle16       pixman_rectangle16_t;
233
 
typedef struct pixman_region16          pixman_region16_t;
234
 
 
235
 
struct pixman_region16_data {
236
 
    long                size;
237
 
    long                numRects;
238
 
/*  pixman_box16_t      rects[size];   in memory but not explicitly declared */
239
 
};
240
 
 
241
 
struct pixman_rectangle16
242
 
{
243
 
    int16_t x, y;
244
 
    uint16_t width, height;
245
 
};
246
 
 
247
 
struct pixman_box16
248
 
{
249
 
    int16_t x1, y1, x2, y2;
250
 
};
251
 
 
252
 
struct pixman_region16
253
 
{
254
 
    pixman_box16_t          extents;
255
 
    pixman_region16_data_t  *data;
256
 
};
257
 
 
258
 
typedef enum
259
 
{
260
 
    PIXMAN_REGION_OUT,
261
 
    PIXMAN_REGION_IN,
262
 
    PIXMAN_REGION_PART
263
 
} pixman_region_overlap_t;
264
 
 
265
 
/* This function exists only to make it possible to preserve the X ABI - it should
266
 
 * go away at first opportunity.
267
 
 */
268
 
void                    pixman_region_set_static_pointers (pixman_box16_t *empty_box,
269
 
                                                           pixman_region16_data_t *empty_data,
270
 
                                                           pixman_region16_data_t *broken_data);
271
 
 
272
 
/* creation/destruction */
273
 
void                    pixman_region_init              (pixman_region16_t *region);
274
 
void                    pixman_region_init_rect         (pixman_region16_t *region,
275
 
                                                         int                x,
276
 
                                                         int                y,
277
 
                                                         unsigned int       width,
278
 
                                                         unsigned int       height);
279
 
void                    pixman_region_init_with_extents (pixman_region16_t *region,
280
 
                                                         pixman_box16_t    *extents);
281
 
void                    pixman_region_fini              (pixman_region16_t *region);
282
 
 
283
 
/* manipulation */
284
 
void                    pixman_region_translate  (pixman_region16_t *region,
285
 
                                                  int                x,
286
 
                                                  int                y);
287
 
pixman_bool_t           pixman_region_copy       (pixman_region16_t *dest,
288
 
                                                  pixman_region16_t *source);
289
 
pixman_bool_t           pixman_region_intersect  (pixman_region16_t *newReg,
290
 
                                                  pixman_region16_t *reg1,
291
 
                                                  pixman_region16_t *reg2);
292
 
pixman_bool_t           pixman_region_union      (pixman_region16_t *newReg,
293
 
                                                  pixman_region16_t *reg1,
294
 
                                                  pixman_region16_t *reg2);
295
 
pixman_bool_t           pixman_region_union_rect (pixman_region16_t *dest,
296
 
                                                  pixman_region16_t *source,
297
 
                                                  int                x,
298
 
                                                  int                y,
299
 
                                                  unsigned int       width,
300
 
                                                  unsigned int       height);
301
 
pixman_bool_t           pixman_region_subtract   (pixman_region16_t *regD,
302
 
                                                  pixman_region16_t *regM,
303
 
                                                  pixman_region16_t *regS);
304
 
pixman_bool_t           pixman_region_inverse    (pixman_region16_t *newReg,
305
 
                                                  pixman_region16_t *reg1,
306
 
                                                  pixman_box16_t    *invRect);
307
 
pixman_bool_t           pixman_region_contains_point (pixman_region16_t *region,
308
 
                                                      int x, int y, pixman_box16_t *box);
309
 
pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *pixman_region16_t,
310
 
                                                          pixman_box16_t *prect);
311
 
pixman_bool_t           pixman_region_not_empty (pixman_region16_t *region);
312
 
pixman_box16_t *        pixman_region_extents (pixman_region16_t *region);
313
 
int                     pixman_region_n_rects (pixman_region16_t *region);
314
 
pixman_box16_t *        pixman_region_rectangles (pixman_region16_t *region,
315
 
                                                  int               *n_rects);
316
 
pixman_bool_t           pixman_region_equal (pixman_region16_t *region1,
317
 
                                             pixman_region16_t *region2);
318
 
pixman_bool_t           pixman_region_selfcheck (pixman_region16_t *region);
319
 
void                    pixman_region_reset (pixman_region16_t *region, pixman_box16_t *box);
320
 
pixman_bool_t           pixman_region_init_rects (pixman_region16_t *region,
321
 
                                                  pixman_box16_t *boxes, int count);
322
 
 
323
 
/* Copy / Fill */
324
 
pixman_bool_t pixman_blt (uint32_t *src_bits,
325
 
                          uint32_t *dst_bits,
326
 
                          int src_stride,
327
 
                          int dst_stride,
328
 
                          int src_bpp,
329
 
                          int dst_bpp,
330
 
                          int src_x, int src_y,
331
 
                          int dst_x, int dst_y,
332
 
                          int width, int height);
333
 
pixman_bool_t pixman_fill (uint32_t *bits,
334
 
                           int stride,
335
 
                           int bpp,
336
 
                           int x,
337
 
                           int y,
338
 
                           int width,
339
 
                           int height,
340
 
                           uint32_t xor);
341
 
/*
342
 
 * Images
343
 
 */
344
 
typedef  union pixman_image             pixman_image_t;
345
 
typedef struct pixman_indexed           pixman_indexed_t;
346
 
typedef struct pixman_gradient_stop     pixman_gradient_stop_t;
347
 
 
348
 
typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
349
 
typedef void     (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
350
 
 
351
 
struct pixman_gradient_stop {
352
 
    pixman_fixed_t x;
353
 
    pixman_color_t color;
354
 
};
355
 
 
356
 
#define PIXMAN_MAX_INDEXED  256 /* XXX depth must be <= 8 */
357
 
 
358
 
#if PIXMAN_MAX_INDEXED <= 256
359
 
typedef uint8_t pixman_index_type;
360
 
#endif
361
 
 
362
 
struct pixman_indexed
363
 
{
364
 
    pixman_bool_t       color;
365
 
    uint32_t            rgba[PIXMAN_MAX_INDEXED];
366
 
    pixman_index_type   ent[32768];
367
 
};
368
 
 
369
 
/*
370
 
 * While the protocol is generous in format support, the
371
 
 * sample implementation allows only packed RGB and GBR
372
 
 * representations for data to simplify software rendering,
373
 
 */
374
 
#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) |  \
375
 
                                         ((type) << 16) | \
376
 
                                         ((a) << 12) |    \
377
 
                                         ((r) << 8) |     \
378
 
                                         ((g) << 4) |     \
379
 
                                         ((b)))
380
 
 
381
 
#define PIXMAN_FORMAT_BPP(f)    (((f) >> 24)       )
382
 
#define PIXMAN_FORMAT_TYPE(f)   (((f) >> 16) & 0xff)
383
 
#define PIXMAN_FORMAT_A(f)      (((f) >> 12) & 0x0f)
384
 
#define PIXMAN_FORMAT_R(f)      (((f) >>  8) & 0x0f)
385
 
#define PIXMAN_FORMAT_G(f)      (((f) >>  4) & 0x0f)
386
 
#define PIXMAN_FORMAT_B(f)      (((f)      ) & 0x0f)
387
 
#define PIXMAN_FORMAT_RGB(f)    (((f)      ) & 0xfff)
388
 
#define PIXMAN_FORMAT_VIS(f)    (((f)      ) & 0xffff)
389
 
#define PIXMAN_FORMAT_DEPTH(f)  (PIXMAN_FORMAT_A(f) +   \
390
 
                                 PIXMAN_FORMAT_R(f) +   \
391
 
                                 PIXMAN_FORMAT_G(f) +   \
392
 
                                 PIXMAN_FORMAT_B(f))
393
 
 
394
 
#define PIXMAN_TYPE_OTHER       0
395
 
#define PIXMAN_TYPE_A           1
396
 
#define PIXMAN_TYPE_ARGB        2
397
 
#define PIXMAN_TYPE_ABGR        3
398
 
#define PIXMAN_TYPE_COLOR       4
399
 
#define PIXMAN_TYPE_GRAY        5
400
 
 
401
 
#define PIXMAN_FORMAT_COLOR(f)  (PIXMAN_FORMAT_TYPE(f) & 2)
402
 
 
403
 
/* 32bpp formats */
404
 
typedef enum {
405
 
    PIXMAN_a8r8g8b8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8),
406
 
    PIXMAN_x8r8g8b8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8),
407
 
    PIXMAN_a8b8g8r8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8),
408
 
    PIXMAN_x8b8g8r8 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,8,8,8),
409
 
    
410
 
/* 24bpp formats */
411
 
    PIXMAN_r8g8b8 =     PIXMAN_FORMAT(24,PIXMAN_TYPE_ARGB,0,8,8,8),
412
 
    PIXMAN_b8g8r8 =     PIXMAN_FORMAT(24,PIXMAN_TYPE_ABGR,0,8,8,8),
413
 
    
414
 
/* 16bpp formats */
415
 
    PIXMAN_r5g6b5 =     PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,6,5),
416
 
    PIXMAN_b5g6r5 =     PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,6,5),
417
 
    
418
 
    PIXMAN_a1r5g5b5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,1,5,5,5),
419
 
    PIXMAN_x1r5g5b5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,5,5),
420
 
    PIXMAN_a1b5g5r5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,1,5,5,5),
421
 
    PIXMAN_x1b5g5r5 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,5,5),
422
 
    PIXMAN_a4r4g4b4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,4,4,4,4),
423
 
    PIXMAN_x4r4g4b4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,4,4,4),
424
 
    PIXMAN_a4b4g4r4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,4,4,4,4),
425
 
    PIXMAN_x4b4g4r4 =   PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,4,4,4),
426
 
    
427
 
/* 8bpp formats */
428
 
    PIXMAN_a8 =         PIXMAN_FORMAT(8,PIXMAN_TYPE_A,8,0,0,0),
429
 
    PIXMAN_r3g3b2 =     PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,0,3,3,2),
430
 
    PIXMAN_b2g3r3 =     PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,0,3,3,2),
431
 
    PIXMAN_a2r2g2b2 =   PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,2,2,2,2),
432
 
    PIXMAN_a2b2g2r2 =   PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,2,2,2,2),
433
 
    
434
 
    PIXMAN_c8 =         PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
435
 
    PIXMAN_g8 =         PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
436
 
    
437
 
    PIXMAN_x4a4 =       PIXMAN_FORMAT(8,PIXMAN_TYPE_A,4,0,0,0),
438
 
    
439
 
    PIXMAN_x4c4 =       PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
440
 
    PIXMAN_x4g4 =       PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
441
 
    
442
 
/* 4bpp formats */
443
 
    PIXMAN_a4 =         PIXMAN_FORMAT(4,PIXMAN_TYPE_A,4,0,0,0),
444
 
    PIXMAN_r1g2b1 =     PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,0,1,2,1),
445
 
    PIXMAN_b1g2r1 =     PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,0,1,2,1),
446
 
    PIXMAN_a1r1g1b1 =   PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,1,1,1,1),
447
 
    PIXMAN_a1b1g1r1 =   PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,1,1,1,1),
448
 
    
449
 
    PIXMAN_c4 =         PIXMAN_FORMAT(4,PIXMAN_TYPE_COLOR,0,0,0,0),
450
 
    PIXMAN_g4 =         PIXMAN_FORMAT(4,PIXMAN_TYPE_GRAY,0,0,0,0),
451
 
    
452
 
/* 1bpp formats */
453
 
    PIXMAN_a1 =         PIXMAN_FORMAT(1,PIXMAN_TYPE_A,1,0,0,0),
454
 
    
455
 
    PIXMAN_g1 =         PIXMAN_FORMAT(1,PIXMAN_TYPE_GRAY,0,0,0,0),
456
 
} pixman_format_code_t;
457
 
 
458
 
/* Constructors */
459
 
pixman_image_t *pixman_image_create_solid_fill       (pixman_color_t               *color);
460
 
pixman_image_t *pixman_image_create_linear_gradient  (pixman_point_fixed_t         *p1,
461
 
                                                      pixman_point_fixed_t         *p2,
462
 
                                                      const pixman_gradient_stop_t *stops,
463
 
                                                      int                           n_stops);
464
 
pixman_image_t *pixman_image_create_radial_gradient  (pixman_point_fixed_t         *inner,
465
 
                                                      pixman_point_fixed_t         *outer,
466
 
                                                      pixman_fixed_t                inner_radius,
467
 
                                                      pixman_fixed_t                outer_radius,
468
 
                                                      const pixman_gradient_stop_t *stops,
469
 
                                                      int                           n_stops);
470
 
pixman_image_t *pixman_image_create_conical_gradient (pixman_point_fixed_t         *center,
471
 
                                                      pixman_fixed_t                angle,
472
 
                                                      const pixman_gradient_stop_t *stops,
473
 
                                                      int                           n_stops);
474
 
pixman_image_t *pixman_image_create_bits             (pixman_format_code_t          format,
475
 
                                                      int                           width,
476
 
                                                      int                           height,
477
 
                                                      uint32_t                     *bits,
478
 
                                                      int                           rowstride_bytes);
479
 
 
480
 
/* Destructor */
481
 
pixman_image_t *pixman_image_ref                     (pixman_image_t               *image);
482
 
pixman_bool_t   pixman_image_unref                   (pixman_image_t               *image);
483
 
 
484
 
 
485
 
/* Set properties */
486
 
pixman_bool_t   pixman_image_set_clip_region         (pixman_image_t               *image,
487
 
                                                      pixman_region16_t            *region);
488
 
void            pixman_image_set_has_client_clip     (pixman_image_t               *image,
489
 
                                                      pixman_bool_t                 clien_clip);
490
 
pixman_bool_t   pixman_image_set_transform           (pixman_image_t               *image,
491
 
                                                      const pixman_transform_t     *transform);
492
 
void            pixman_image_set_repeat              (pixman_image_t               *image,
493
 
                                                      pixman_repeat_t               repeat);
494
 
pixman_bool_t   pixman_image_set_filter              (pixman_image_t               *image,
495
 
                                                      pixman_filter_t               filter,
496
 
                                                      const pixman_fixed_t         *filter_params,
497
 
                                                      int                           n_filter_params);
498
 
void            pixman_image_set_filter_params       (pixman_image_t               *image,
499
 
                                                      pixman_fixed_t               *params,
500
 
                                                      int                           n_params);
501
 
void            pixman_image_set_source_cliping      (pixman_image_t               *image,
502
 
                                                      pixman_bool_t                 source_clipping);
503
 
void            pixman_image_set_alpha_map           (pixman_image_t               *image,
504
 
                                                      pixman_image_t               *alpha_map,
505
 
                                                      int16_t                       x,
506
 
                                                      int16_t                       y);
507
 
void            pixman_image_set_component_alpha     (pixman_image_t               *image,
508
 
                                                      pixman_bool_t                 component_alpha);
509
 
void            pixman_image_set_accessors           (pixman_image_t               *image,
510
 
                                                      pixman_read_memory_func_t     read_func,
511
 
                                                      pixman_write_memory_func_t    write_func);
512
 
void            pixman_image_set_indexed             (pixman_image_t               *image,
513
 
                                                      const pixman_indexed_t       *indexed);
514
 
uint32_t       *pixman_image_get_data                (pixman_image_t               *image);
515
 
int             pixman_image_get_width               (pixman_image_t               *image);
516
 
int             pixman_image_get_height              (pixman_image_t               *image);
517
 
int             pixman_image_get_stride              (pixman_image_t               *image);
518
 
int             pixman_image_get_depth               (pixman_image_t               *image);
519
 
pixman_bool_t   pixman_image_fill_rectangles         (pixman_op_t                   op,
520
 
                                                      pixman_image_t               *image,
521
 
                                                      pixman_color_t               *color,
522
 
                                                      int                           n_rects,
523
 
                                                      const pixman_rectangle16_t           *rects);
524
 
 
525
 
/* Composite */
526
 
pixman_bool_t   pixman_compute_composite_region (pixman_region16_t *    pRegion,
527
 
                                                 pixman_image_t *       pSrc,
528
 
                                                 pixman_image_t *       pMask,
529
 
                                                 pixman_image_t *       pDst,
530
 
                                                 int16_t                xSrc,
531
 
                                                 int16_t                ySrc,
532
 
                                                 int16_t                xMask,
533
 
                                                 int16_t                yMask,
534
 
                                                 int16_t                xDst,
535
 
                                                 int16_t                yDst,
536
 
                                                 uint16_t               width,
537
 
                                                 uint16_t               height);
538
 
void            pixman_image_composite          (pixman_op_t                op,
539
 
                                                 pixman_image_t            *src,
540
 
                                                 pixman_image_t               *mask,
541
 
                                                 pixman_image_t               *dest,
542
 
                                                 int16_t                       src_x,
543
 
                                                 int16_t                       src_y,
544
 
                                                 int16_t                       mask_x,
545
 
                                                 int16_t                       mask_y,
546
 
                                                 int16_t                       dest_x,
547
 
                                                 int16_t                       dest_y,
548
 
                                                 uint16_t                      width,
549
 
                                                 uint16_t                      height);
550
 
 
551
 
/*
552
 
 * Trapezoids
553
 
 */
554
 
typedef struct pixman_edge pixman_edge_t;
555
 
typedef struct pixman_trapezoid pixman_trapezoid_t;
556
 
typedef struct pixman_trap pixman_trap_t;
557
 
typedef struct pixman_span_fix pixman_span_fix_t;
558
 
 
559
 
/*
560
 
 * An edge structure.  This represents a single polygon edge
561
 
 * and can be quickly stepped across small or large gaps in the
562
 
 * sample grid
563
 
 */
564
 
struct pixman_edge
565
 
{
566
 
    pixman_fixed_t      x;
567
 
    pixman_fixed_t      e;
568
 
    pixman_fixed_t   stepx;
569
 
    pixman_fixed_t   signdx;
570
 
    pixman_fixed_t   dy;
571
 
    pixman_fixed_t   dx;
572
 
 
573
 
    pixman_fixed_t   stepx_small;
574
 
    pixman_fixed_t   stepx_big;
575
 
    pixman_fixed_t   dx_small;
576
 
    pixman_fixed_t   dx_big;
577
 
};
578
 
 
579
 
struct pixman_trapezoid
580
 
{
581
 
    pixman_fixed_t  top, bottom;
582
 
    pixman_line_fixed_t left, right;
583
 
};
584
 
 
585
 
 
586
 
/* whether 't' is a well defined not obviously empty trapezoid */
587
 
#define pixman_trapezoid_valid(t)                               \
588
 
    ((t)->left.p1.y != (t)->left.p2.y &&                           \
589
 
     (t)->right.p1.y != (t)->right.p2.y &&                         \
590
 
     (int) ((t)->bottom - (t)->top) > 0)
591
 
 
592
 
struct pixman_span_fix
593
 
{
594
 
    pixman_fixed_t      l, r, y;
595
 
};
596
 
 
597
 
struct pixman_trap
598
 
{
599
 
    pixman_span_fix_t   top, bot;
600
 
};
601
 
 
602
 
pixman_fixed_t pixman_sample_ceil_y        (pixman_fixed_t       y,
603
 
                                            int                  bpp);
604
 
pixman_fixed_t pixman_sample_floor_y       (pixman_fixed_t       y,
605
 
                                            int                  bpp);
606
 
void           pixman_edge_step            (pixman_edge_t       *e,
607
 
                                            int                  n);
608
 
void           pixman_edge_init            (pixman_edge_t       *e,
609
 
                                            int                  bpp,
610
 
                                            pixman_fixed_t       y_start,
611
 
                                            pixman_fixed_t       x_top,
612
 
                                            pixman_fixed_t       y_top,
613
 
                                            pixman_fixed_t       x_bot,
614
 
                                            pixman_fixed_t       y_bot);
615
 
void           pixman_line_fixed_edge_init (pixman_edge_t       *e,
616
 
                                            int                  bpp,
617
 
                                            pixman_fixed_t       y,
618
 
                                            const pixman_line_fixed_t *line,
619
 
                                            int                  x_off,
620
 
                                            int                  y_off);
621
 
void           pixman_rasterize_edges      (pixman_image_t      *image,
622
 
                                            pixman_edge_t       *l,
623
 
                                            pixman_edge_t       *r,
624
 
                                            pixman_fixed_t       t,
625
 
                                            pixman_fixed_t       b);
626
 
void           pixman_add_traps            (pixman_image_t      *image,
627
 
                                            int16_t              x_off,
628
 
                                            int16_t              y_off,
629
 
                                            int                  ntrap,
630
 
                                            pixman_trap_t       *traps);
631
 
void           pixman_add_trapezoids       (pixman_image_t      *image,
632
 
                                            int16_t              x_off,
633
 
                                            int                  y_off,
634
 
                                            int                  ntraps,
635
 
                                            const pixman_trapezoid_t  *traps);
636
 
void           pixman_rasterize_trapezoid  (pixman_image_t      *image,
637
 
                                            const pixman_trapezoid_t  *trap,
638
 
                                            int                  x_off,
639
 
                                            int                  y_off);
640
 
 
641
 
 
642
 
#endif /* PIXMAN_H__ */