← Back to branch summary

~ubuntu-branches/ubuntu/saucy/pixman/saucy-security

« back to all changes in this revision

Viewing changes to pixman/pixman-private.h

  • Committer: Bazaar Package Importer
  • Author(s): Julien Cristau
  • Date: 2009-09-28 18:12:47 UTC
  • mfrom: (1.1.8 upstream) (2.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090928181247-3iehog63i50htejf
Tags: 0.16.2-1
http://bugs.debian.org/546849
* New upstream release (closes: #546849).
* Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pixman/pixman-private.h
7
7
 
8
8
#include "pixman.h"
9
9
#include <time.h>
10
 
 
11
 
#ifndef FALSE
12
 
#define FALSE 0
13
 
#endif
14
 
 
15
 
#ifndef TRUE
16
 
#define TRUE 1
17
 
#endif
18
 
 
19
 
#define MSBFirst 0
20
 
#define LSBFirst 1
21
 
 
22
 
#ifdef WORDS_BIGENDIAN
23
 
#  define IMAGE_BYTE_ORDER MSBFirst
24
 
#  define BITMAP_BIT_ORDER MSBFirst
25
 
#else
26
 
#  define IMAGE_BYTE_ORDER LSBFirst
27
 
#  define BITMAP_BIT_ORDER LSBFirst
28
 
#endif
29
 
 
30
 
#undef DEBUG
31
 
#define DEBUG 0
32
 
 
33
 
#if defined (__GNUC__)
34
 
#  define FUNC     ((const char*) (__PRETTY_FUNCTION__))
35
 
#elif defined (__sun) || (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
36
 
#  define FUNC     ((const char*) (__func__))
37
 
#else
38
 
#  define FUNC     ((const char*) ("???"))
39
 
#endif
40
 
 
41
 
#ifndef INT16_MIN
42
 
# define INT16_MIN              (-32767-1)
43
 
#endif
44
 
 
45
 
#ifndef INT16_MAX
46
 
# define INT16_MAX              (32767)
47
 
#endif
48
 
 
49
 
#ifndef INT32_MIN
50
 
# define INT32_MIN              (-2147483647-1)
51
 
#endif
52
 
 
53
 
#ifndef INT32_MAX
54
 
# define INT32_MAX              (2147483647)
55
 
#endif
56
 
 
57
 
#ifndef UINT32_MIN
58
 
# define UINT32_MIN             (0)
59
 
#endif
60
 
 
61
 
#ifndef UINT32_MAX
62
 
# define UINT32_MAX             (4294967295U)
63
 
#endif
64
 
 
65
 
#ifndef M_PI
66
 
# define M_PI                   3.14159265358979323846
67
 
#endif
68
 
 
69
 
#ifdef _MSC_VER
70
 
/* 'inline' is available only in C++ in MSVC */
71
 
#   define inline __inline
72
 
#   define force_inline __forceinline
73
 
#elif defined __GNUC__
74
 
#   define inline __inline__
75
 
#   define force_inline __inline__ __attribute__ ((__always_inline__))
76
 
#else
77
 
# ifndef force_inline
78
 
#  define force_inline inline
79
 
# endif
80
 
#endif
81
 
 
82
 
#define FB_SHIFT    5
83
 
#define FB_UNIT     (1 << FB_SHIFT)
84
 
#define FB_HALFUNIT (1 << (FB_SHIFT-1))
85
 
#define FB_MASK     (FB_UNIT - 1)
86
 
#define FB_ALLONES  ((uint32_t) -1)
87
 
 
88
 
/* Memory allocation helpers */
89
 
void *pixman_malloc_ab (unsigned int n, unsigned int b);
90
 
void *pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);
91
 
pixman_bool_t pixman_multiply_overflows_int (unsigned int a, unsigned int b);
92
 
pixman_bool_t pixman_addition_overflows_int (unsigned int a, unsigned int b);
93
 
 
94
 
#if DEBUG
95
 
 
96
 
#define return_if_fail(expr)                                            \
97
 
    do                                                                  \
98
 
    {                                                                   \
99
 
        if (!(expr))                                                    \
100
 
        {                                                               \
101
 
            fprintf(stderr, "In %s: %s failed\n", FUNC, #expr);         \
102
 
            return;                                                     \
103
 
        }                                                               \
104
 
    }                                                                   \
105
 
    while (0)
106
 
 
107
 
#define return_val_if_fail(expr, retval)                                \
108
 
    do                                                                  \
109
 
    {                                                                   \
110
 
        if (!(expr))                                                    \
111
 
        {                                                               \
112
 
            fprintf(stderr, "In %s: %s failed\n", FUNC, #expr);         \
113
 
            return (retval);                                            \
114
 
        }                                                               \
115
 
    }                                                                   \
116
 
    while (0)
117
 
 
118
 
#else
119
 
 
120
 
#define return_if_fail(expr)                                            \
121
 
    do                                                                  \
122
 
    {                                                                   \
123
 
        if (!(expr))                                                    \
124
 
            return;                                                     \
125
 
    }                                                                   \
126
 
    while (0)
127
 
 
128
 
#define return_val_if_fail(expr, retval)                                \
129
 
    do                                                                  \
130
 
    {                                                                   \
131
 
        if (!(expr))                                                    \
132
 
            return (retval);                                            \
133
 
    }                                                                   \
134
 
    while (0)
135
 
 
136
 
#endif
137
 
 
 
10
#include <assert.h>
 
11
 
 
12
#include "pixman-compiler.h"
 
13
 
 
14
/*
 
15
 * Images
 
16
 */
138
17
typedef struct image_common image_common_t;
139
18
typedef struct source_image source_image_t;
140
19
typedef struct solid_fill solid_fill_t;
146
25
typedef struct radial_gradient radial_gradient_t;
147
26
typedef struct bits_image bits_image_t;
148
27
typedef struct circle circle_t;
149
 
typedef struct point point_t;
150
 
 
151
 
/* FIXME - the types and structures below should be give proper names
152
 
 */
153
 
 
154
 
#define FASTCALL
155
 
typedef FASTCALL void (*CombineMaskU32) (uint32_t *src, const uint32_t *mask, int width);
156
 
typedef FASTCALL void (*CombineFuncU32) (uint32_t *dest, const uint32_t *src, int width);
157
 
typedef FASTCALL void (*CombineFuncC32) (uint32_t *dest, uint32_t *src, uint32_t *mask, int width);
158
 
typedef FASTCALL void (*fetchProc32)(bits_image_t *pict, int x, int y, int width,
159
 
                                     uint32_t *buffer);
160
 
typedef FASTCALL uint32_t (*fetchPixelProc32)(bits_image_t *pict, int offset, int line);
161
 
typedef FASTCALL void (*storeProc32)(pixman_image_t *, uint32_t *bits,
162
 
                                     const uint32_t *values, int x, int width,
163
 
                                     const pixman_indexed_t *);
164
 
 
165
 
typedef FASTCALL void (*CombineMaskU64) (uint64_t *src, const uint64_t *mask, int width);
166
 
typedef FASTCALL void (*CombineFuncU64) (uint64_t *dest, const uint64_t *src, int width);
167
 
typedef FASTCALL void (*CombineFuncC64) (uint64_t *dest, uint64_t *src, uint64_t *mask, int width);
168
 
typedef FASTCALL void (*fetchProc64)(bits_image_t *pict, int x, int y, int width,
169
 
                                     uint64_t *buffer);
170
 
typedef FASTCALL uint64_t (*fetchPixelProc64)(bits_image_t *pict, int offset, int line);
171
 
typedef FASTCALL void (*storeProc64)(pixman_image_t *, uint32_t *bits,
172
 
                                     const uint64_t *values, int x, int width,
173
 
                                     const pixman_indexed_t *);
174
 
 
175
 
typedef struct _FbComposeData {
176
 
    uint8_t      op;
177
 
    pixman_image_t      *src;
178
 
    pixman_image_t      *mask;
179
 
    pixman_image_t      *dest;
180
 
    int16_t      xSrc;
181
 
    int16_t      ySrc;
182
 
    int16_t      xMask;
183
 
    int16_t      yMask;
184
 
    int16_t      xDest;
185
 
    int16_t      yDest;
186
 
    uint16_t     width;
187
 
    uint16_t     height;
188
 
} FbComposeData;
189
 
 
190
 
typedef struct _FbComposeFunctions32 {
191
 
    CombineFuncU32 *combineU;
192
 
    CombineFuncC32 *combineC;
193
 
    CombineMaskU32 combineMaskU;
194
 
} FbComposeFunctions32;
195
 
 
196
 
typedef struct _FbComposeFunctions64 {
197
 
    CombineFuncU64 *combineU;
198
 
    CombineFuncC64 *combineC;
199
 
    CombineMaskU64 combineMaskU;
200
 
} FbComposeFunctions64;
201
 
 
202
 
extern FbComposeFunctions32 pixman_composeFunctions;
203
 
extern FbComposeFunctions64 pixman_composeFunctions64;
204
 
 
205
 
void pixman_composite_rect_general_accessors (const FbComposeData *data,
206
 
                                              void *src_buffer,
207
 
                                              void *mask_buffer,
208
 
                                              void *dest_buffer,
209
 
                                              const int wide);
210
 
void pixman_composite_rect_general (const FbComposeData *data);
211
 
 
212
 
fetchProc32 pixman_fetchProcForPicture32 (bits_image_t *);
213
 
fetchPixelProc32 pixman_fetchPixelProcForPicture32 (bits_image_t *);
214
 
storeProc32 pixman_storeProcForPicture32 (bits_image_t *);
215
 
fetchProc32 pixman_fetchProcForPicture32_accessors (bits_image_t *);
216
 
fetchPixelProc32 pixman_fetchPixelProcForPicture32_accessors (bits_image_t *);
217
 
storeProc32 pixman_storeProcForPicture32_accessors (bits_image_t *);
218
 
 
219
 
fetchProc64 pixman_fetchProcForPicture64 (bits_image_t *);
220
 
fetchPixelProc64 pixman_fetchPixelProcForPicture64 (bits_image_t *);
221
 
storeProc64 pixman_storeProcForPicture64 (bits_image_t *);
222
 
fetchProc64 pixman_fetchProcForPicture64_accessors (bits_image_t *);
223
 
fetchPixelProc64 pixman_fetchPixelProcForPicture64_accessors (bits_image_t *);
224
 
storeProc64 pixman_storeProcForPicture64_accessors (bits_image_t *);
225
 
 
226
 
void pixman_expand(uint64_t *dst, const uint32_t *src, pixman_format_code_t, int width);
227
 
void pixman_contract(uint32_t *dst, const uint64_t *src, int width);
228
 
 
229
 
void pixmanFetchSourcePict(source_image_t *, int x, int y, int width,
230
 
                           uint32_t *buffer, uint32_t *mask, uint32_t maskBits);
231
 
void pixmanFetchSourcePict64(source_image_t *, int x, int y, int width,
232
 
                             uint64_t *buffer, uint64_t *mask, uint32_t maskBits);
233
 
 
234
 
void fbFetchTransformed(bits_image_t *, int x, int y, int width,
235
 
                        uint32_t *buffer, uint32_t *mask, uint32_t maskBits);
236
 
void fbStoreExternalAlpha(bits_image_t *, int x, int y, int width,
237
 
                          uint32_t *buffer);
238
 
void fbFetchExternalAlpha(bits_image_t *, int x, int y, int width,
239
 
                          uint32_t *buffer, uint32_t *mask, uint32_t maskBits);
240
 
 
241
 
void fbFetchTransformed_accessors(bits_image_t *, int x, int y, int width,
242
 
                                  uint32_t *buffer, uint32_t *mask,
243
 
                                  uint32_t maskBits);
244
 
void fbStoreExternalAlpha_accessors(bits_image_t *, int x, int y, int width,
245
 
                                    uint32_t *buffer);
246
 
void fbFetchExternalAlpha_accessors(bits_image_t *, int x, int y, int width,
247
 
                                    uint32_t *buffer, uint32_t *mask,
248
 
                                    uint32_t maskBits);
249
 
 
250
 
void fbFetchTransformed64(bits_image_t *, int x, int y, int width,
251
 
                          uint64_t *buffer, uint64_t *mask, uint32_t maskBits);
252
 
void fbStoreExternalAlpha64(bits_image_t *, int x, int y, int width,
253
 
                            uint64_t *buffer);
254
 
void fbFetchExternalAlpha64(bits_image_t *, int x, int y, int width,
255
 
                            uint64_t *buffer, uint64_t *mask, uint32_t maskBits);
256
 
 
257
 
void fbFetchTransformed64_accessors(bits_image_t *, int x, int y, int width,
258
 
                                    uint64_t *buffer, uint64_t *mask,
259
 
                                    uint32_t maskBits);
260
 
void fbStoreExternalAlpha64_accessors(bits_image_t *, int x, int y, int width,
261
 
                                      uint64_t *buffer);
262
 
void fbFetchExternalAlpha64_accessors(bits_image_t *, int x, int y, int width,
263
 
                                      uint64_t *buffer, uint64_t *mask,
264
 
                                      uint32_t maskBits);
265
 
 
266
 
/* end */
 
28
 
 
29
typedef void (*fetch_scanline_t) (pixman_image_t *image,
 
30
                                  int             x,
 
31
                                  int             y,
 
32
                                  int             width,
 
33
                                  uint32_t       *buffer,
 
34
                                  const uint32_t *mask,
 
35
                                  uint32_t        mask_bits);
 
36
 
 
37
typedef uint32_t (*fetch_pixel_32_t) (bits_image_t *image,
 
38
                                      int           x,
 
39
                                      int           y);
 
40
 
 
41
typedef uint64_t (*fetch_pixel_64_t) (bits_image_t *image,
 
42
                                      int           x,
 
43
                                      int           y);
 
44
 
 
45
typedef void (*store_scanline_t) (bits_image_t *  image,
 
46
                                  int             x,
 
47
                                  int             y,
 
48
                                  int             width,
 
49
                                  const uint32_t *values);
267
50
 
268
51
typedef enum
269
52
{
274
57
    SOLID
275
58
} image_type_t;
276
59
 
277
 
#define IS_SOURCE_IMAGE(img)     (((image_common_t *)img)->type > BITS)
278
 
 
279
60
typedef enum
280
61
{
281
62
    SOURCE_IMAGE_CLASS_UNKNOWN,
282
63
    SOURCE_IMAGE_CLASS_HORIZONTAL,
283
 
    SOURCE_IMAGE_CLASS_VERTICAL
284
 
} source_pict_class_t;
 
64
    SOURCE_IMAGE_CLASS_VERTICAL,
 
65
} source_image_class_t;
285
66
 
286
 
struct point
287
 
{
288
 
    int16_t x, y;
289
 
};
 
67
typedef source_image_class_t (*classify_func_t) (pixman_image_t *image,
 
68
                                                int             x,
 
69
                                                int             y,
 
70
                                                int             width,
 
71
                                                int             height);
 
72
typedef void (*property_changed_func_t) (pixman_image_t *image);
290
73
 
291
74
struct image_common
292
75
{
293
 
    image_type_t                type;
294
 
    int32_t                     ref_count;
295
 
    pixman_region32_t           full_region;
296
 
    pixman_region32_t           clip_region;
297
 
    pixman_region32_t          *src_clip;
298
 
    pixman_bool_t               has_client_clip;
299
 
    pixman_transform_t         *transform;
300
 
    pixman_repeat_t             repeat;
301
 
    pixman_filter_t             filter;
302
 
    pixman_fixed_t             *filter_params;
303
 
    int                         n_filter_params;
304
 
    bits_image_t               *alpha_map;
305
 
    point_t                     alpha_origin;
306
 
    pixman_bool_t               component_alpha;
307
 
    pixman_read_memory_func_t   read_func;
308
 
    pixman_write_memory_func_t  write_func;
 
76
    image_type_t                type;
 
77
    int32_t                     ref_count;
 
78
    pixman_region32_t           clip_region;
 
79
    pixman_bool_t               have_clip_region;   /* FALSE if there is no clip */
 
80
    pixman_bool_t               client_clip;        /* Whether the source clip was
 
81
                                                       set by a client */
 
82
    pixman_bool_t               clip_sources;       /* Whether the clip applies when
 
83
                                                     * the image is used as a source
 
84
                                                     */
 
85
    pixman_bool_t               dirty;
 
86
    pixman_bool_t               need_workaround;
 
87
    pixman_transform_t *        transform;
 
88
    pixman_repeat_t             repeat;
 
89
    pixman_filter_t             filter;
 
90
    pixman_fixed_t *            filter_params;
 
91
    int                         n_filter_params;
 
92
    bits_image_t *              alpha_map;
 
93
    int                         alpha_origin_x;
 
94
    int                         alpha_origin_y;
 
95
    pixman_bool_t               component_alpha;
 
96
    classify_func_t             classify;
 
97
    property_changed_func_t     property_changed;
 
98
    fetch_scanline_t            get_scanline_32;
 
99
    fetch_scanline_t            get_scanline_64;
 
100
 
 
101
    pixman_image_destroy_func_t destroy_func;
 
102
    void *                      destroy_data;
309
103
};
310
104
 
311
105
struct source_image
312
106
{
313
 
    image_common_t      common;
314
 
    source_pict_class_t class;
 
107
    image_common_t common;
 
108
    source_image_class_t class;
315
109
};
316
110
 
317
111
struct solid_fill
318
112
{
319
 
    source_image_t      common;
320
 
    uint32_t            color;          /* FIXME: shouldn't this be a pixman_color_t? */
 
113
    source_image_t common;
 
114
    uint32_t       color;    /* FIXME: shouldn't this be a pixman_color_t? */
321
115
};
322
116
 
323
117
struct gradient
324
118
{
325
 
    source_image_t              common;
326
 
    int                         n_stops;
327
 
    pixman_gradient_stop_t *    stops;
328
 
    int                         stop_range;
329
 
    uint32_t *                  color_table;
330
 
    int                         color_table_size;
 
119
    source_image_t          common;
 
120
    int                     n_stops;
 
121
    pixman_gradient_stop_t *stops;
 
122
    int                     stop_range;
 
123
    uint32_t *              color_table;
 
124
    int                     color_table_size;
331
125
};
332
126
 
333
127
struct linear_gradient
334
128
{
335
 
    gradient_t                  common;
336
 
    pixman_point_fixed_t        p1;
337
 
    pixman_point_fixed_t        p2;
 
129
    gradient_t           common;
 
130
    pixman_point_fixed_t p1;
 
131
    pixman_point_fixed_t p2;
338
132
};
339
133
 
340
134
struct circle
346
140
 
347
141
struct radial_gradient
348
142
{
349
 
    gradient_t  common;
 
143
    gradient_t common;
350
144
 
351
 
    circle_t    c1;
352
 
    circle_t    c2;
353
 
    double      cdx;
354
 
    double      cdy;
355
 
    double      dr;
356
 
    double      A;
 
145
    circle_t   c1;
 
146
    circle_t   c2;
 
147
    double     cdx;
 
148
    double     cdy;
 
149
    double     dr;
 
150
    double     A;
357
151
};
358
152
 
359
153
struct conical_gradient
360
154
{
361
 
    gradient_t                  common;
362
 
    pixman_point_fixed_t        center;
363
 
    pixman_fixed_t              angle;
 
155
    gradient_t           common;
 
156
    pixman_point_fixed_t center;
 
157
    pixman_fixed_t       angle;
364
158
};
365
159
 
366
160
struct bits_image
367
161
{
368
 
    image_common_t              common;
369
 
    pixman_format_code_t        format;
370
 
    const pixman_indexed_t     *indexed;
371
 
    int                         width;
372
 
    int                         height;
373
 
    uint32_t *                  bits;
374
 
    uint32_t *                  free_me;
375
 
    int                         rowstride; /* in number of uint32_t's */
 
162
    image_common_t             common;
 
163
    pixman_format_code_t       format;
 
164
    const pixman_indexed_t *   indexed;
 
165
    int                        width;
 
166
    int                        height;
 
167
    uint32_t *                 bits;
 
168
    uint32_t *                 free_me;
 
169
    int                        rowstride;  /* in number of uint32_t's */
 
170
 
 
171
    /* Fetch a pixel, disregarding alpha maps, transformations etc. */
 
172
    fetch_pixel_32_t           fetch_pixel_raw_32;
 
173
    fetch_pixel_64_t           fetch_pixel_raw_64;
 
174
 
 
175
    /* Fetch a pixel, taking alpha maps into account */
 
176
    fetch_pixel_32_t           fetch_pixel_32;
 
177
    fetch_pixel_64_t           fetch_pixel_64;
 
178
 
 
179
    /* Fetch raw scanlines, with no regard for transformations, alpha maps etc. */
 
180
    fetch_scanline_t           fetch_scanline_raw_32;
 
181
    fetch_scanline_t           fetch_scanline_raw_64;
 
182
 
 
183
    /* Store scanlines with no regard for alpha maps */
 
184
    store_scanline_t           store_scanline_raw_32;
 
185
    store_scanline_t           store_scanline_raw_64;
 
186
 
 
187
    /* Store a scanline, taking alpha maps into account */
 
188
    store_scanline_t           store_scanline_32;
 
189
    store_scanline_t           store_scanline_64;
 
190
 
 
191
    /* Used for indirect access to the bits */
 
192
    pixman_read_memory_func_t  read_func;
 
193
    pixman_write_memory_func_t write_func;
376
194
};
377
195
 
378
196
union pixman_image
379
197
{
380
 
    image_type_t                type;
381
 
    image_common_t              common;
382
 
    bits_image_t                bits;
383
 
    gradient_t                  gradient;
384
 
    linear_gradient_t           linear;
385
 
    conical_gradient_t          conical;
386
 
    radial_gradient_t           radial;
387
 
    solid_fill_t                solid;
 
198
    image_type_t       type;
 
199
    image_common_t     common;
 
200
    bits_image_t       bits;
 
201
    source_image_t     source;
 
202
    gradient_t         gradient;
 
203
    linear_gradient_t  linear;
 
204
    conical_gradient_t conical;
 
205
    radial_gradient_t  radial;
 
206
    solid_fill_t       solid;
388
207
};
389
208
 
390
209
 
391
 
#define LOG2_BITMAP_PAD 5
392
 
#define FB_STIP_SHIFT   LOG2_BITMAP_PAD
393
 
#define FB_STIP_UNIT    (1 << FB_STIP_SHIFT)
394
 
#define FB_STIP_MASK    (FB_STIP_UNIT - 1)
395
 
#define FB_STIP_ALLONES ((uint32_t) -1)
396
 
 
397
 
#if BITMAP_BIT_ORDER == LSBFirst
398
 
#define FbScrLeft(x,n)  ((x) >> (n))
399
 
#define FbScrRight(x,n) ((x) << (n))
400
 
#define FbLeftStipBits(x,n) ((x) & ((((uint32_t) 1) << (n)) - 1))
401
 
#else
402
 
#define FbScrLeft(x,n)  ((x) << (n))
403
 
#define FbScrRight(x,n) ((x) >> (n))
404
 
#define FbLeftStipBits(x,n) ((x) >> (FB_STIP_UNIT - (n)))
405
 
#endif
406
 
 
407
 
#define FbStipLeft(x,n) FbScrLeft(x,n)
408
 
#define FbStipRight(x,n) FbScrRight(x,n)
409
 
#define FbStipMask(x,w) (FbStipRight(FB_STIP_ALLONES,(x) & FB_STIP_MASK) & \
410
 
                         FbStipLeft(FB_STIP_ALLONES,(FB_STIP_UNIT - ((x)+(w))) & FB_STIP_MASK))
411
 
 
412
 
#define FbLeftMask(x)       ( ((x) & FB_MASK) ? \
413
 
                              FbScrRight(FB_ALLONES,(x) & FB_MASK) : 0)
414
 
#define FbRightMask(x)      ( ((FB_UNIT - (x)) & FB_MASK) ? \
415
 
                              FbScrLeft(FB_ALLONES,(FB_UNIT - (x)) & FB_MASK) : 0)
416
 
 
417
 
#define FbMaskBits(x,w,l,n,r) {                                         \
418
 
        n = (w); \
419
 
        r = FbRightMask((x)+n); \
420
 
        l = FbLeftMask(x); \
421
 
        if (l) { \
422
 
            n -= FB_UNIT - ((x) & FB_MASK); \
423
 
            if (n < 0) { \
424
 
                n = 0; \
425
 
                l &= r; \
426
 
                r = 0; \
427
 
            } \
428
 
        } \
429
 
        n >>= FB_SHIFT; \
430
 
    }
431
 
 
432
 
#if IMAGE_BYTE_ORDER == MSBFirst
433
 
#define Fetch24(img, a)  ((unsigned long) (a) & 1 ?           \
434
 
    ((READ(img, a) << 16) | READ(img, (uint16_t *) ((a)+1))) : \
435
 
    ((READ(img, (uint16_t *) (a)) << 8) | READ(img, (a)+2)))
436
 
#define Store24(img,a,v) ((unsigned long) (a) & 1 ? \
437
 
    (WRITE(img, a, (uint8_t) ((v) >> 16)),                \
438
 
     WRITE(img, (uint16_t *) ((a)+1), (uint16_t) (v))) :  \
439
 
    (WRITE(img, (uint16_t *) (a), (uint16_t) ((v) >> 8)), \
440
 
     WRITE(img, (a)+2, (uint8_t) (v))))
441
 
#else
442
 
#define Fetch24(img,a)  ((unsigned long) (a) & 1 ?                           \
443
 
    (READ(img, a) | (READ(img, (uint16_t *) ((a)+1)) << 8)) : \
444
 
    (READ(img, (uint16_t *) (a)) | (READ(img, (a)+2) << 16)))
445
 
#define Store24(img,a,v) ((unsigned long) (a) & 1 ? \
446
 
    (WRITE(img, a, (uint8_t) (v)),                              \
447
 
     WRITE(img, (uint16_t *) ((a)+1), (uint16_t) ((v) >> 8))) : \
448
 
    (WRITE(img, (uint16_t *) (a), (uint16_t) (v)),              \
449
 
     WRITE(img, (a)+2, (uint8_t) ((v) >> 16))))
450
 
#endif
451
 
 
452
 
#define CvtR8G8B8toY15(s)       (((((s) >> 16) & 0xff) * 153 + \
453
 
                                  (((s) >>  8) & 0xff) * 301 +          \
454
 
                                  (((s)      ) & 0xff) * 58) >> 2)
455
 
#define miCvtR8G8B8to15(s) ((((s) >> 3) & 0x001f) |  \
456
 
                            (((s) >> 6) & 0x03e0) |  \
457
 
                            (((s) >> 9) & 0x7c00))
458
 
#define miIndexToEnt15(mif,rgb15) ((mif)->ent[rgb15])
459
 
#define miIndexToEnt24(mif,rgb24) miIndexToEnt15(mif,miCvtR8G8B8to15(rgb24))
460
 
 
461
 
#define miIndexToEntY24(mif,rgb24) ((mif)->ent[CvtR8G8B8toY15(rgb24)])
462
 
 
463
 
 
464
 
#define FbIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) )
465
 
#define FbIntDiv(a,b)    (((uint16_t) (a) * 255) / (b))
466
 
 
467
 
#define FbGet8(v,i)   ((uint16_t) (uint8_t) ((v) >> i))
468
 
 
469
 
 
470
 
#define cvt8888to0565(s)    ((((s) >> 3) & 0x001f) | \
471
 
                             (((s) >> 5) & 0x07e0) | \
472
 
                             (((s) >> 8) & 0xf800))
473
 
#define cvt0565to0888(s)    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \
474
 
                             ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) | \
475
 
                             ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
476
 
 
477
 
/*
478
 
 * There are two ways of handling alpha -- either as a single unified value or
479
 
 * a separate value for each component, hence each macro must have two
480
 
 * versions.  The unified alpha version has a 'U' at the end of the name,
481
 
 * the component version has a 'C'.  Similarly, functions which deal with
482
 
 * this difference will have two versions using the same convention.
483
 
 */
484
 
 
485
 
#define FbOverU(x,y,i,a,t) ((t) = FbIntMult(FbGet8(y,i),(a),(t)) + FbGet8(x,i), \
486
 
                            (uint32_t) ((uint8_t) ((t) | (0 - ((t) >> 8)))) << (i))
487
 
 
488
 
#define FbOverC(x,y,i,a,t) ((t) = FbIntMult(FbGet8(y,i),FbGet8(a,i),(t)) + FbGet8(x,i), \
489
 
                            (uint32_t) ((uint8_t) ((t) | (0 - ((t) >> 8)))) << (i))
490
 
 
491
 
#define FbInU(x,i,a,t) ((uint32_t) FbIntMult(FbGet8(x,i),(a),(t)) << (i))
492
 
 
493
 
#define FbInC(x,i,a,t) ((uint32_t) FbIntMult(FbGet8(x,i),FbGet8(a,i),(t)) << (i))
494
 
 
495
 
#define FbAdd(x,y,i,t)  ((t) = FbGet8(x,i) + FbGet8(y,i),               \
496
 
                         (uint32_t) ((uint8_t) ((t) | (0 - ((t) >> 8)))) << (i))
497
 
 
498
 
#define div_255(x) (((x) + 0x80 + (((x) + 0x80) >> 8)) >> 8)
499
 
#define div_65535(x) (((x) + 0x8000 + (((x) + 0x8000) >> 16)) >> 16)
500
 
 
501
 
#define MOD(a,b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
502
 
 
503
 
#define DIV(a,b) ((((a) < 0) == ((b) < 0)) ? (a) / (b) :                \
504
 
                  ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
505
 
 
506
 
#define CLIP(a,b,c) ((a) < (b) ? (b) : ((a) > (c) ? (c) : (a)))
507
 
 
508
 
#if 0
509
 
/* FIXME: the MOD macro above is equivalent, but faster I think */
510
 
#define mod(a,b) ((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b))
511
 
#endif
512
 
 
513
 
/* FIXME: the (void)__read_func hides lots of warnings (which is what they
514
 
 * are supposed to do), but some of them are real. For example the one
515
 
 * where Fetch4 doesn't have a READ
516
 
 */
517
 
 
518
 
#if 0
519
 
/* Framebuffer access support macros */
520
 
#define ACCESS_MEM(code)                                                \
521
 
    do {                                                                \
522
 
        const image_common_t *const com__ =                             \
523
 
            (image_common_t *)image;                                    \
524
 
                                                                        \
525
 
        if (!com__->read_func && !com__->write_func)                    \
526
 
        {                                                               \
527
 
            const int do_access__ = 0;                                  \
528
 
            const pixman_read_memory_func_t read_func__ = NULL;         \
529
 
            const pixman_write_memory_func_t write_func__ = NULL;       \
530
 
            (void)read_func__;                                          \
531
 
            (void)write_func__;                                         \
532
 
            (void)do_access__;                                          \
533
 
                                                                        \
534
 
            {code}                                                      \
535
 
        }                                                               \
536
 
        else                                                            \
537
 
        {                                                               \
538
 
            const int do_access__ = 1;                                  \
539
 
            const pixman_read_memory_func_t read_func__ =               \
540
 
                com__->read_func;                                       \
541
 
            const pixman_write_memory_func_t write_func__ =             \
542
 
                com__->write_func;                                      \
543
 
            (void)read_func__;                                          \
544
 
            (void)write_func__;                                         \
545
 
            (void)do_access__;                                          \
546
 
                                                                        \
547
 
            {code}                                                      \
548
 
        }                                                               \
549
 
    } while (0)
550
 
#endif
551
 
 
552
 
#ifdef PIXMAN_FB_ACCESSORS
553
 
 
554
 
#define ACCESS(sym) sym##_accessors
555
 
 
556
 
#define READ(img, ptr)                                                  \
557
 
    ((img)->common.read_func ((ptr), sizeof(*(ptr))))
558
 
#define WRITE(img, ptr,val)                                             \
559
 
    ((img)->common.write_func ((ptr), (val), sizeof (*(ptr))))
560
 
 
561
 
#define MEMCPY_WRAPPED(img, dst, src, size)                             \
562
 
    do {                                                                \
563
 
        size_t _i;                                                      \
564
 
        uint8_t *_dst = (uint8_t*)(dst), *_src = (uint8_t*)(src);       \
565
 
        for(_i = 0; _i < size; _i++) {                                  \
566
 
            WRITE((img), _dst +_i, READ((img), _src + _i));             \
567
 
        }                                                               \
568
 
    } while (0)
569
 
 
570
 
#define MEMSET_WRAPPED(img, dst, val, size)                             \
571
 
    do {                                                                \
572
 
        size_t _i;                                                      \
573
 
        uint8_t *_dst = (uint8_t*)(dst);                                \
574
 
        for(_i = 0; _i < (size_t) size; _i++) {                         \
575
 
            WRITE((img), _dst +_i, (val));                              \
576
 
        }                                                               \
577
 
    } while (0)
578
 
 
579
 
#else
580
 
 
581
 
#define ACCESS(sym) sym
582
 
 
583
 
#define READ(img, ptr)          (*(ptr))
584
 
#define WRITE(img, ptr, val)    (*(ptr) = (val))
585
 
#define MEMCPY_WRAPPED(img, dst, src, size)                                     \
586
 
    memcpy(dst, src, size)
587
 
#define MEMSET_WRAPPED(img, dst, val, size)                                     \
588
 
    memset(dst, val, size)
589
 
 
590
 
#endif
591
 
 
592
 
#define fbComposeGetSolid(img, res, fmt)                                \
 
210
void
 
211
_pixman_bits_image_setup_raw_accessors (bits_image_t *image);
 
212
 
 
213
void
 
214
_pixman_image_get_scanline_generic_64  (pixman_image_t *image,
 
215
                                        int             x,
 
216
                                        int             y,
 
217
                                        int             width,
 
218
                                        uint32_t *      buffer,
 
219
                                        const uint32_t *mask,
 
220
                                        uint32_t        mask_bits);
 
221
 
 
222
source_image_class_t
 
223
_pixman_image_classify (pixman_image_t *image,
 
224
                        int             x,
 
225
                        int             y,
 
226
                        int             width,
 
227
                        int             height);
 
228
 
 
229
void
 
230
_pixman_image_get_scanline_32 (pixman_image_t *image,
 
231
                               int             x,
 
232
                               int             y,
 
233
                               int             width,
 
234
                               uint32_t *      buffer,
 
235
                               const uint32_t *mask,
 
236
                               uint32_t        mask_bits);
 
237
 
 
238
/* Even thought the type of buffer is uint32_t *, the function actually expects
 
239
 * a uint64_t *buffer.
 
240
 */
 
241
void
 
242
_pixman_image_get_scanline_64 (pixman_image_t *image,
 
243
                               int             x,
 
244
                               int             y,
 
245
                               int             width,
 
246
                               uint32_t *      buffer,
 
247
                               const uint32_t *unused,
 
248
                               uint32_t        unused2);
 
249
 
 
250
void
 
251
_pixman_image_store_scanline_32 (bits_image_t *  image,
 
252
                                 int             x,
 
253
                                 int             y,
 
254
                                 int             width,
 
255
                                 const uint32_t *buffer);
 
256
void
 
257
_pixman_image_fetch_pixels (bits_image_t *image,
 
258
                            uint32_t *    buffer,
 
259
                            int           n_pixels);
 
260
 
 
261
/* Even though the type of buffer is uint32_t *, the function
 
262
 * actually expects a uint64_t *buffer.
 
263
 */
 
264
void
 
265
_pixman_image_store_scanline_64 (bits_image_t *  image,
 
266
                                 int             x,
 
267
                                 int             y,
 
268
                                 int             width,
 
269
                                 const uint32_t *buffer);
 
270
 
 
271
pixman_image_t *
 
272
_pixman_image_allocate (void);
 
273
 
 
274
pixman_bool_t
 
275
_pixman_init_gradient (gradient_t *                  gradient,
 
276
                       const pixman_gradient_stop_t *stops,
 
277
                       int                           n_stops);
 
278
void
 
279
_pixman_image_reset_clip_region (pixman_image_t *image);
 
280
 
 
281
void
 
282
_pixman_image_validate (pixman_image_t *image);
 
283
 
 
284
pixman_bool_t
 
285
_pixman_image_is_opaque (pixman_image_t *image);
 
286
 
 
287
pixman_bool_t
 
288
_pixman_image_is_solid (pixman_image_t *image);
 
289
 
 
290
uint32_t
 
291
_pixman_image_get_solid (pixman_image_t *     image,
 
292
                         pixman_format_code_t format);
 
293
 
 
294
#define PIXMAN_IMAGE_GET_LINE(image, x, y, type, out_stride, line, mul) \
593
295
    do                                                                  \
594
296
    {                                                                   \
595
 
        pixman_format_code_t format__;                                  \
596
 
        if (img->type == SOLID)                                         \
597
 
        {                                                               \
598
 
            format__ = PIXMAN_a8r8g8b8;                                 \
599
 
            (res) = img->solid.color;                                   \
600
 
        }                                                               \
601
 
        else                                                            \
602
 
        {                                                               \
603
 
            uint32_t           *bits__   = (img)->bits.bits;            \
604
 
            format__ = (img)->bits.format;                              \
605
 
                                                                        \
606
 
            switch (PIXMAN_FORMAT_BPP((img)->bits.format))              \
607
 
            {                                                           \
608
 
            case 32:                                                    \
609
 
                (res) = READ(img, (uint32_t *)bits__);                  \
610
 
                break;                                                  \
611
 
            case 24:                                                    \
612
 
                (res) = Fetch24(img, (uint8_t *) bits__);                       \
613
 
                break;                                                  \
614
 
            case 16:                                                    \
615
 
                (res) = READ(img, (uint16_t *) bits__);                 \
616
 
                (res) = cvt0565to0888(res);                             \
617
 
                break;                                                  \
618
 
            case 8:                                                     \
619
 
                (res) = READ(img, (uint8_t *) bits__);                  \
620
 
                (res) = (res) << 24;                                    \
621
 
                break;                                                  \
622
 
            case 1:                                                     \
623
 
                (res) = READ(img, (uint32_t *) bits__);                 \
624
 
                (res) = FbLeftStipBits((res),1) ? 0xff000000 : 0x00000000; \
625
 
                break;                                                  \
626
 
            default:                                                    \
627
 
                return;                                                 \
628
 
            }                                                           \
629
 
            /* manage missing src alpha */                              \
630
 
            if (!PIXMAN_FORMAT_A((img)->bits.format))                   \
631
 
                (res) |= 0xff000000;                                    \
632
 
        }                                                               \
633
 
                                                                        \
634
 
        /* If necessary, convert RGB <--> BGR. */                       \
635
 
        if (PIXMAN_FORMAT_TYPE (format__) != PIXMAN_FORMAT_TYPE(fmt))   \
636
 
        {                                                               \
637
 
            (res) = ((((res) & 0xff000000) >>  0) |                     \
638
 
                     (((res) & 0x00ff0000) >> 16) |                     \
639
 
                     (((res) & 0x0000ff00) >>  0) |                     \
640
 
                     (((res) & 0x000000ff) << 16));                     \
641
 
        }                                                               \
642
 
    }                                                                   \
643
 
    while (0)
644
 
 
645
 
#define fbComposeGetStart(pict,x,y,type,out_stride,line,mul) do {       \
646
 
        uint32_t        *__bits__;                                      \
647
 
        int             __stride__;                                     \
648
 
        int             __bpp__;                                        \
649
 
                                                                        \
650
 
        __bits__ = pict->bits.bits;                                     \
651
 
        __stride__ = pict->bits.rowstride;                              \
652
 
        __bpp__ = PIXMAN_FORMAT_BPP(pict->bits.format);                 \
653
 
        (out_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type);      \
654
 
        (line) = ((type *) __bits__) +                                  \
655
 
            (out_stride) * (y) + (mul) * (x);                           \
 
297
        uint32_t *__bits__;                                             \
 
298
        int       __stride__;                                           \
 
299
                                                                        \
 
300
        __bits__ = image->bits.bits;                                    \
 
301
        __stride__ = image->bits.rowstride;                             \
 
302
        (out_stride) =                                                  \
 
303
            __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type); \
 
304
        (line) =                                                        \
 
305
            ((type *) __bits__) + (out_stride) * (y) + (mul) * (x);     \
656
306
    } while (0)
657
307
 
658
 
 
659
 
#define PIXMAN_FORMAT_16BPC(f)  (PIXMAN_FORMAT_A(f) > 8 || \
660
 
                                 PIXMAN_FORMAT_R(f) > 8 || \
661
 
                                 PIXMAN_FORMAT_G(f) > 8 || \
662
 
                                 PIXMAN_FORMAT_B(f) > 8)
 
308
/*
 
309
 * Gradient walker
 
310
 */
 
311
typedef struct
 
312
{
 
313
    uint32_t                left_ag;
 
314
    uint32_t                left_rb;
 
315
    uint32_t                right_ag;
 
316
    uint32_t                right_rb;
 
317
    int32_t                 left_x;
 
318
    int32_t                 right_x;
 
319
    int32_t                 stepper;
 
320
 
 
321
    pixman_gradient_stop_t *stops;
 
322
    int                     num_stops;
 
323
    unsigned int            spread;
 
324
 
 
325
    int                     need_reset;
 
326
} pixman_gradient_walker_t;
 
327
 
 
328
void
 
329
_pixman_gradient_walker_init (pixman_gradient_walker_t *walker,
 
330
                              gradient_t *              gradient,
 
331
                              unsigned int              spread);
 
332
 
 
333
void
 
334
_pixman_gradient_walker_reset (pixman_gradient_walker_t *walker,
 
335
                               pixman_fixed_32_32_t      pos);
 
336
 
 
337
uint32_t
 
338
_pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
 
339
                               pixman_fixed_32_32_t      x);
 
340
 
663
341
/*
664
342
 * Edges
665
343
 */
666
344
 
667
 
#define MAX_ALPHA(n)    ((1 << (n)) - 1)
668
 
#define N_Y_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n)/2)) - 1)
669
 
#define N_X_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n)/2)) + 1)
670
 
 
671
 
#define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC(n))
672
 
#define STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC(n) - 1) * STEP_Y_SMALL(n))
673
 
 
674
 
#define Y_FRAC_FIRST(n) (STEP_Y_SMALL(n) / 2)
675
 
#define Y_FRAC_LAST(n)  (Y_FRAC_FIRST(n) + (N_Y_FRAC(n) - 1) * STEP_Y_SMALL(n))
676
 
 
677
 
#define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC(n))
678
 
#define STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC(n) - 1) * STEP_X_SMALL(n))
679
 
 
680
 
#define X_FRAC_FIRST(n) (STEP_X_SMALL(n) / 2)
681
 
#define X_FRAC_LAST(n)  (X_FRAC_FIRST(n) + (N_X_FRAC(n) - 1) * STEP_X_SMALL(n))
682
 
 
683
 
#define RenderSamplesX(x,n)     ((n) == 1 ? 0 : (pixman_fixed_frac (x) + X_FRAC_FIRST(n)) / STEP_X_SMALL(n))
684
 
 
685
 
/*
686
 
 * Step across a small sample grid gap
687
 
 */
688
 
#define RenderEdgeStepSmall(edge) { \
689
 
    edge->x += edge->stepx_small;   \
690
 
    edge->e += edge->dx_small;      \
691
 
    if (edge->e > 0)                \
692
 
    {                               \
693
 
        edge->e -= edge->dy;        \
694
 
        edge->x += edge->signdx;    \
695
 
    }                               \
696
 
}
697
 
 
698
 
/*
699
 
 * Step across a large sample grid gap
700
 
 */
701
 
#define RenderEdgeStepBig(edge) {   \
702
 
    edge->x += edge->stepx_big;     \
703
 
    edge->e += edge->dx_big;        \
704
 
    if (edge->e > 0)                \
705
 
    {                               \
706
 
        edge->e -= edge->dy;        \
707
 
        edge->x += edge->signdx;    \
708
 
    }                               \
709
 
}
 
345
#define MAX_ALPHA(n)    ((1 << (n)) - 1)
 
346
#define N_Y_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)
 
347
#define N_X_FRAC(n)     ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)
 
348
 
 
349
#define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC (n))
 
350
#define STEP_Y_BIG(n)   (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
 
351
 
 
352
#define Y_FRAC_FIRST(n) (STEP_Y_SMALL (n) / 2)
 
353
#define Y_FRAC_LAST(n)  (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
 
354
 
 
355
#define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC (n))
 
356
#define STEP_X_BIG(n)   (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
 
357
 
 
358
#define X_FRAC_FIRST(n) (STEP_X_SMALL (n) / 2)
 
359
#define X_FRAC_LAST(n)  (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
 
360
 
 
361
#define RENDER_SAMPLES_X(x, n)                                          \
 
362
    ((n) == 1? 0 : (pixman_fixed_frac (x) +                             \
 
363
                    X_FRAC_FIRST (n)) / STEP_X_SMALL (n))
710
364
 
711
365
void
712
366
pixman_rasterize_edges_accessors (pixman_image_t *image,
713
 
                                  pixman_edge_t *l,
714
 
                                  pixman_edge_t *r,
715
 
                                  pixman_fixed_t        t,
716
 
                                  pixman_fixed_t        b);
717
 
 
718
 
pixman_bool_t
719
 
pixman_image_is_opaque(pixman_image_t *image);
720
 
 
721
 
pixman_bool_t
722
 
pixman_image_can_get_solid (pixman_image_t *image);
723
 
 
724
 
pixman_bool_t
725
 
pixman_compute_composite_region32 (pixman_region32_t *  pRegion,
726
 
                                   pixman_image_t *     pSrc,
727
 
                                   pixman_image_t *     pMask,
728
 
                                   pixman_image_t *     pDst,
729
 
                                   int16_t              xSrc,
730
 
                                   int16_t              ySrc,
731
 
                                   int16_t              xMask,
732
 
                                   int16_t              yMask,
733
 
                                   int16_t              xDst,
734
 
                                   int16_t              yDst,
735
 
                                   uint16_t             width,
736
 
                                   uint16_t             height);
737
 
 
738
 
/* GCC visibility */
739
 
#if defined(__GNUC__) && __GNUC__ >= 4
740
 
#define PIXMAN_EXPORT __attribute__ ((visibility("default")))
741
 
/* Sun Studio 8 visibility */
742
 
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
743
 
#define PIXMAN_EXPORT __global
744
 
#else
745
 
#define PIXMAN_EXPORT
746
 
#endif
 
367
                                  pixman_edge_t * l,
 
368
                                  pixman_edge_t * r,
 
369
                                  pixman_fixed_t  t,
 
370
                                  pixman_fixed_t  b);
 
371
 
 
372
/*
 
373
 * Implementations
 
374
 */
 
375
 
 
376
typedef struct pixman_implementation_t pixman_implementation_t;
 
377
 
 
378
typedef void (*pixman_combine_32_func_t) (pixman_implementation_t *imp,
 
379
                                          pixman_op_t              op,
 
380
                                          uint32_t *               dest,
 
381
                                          const uint32_t *         src,
 
382
                                          const uint32_t *         mask,
 
383
                                          int                      width);
 
384
 
 
385
typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,
 
386
                                          pixman_op_t              op,
 
387
                                          uint64_t *               dest,
 
388
                                          const uint64_t *         src,
 
389
                                          const uint64_t *         mask,
 
390
                                          int                      width);
 
391
 
 
392
typedef void (*pixman_composite_func_t) (pixman_implementation_t *imp,
 
393
                                         pixman_op_t              op,
 
394
                                         pixman_image_t *         src,
 
395
                                         pixman_image_t *         mask,
 
396
                                         pixman_image_t *         dest,
 
397
                                         int32_t                  src_x,
 
398
                                         int32_t                  src_y,
 
399
                                         int32_t                  mask_x,
 
400
                                         int32_t                  mask_y,
 
401
                                         int32_t                  dest_x,
 
402
                                         int32_t                  dest_y,
 
403
                                         int32_t                  width,
 
404
                                         int32_t                  height);
 
405
typedef pixman_bool_t (*pixman_blt_func_t) (pixman_implementation_t *imp,
 
406
                                            uint32_t *               src_bits,
 
407
                                            uint32_t *               dst_bits,
 
408
                                            int                      src_stride,
 
409
                                            int                      dst_stride,
 
410
                                            int                      src_bpp,
 
411
                                            int                      dst_bpp,
 
412
                                            int                      src_x,
 
413
                                            int                      src_y,
 
414
                                            int                      dst_x,
 
415
                                            int                      dst_y,
 
416
                                            int                      width,
 
417
                                            int                      height);
 
418
typedef pixman_bool_t (*pixman_fill_func_t) (pixman_implementation_t *imp,
 
419
                                             uint32_t *               bits,
 
420
                                             int                      stride,
 
421
                                             int                      bpp,
 
422
                                             int                      x,
 
423
                                             int                      y,
 
424
                                             int                      width,
 
425
                                             int                      height,
 
426
                                             uint32_t                 xor);
 
427
 
 
428
void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);
 
429
void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);
 
430
 
 
431
struct pixman_implementation_t
 
432
{
 
433
    pixman_implementation_t *toplevel;
 
434
    pixman_implementation_t *delegate;
 
435
 
 
436
    pixman_composite_func_t  composite;
 
437
    pixman_blt_func_t        blt;
 
438
    pixman_fill_func_t       fill;
 
439
 
 
440
    pixman_combine_32_func_t combine_32[PIXMAN_OP_LAST];
 
441
    pixman_combine_32_func_t combine_32_ca[PIXMAN_OP_LAST];
 
442
    pixman_combine_64_func_t combine_64[PIXMAN_OP_LAST];
 
443
    pixman_combine_64_func_t combine_64_ca[PIXMAN_OP_LAST];
 
444
};
 
445
 
 
446
pixman_implementation_t *
 
447
_pixman_implementation_create (pixman_implementation_t *delegate);
 
448
 
 
449
void
 
450
_pixman_implementation_combine_32 (pixman_implementation_t *imp,
 
451
                                   pixman_op_t              op,
 
452
                                   uint32_t *               dest,
 
453
                                   const uint32_t *         src,
 
454
                                   const uint32_t *         mask,
 
455
                                   int                      width);
 
456
void
 
457
_pixman_implementation_combine_64 (pixman_implementation_t *imp,
 
458
                                   pixman_op_t              op,
 
459
                                   uint64_t *               dest,
 
460
                                   const uint64_t *         src,
 
461
                                   const uint64_t *         mask,
 
462
                                   int                      width);
 
463
void
 
464
_pixman_implementation_combine_32_ca (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_ca (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_composite (pixman_implementation_t *imp,
 
479
                                  pixman_op_t              op,
 
480
                                  pixman_image_t *         src,
 
481
                                  pixman_image_t *         mask,
 
482
                                  pixman_image_t *         dest,
 
483
                                  int32_t                  src_x,
 
484
                                  int32_t                  src_y,
 
485
                                  int32_t                  mask_x,
 
486
                                  int32_t                  mask_y,
 
487
                                  int32_t                  dest_x,
 
488
                                  int32_t                  dest_y,
 
489
                                  int32_t                  width,
 
490
                                  int32_t                  height);
 
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" both 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
 
 
565
#define NEED_COMPONENT_ALPHA            (1 << 0)
 
566
#define NEED_PIXBUF                     (1 << 1)
 
567
#define NEED_SOLID_MASK                 (1 << 2)
 
568
 
 
569
typedef struct
 
570
{
 
571
    pixman_op_t             op;
 
572
    pixman_format_code_t    src_format;
 
573
    pixman_format_code_t    mask_format;
 
574
    pixman_format_code_t    dest_format;
 
575
    pixman_composite_func_t func;
 
576
    uint32_t                flags;
 
577
} pixman_fast_path_t;
 
578
 
 
579
/* Memory allocation helpers */
 
580
void *
 
581
pixman_malloc_ab (unsigned int n, unsigned int b);
 
582
 
 
583
void *
 
584
pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);
 
585
 
 
586
pixman_bool_t
 
587
pixman_multiply_overflows_int (unsigned int a, unsigned int b);
 
588
 
 
589
pixman_bool_t
 
590
pixman_addition_overflows_int (unsigned int a, unsigned int b);
 
591
 
 
592
/* Compositing utilities */
 
593
pixman_bool_t
 
594
_pixman_run_fast_path (const pixman_fast_path_t *paths,
 
595
                       pixman_implementation_t * imp,
 
596
                       pixman_op_t               op,
 
597
                       pixman_image_t *          src,
 
598
                       pixman_image_t *          mask,
 
599
                       pixman_image_t *          dest,
 
600
                       int32_t                   src_x,
 
601
                       int32_t                   src_y,
 
602
                       int32_t                   mask_x,
 
603
                       int32_t                   mask_y,
 
604
                       int32_t                   dest_x,
 
605
                       int32_t                   dest_y,
 
606
                       int32_t                   width,
 
607
                       int32_t                   height);
 
608
 
 
609
void
 
610
_pixman_walk_composite_region (pixman_implementation_t *imp,
 
611
                               pixman_op_t              op,
 
612
                               pixman_image_t *         src_image,
 
613
                               pixman_image_t *         mask_image,
 
614
                               pixman_image_t *         dst_image,
 
615
                               int16_t                  src_x,
 
616
                               int16_t                  src_y,
 
617
                               int16_t                  mask_x,
 
618
                               int16_t                  mask_y,
 
619
                               int16_t                  dest_x,
 
620
                               int16_t                  dest_y,
 
621
                               uint16_t                 width,
 
622
                               uint16_t                 height,
 
623
                               pixman_composite_func_t  composite_rect);
 
624
 
 
625
void
 
626
pixman_expand (uint64_t *           dst,
 
627
               const uint32_t *     src,
 
628
               pixman_format_code_t format,
 
629
               int                  width);
 
630
 
 
631
void
 
632
pixman_contract (uint32_t *      dst,
 
633
                 const uint64_t *src,
 
634
                 int             width);
 
635
 
747
636
 
748
637
/* Region Helpers */
749
 
pixman_bool_t pixman_region32_copy_from_region16 (pixman_region32_t *dst,
750
 
                                                  pixman_region16_t *src);
751
 
pixman_bool_t pixman_region16_copy_from_region32 (pixman_region16_t *dst,
752
 
                                                  pixman_region32_t *src);
753
 
void pixman_region_internal_set_static_pointers (pixman_box16_t *empty_box,
754
 
                                                 pixman_region16_data_t *empty_data,
755
 
                                                 pixman_region16_data_t *broken_data);
756
 
 
757
 
#ifdef PIXMAN_TIMING
758
 
 
759
 
/* Timing */
 
638
pixman_bool_t
 
639
pixman_region32_copy_from_region16 (pixman_region32_t *dst,
 
640
                                    pixman_region16_t *src);
 
641
 
 
642
pixman_bool_t
 
643
pixman_region16_copy_from_region32 (pixman_region16_t *dst,
 
644
                                    pixman_region32_t *src);
 
645
 
 
646
 
 
647
/* Misc macros */
 
648
 
 
649
#ifndef FALSE
 
650
#   define FALSE 0
 
651
#endif
 
652
 
 
653
#ifndef TRUE
 
654
#   define TRUE 1
 
655
#endif
 
656
 
 
657
#ifndef MIN
 
658
#  define MIN(a, b) ((a < b) ? a : b)
 
659
#endif
 
660
 
 
661
#ifndef MAX
 
662
#  define MAX(a, b) ((a > b) ? a : b)
 
663
#endif
 
664
 
 
665
/* Integer division that rounds towards -infinity */
 
666
#define DIV(a, b)                                          \
 
667
    ((((a) < 0) == ((b) < 0)) ? (a) / (b) :                \
 
668
     ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
 
669
 
 
670
/* Modulus that produces the remainder wrt. DIV */
 
671
#define MOD(a, b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
 
672
 
 
673
#define CLIP(v, low, high) ((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))
 
674
 
 
675
/* Conversion between 8888 and 0565 */
 
676
 
 
677
#define CONVERT_8888_TO_0565(s)                                         \
 
678
    ((((s) >> 3) & 0x001f) |                                            \
 
679
     (((s) >> 5) & 0x07e0) |                                            \
 
680
     (((s) >> 8) & 0xf800))
 
681
 
 
682
#define CONVERT_0565_TO_0888(s)                                         \
 
683
    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) |                       \
 
684
     ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) |                   \
 
685
     ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
 
686
 
 
687
#define PIXMAN_FORMAT_IS_WIDE(f)                                        \
 
688
    (PIXMAN_FORMAT_A (f) > 8 ||                                         \
 
689
     PIXMAN_FORMAT_R (f) > 8 ||                                         \
 
690
     PIXMAN_FORMAT_G (f) > 8 ||                                         \
 
691
     PIXMAN_FORMAT_B (f) > 8)
 
692
 
 
693
/*
 
694
 * Various debugging code
 
695
 */
 
696
 
 
697
#undef DEBUG
 
698
#define DEBUG 0
 
699
 
 
700
#if DEBUG
 
701
 
 
702
#define return_if_fail(expr)                                            \
 
703
    do                                                                  \
 
704
    {                                                                   \
 
705
        if (!(expr))                                                    \
 
706
        {                                                               \
 
707
            fprintf (stderr, "In %s: %s failed\n", FUNC, # expr);       \
 
708
            return;                                                     \
 
709
        }                                                               \
 
710
    }                                                                   \
 
711
    while (0)
 
712
 
 
713
#define return_val_if_fail(expr, retval)                                \
 
714
    do                                                                  \
 
715
    {                                                                   \
 
716
        if (!(expr))                                                    \
 
717
        {                                                               \
 
718
            fprintf (stderr, "In %s: %s failed\n", FUNC, # expr);       \
 
719
            return (retval);                                            \
 
720
        }                                                               \
 
721
    }                                                                   \
 
722
    while (0)
 
723
 
 
724
#else
 
725
 
 
726
#define return_if_fail(expr)                                            \
 
727
    do                                                                  \
 
728
    {                                                                   \
 
729
        if (!(expr))                                                    \
 
730
            return;                                                     \
 
731
    }                                                                   \
 
732
    while (0)
 
733
 
 
734
#define return_val_if_fail(expr, retval)                                \
 
735
    do                                                                  \
 
736
    {                                                                   \
 
737
        if (!(expr))                                                    \
 
738
            return (retval);                                            \
 
739
    }                                                                   \
 
740
    while (0)
 
741
 
 
742
#endif
 
743
 
 
744
/*
 
745
 * Timers
 
746
 */
 
747
 
 
748
#ifdef PIXMAN_TIMERS
 
749
 
760
750
static inline uint64_t
761
751
oil_profile_stamp_rdtsc (void)
762
752
{
763
753
    uint64_t ts;
764
 
    __asm__ __volatile__("rdtsc\n" : "=A" (ts));
 
754
 
 
755
    __asm__ __volatile__ ("rdtsc\n" : "=A" (ts));
765
756
    return ts;
766
757
}
 
758
 
767
759
#define OIL_STAMP oil_profile_stamp_rdtsc
768
760
 
769
 
typedef struct PixmanTimer PixmanTimer;
 
761
typedef struct pixman_timer_t pixman_timer_t;
770
762
 
771
 
struct PixmanTimer
 
763
struct pixman_timer_t
772
764
{
773
 
    int initialized;
774
 
    const char *name;
775
 
    uint64_t n_times;
776
 
    uint64_t total;
777
 
    PixmanTimer *next;
 
765
    int             initialized;
 
766
    const char *    name;
 
767
    uint64_t        n_times;
 
768
    uint64_t        total;
 
769
    pixman_timer_t *next;
778
770
};
779
771
 
780
772
extern int timer_defined;
781
 
void pixman_timer_register (PixmanTimer *timer);
782
 
 
783
 
#define TIMER_BEGIN(tname)                                              \
784
 
    {                                                                   \
785
 
        static PixmanTimer      timer##tname;                           \
786
 
        uint64_t                begin##tname;                           \
787
 
                                                                        \
788
 
        if (!timer##tname.initialized)                                  \
789
 
        {                                                               \
790
 
            timer##tname.initialized = 1;                               \
791
 
            timer##tname.name = #tname;                                 \
792
 
            pixman_timer_register (&timer##tname);                      \
793
 
        }                                                               \
794
 
                                                                        \
795
 
        timer##tname.n_times++;                                         \
796
 
        begin##tname = OIL_STAMP();
797
 
 
798
 
#define TIMER_END(tname)                                                \
799
 
        timer##tname.total += OIL_STAMP() - begin##tname;               \
 
773
 
 
774
void pixman_timer_register (pixman_timer_t *timer);
 
775
 
 
776
#define TIMER_BEGIN(tname)                                              \
 
777
    {                                                                   \
 
778
        static pixman_timer_t timer ## tname;                           \
 
779
        uint64_t              begin ## tname;                           \
 
780
                                                                        \
 
781
        if (!timer ## tname.initialized)                                \
 
782
        {                                                               \
 
783
            timer ## tname.initialized = 1;                             \
 
784
            timer ## tname.name = # tname;                              \
 
785
            pixman_timer_register (&timer ## tname);                    \
 
786
        }                                                               \
 
787
                                                                        \
 
788
        timer ## tname.n_times++;                                       \
 
789
        begin ## tname = OIL_STAMP ();
 
790
 
 
791
#define TIMER_END(tname)                                                \
 
792
    timer ## tname.total += OIL_STAMP () - begin ## tname;              \
800
793
    }
801
794
 
802
 
#endif /* PIXMAN_TIMING */
 
795
#endif /* PIXMAN_TIMERS */
803
796
 
804
797
#endif /* PIXMAN_PRIVATE_H */