← Back to branch summary

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

« back to all changes in this revision

Viewing changes to pixman/pixman-combine.h.template

  • 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-combine.h.template
 
1
 
 
2
#define COMPONENT_SIZE
 
3
#define MASK
 
4
#define ONE_HALF
 
5
 
 
6
#define A_SHIFT
 
7
#define R_SHIFT
 
8
#define G_SHIFT
 
9
#define A_MASK
 
10
#define R_MASK
 
11
#define G_MASK
 
12
 
 
13
#define RB_MASK
 
14
#define AG_MASK
 
15
#define RB_ONE_HALF
 
16
#define RB_MASK_PLUS_ONE
 
17
 
 
18
#define ALPHA_c(x) ((x) >> A_SHIFT)
 
19
#define RED_c(x) (((x) >> R_SHIFT) & MASK)
 
20
#define GREEN_c(x) (((x) >> G_SHIFT) & MASK)
 
21
#define BLUE_c(x) ((x) & MASK)
 
22
 
 
23
/*
 
24
 * Helper macros.
 
25
 */
 
26
 
 
27
#define MUL_UNc(a, b, t)                                                \
 
28
    ((t) = (a) * (b) + ONE_HALF, ((((t) >> G_SHIFT ) + (t) ) >> G_SHIFT ))
 
29
 
 
30
#define DIV_UNc(a, b)                                                   \
 
31
    (((comp2_t) (a) * MASK) / (b))
 
32
 
 
33
#define ADD_UNc(x, y, t)                                     \
 
34
    ((t) = x + y,                                            \
 
35
     (comp4_t) (comp1_t) ((t) | (0 - ((t) >> G_SHIFT))))
 
36
 
 
37
#define DIV_ONE_UNc(x)                                                  \
 
38
    (((x) + ONE_HALF + (((x) + ONE_HALF) >> G_SHIFT)) >> G_SHIFT)
 
39
 
 
40
/*
 
41
 * The methods below use some tricks to be able to do two color
 
42
 * components at the same time.
 
43
 */
 
44
 
 
45
/*
 
46
 * x_rb = (x_rb * a) / 255
 
47
 */
 
48
#define UNc_rb_MUL_UNc(x, a, t)                                         \
 
49
    do                                                                  \
 
50
    {                                                                   \
 
51
        t  = ((x) & RB_MASK) * (a);                                     \
 
52
        t += RB_ONE_HALF;                                               \
 
53
        x = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
 
54
        x &= RB_MASK;                                                   \
 
55
    } while (0)
 
56
 
 
57
/*
 
58
 * x_rb = min (x_rb + y_rb, 255)
 
59
 */
 
60
#define UNc_rb_ADD_UNc_rb(x, y, t)                                      \
 
61
    do                                                                  \
 
62
    {                                                                   \
 
63
        t = ((x) + (y));                                                \
 
64
        t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
 
65
        x = (t & RB_MASK);                                              \
 
66
    } while (0)
 
67
 
 
68
/*
 
69
 * x_rb = (x_rb * a_rb) / 255
 
70
 */
 
71
#define UNc_rb_MUL_UNc_rb(x, a, t)                                      \
 
72
    do                                                                  \
 
73
    {                                                                   \
 
74
        t  = (x & MASK) * (a & MASK);                                   \
 
75
        t |= (x & R_MASK) * ((a >> R_SHIFT) & MASK);                    \
 
76
        t += RB_ONE_HALF;                                               \
 
77
        t = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
 
78
        x = t & RB_MASK;                                                \
 
79
    } while (0)
 
80
 
 
81
/*
 
82
 * x_c = (x_c * a) / 255
 
83
 */
 
84
#define UNcx4_MUL_UNc(x, a)                                             \
 
85
    do                                                                  \
 
86
    {                                                                   \
 
87
        comp4_t r1, r2, t;                                              \
 
88
                                                                        \
 
89
        r1 = (x);                                                       \
 
90
        UNc_rb_MUL_UNc (r1, a, t);                                      \
 
91
                                                                        \
 
92
        r2 = (x) >> G_SHIFT;                                            \
 
93
        UNc_rb_MUL_UNc (r2, a, t);                                      \
 
94
                                                                        \
 
95
        x = r1 | (r2 << G_SHIFT);                                       \
 
96
    } while (0)
 
97
 
 
98
/*
 
99
 * x_c = (x_c * a) / 255 + y_c
 
100
 */
 
101
#define UNcx4_MUL_UNc_ADD_UNcx4(x, a, y)                                \
 
102
    do                                                                  \
 
103
    {                                                                   \
 
104
        comp4_t r1, r2, r3, t;                                          \
 
105
                                                                        \
 
106
        r1 = (x);                                                       \
 
107
        r2 = (y) & RB_MASK;                                             \
 
108
        UNc_rb_MUL_UNc (r1, a, t);                                      \
 
109
        UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 
110
                                                                        \
 
111
        r2 = (x) >> G_SHIFT;                                            \
 
112
        r3 = ((y) >> G_SHIFT) & RB_MASK;                                \
 
113
        UNc_rb_MUL_UNc (r2, a, t);                                      \
 
114
        UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 
115
                                                                        \
 
116
        x = r1 | (r2 << G_SHIFT);                                       \
 
117
    } while (0)
 
118
 
 
119
/*
 
120
 * x_c = (x_c * a + y_c * b) / 255
 
121
 */
 
122
#define UNcx4_MUL_UNc_ADD_UNcx4_MUL_UNc(x, a, y, b)                     \
 
123
    do                                                                  \
 
124
    {                                                                   \
 
125
        comp4_t r1, r2, r3, t;                                          \
 
126
                                                                        \
 
127
        r1 = x;                                                         \
 
128
        r2 = y;                                                         \
 
129
        UNc_rb_MUL_UNc (r1, a, t);                                      \
 
130
        UNc_rb_MUL_UNc (r2, b, t);                                      \
 
131
        UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 
132
                                                                        \
 
133
        r2 = (x >> G_SHIFT);                                            \
 
134
        r3 = (y >> G_SHIFT);                                            \
 
135
        UNc_rb_MUL_UNc (r2, a, t);                                      \
 
136
        UNc_rb_MUL_UNc (r3, b, t);                                      \
 
137
        UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 
138
                                                                        \
 
139
        x = r1 | (r2 << G_SHIFT);                                       \
 
140
    } while (0)
 
141
 
 
142
/*
 
143
 * x_c = (x_c * a_c) / 255
 
144
 */
 
145
#define UNcx4_MUL_UNcx4(x, a)                                           \
 
146
    do                                                                  \
 
147
    {                                                                   \
 
148
        comp4_t r1, r2, r3, t;                                          \
 
149
                                                                        \
 
150
        r1 = x;                                                         \
 
151
        r2 = a;                                                         \
 
152
        UNc_rb_MUL_UNc_rb (r1, r2, t);                                  \
 
153
                                                                        \
 
154
        r2 = x >> G_SHIFT;                                              \
 
155
        r3 = a >> G_SHIFT;                                              \
 
156
        UNc_rb_MUL_UNc_rb (r2, r3, t);                                  \
 
157
                                                                        \
 
158
        x = r1 | (r2 << G_SHIFT);                                       \
 
159
    } while (0)
 
160
 
 
161
/*
 
162
 * x_c = (x_c * a_c) / 255 + y_c
 
163
 */
 
164
#define UNcx4_MUL_UNcx4_ADD_UNcx4(x, a, y)                              \
 
165
    do                                                                  \
 
166
    {                                                                   \
 
167
        comp4_t r1, r2, r3, t;                                          \
 
168
                                                                        \
 
169
        r1 = x;                                                         \
 
170
        r2 = a;                                                         \
 
171
        UNc_rb_MUL_UNc_rb (r1, r2, t);                                  \
 
172
        r2 = y & RB_MASK;                                               \
 
173
        UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 
174
                                                                        \
 
175
        r2 = (x >> G_SHIFT);                                            \
 
176
        r3 = (a >> G_SHIFT);                                            \
 
177
        UNc_rb_MUL_UNc_rb (r2, r3, t);                                  \
 
178
        r3 = (y >> G_SHIFT) & RB_MASK;                                  \
 
179
        UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 
180
                                                                        \
 
181
        x = r1 | (r2 << G_SHIFT);                                       \
 
182
    } while (0)
 
183
 
 
184
/*
 
185
 * x_c = (x_c * a_c + y_c * b) / 255
 
186
 */
 
187
#define UNcx4_MUL_UNcx4_ADD_UNcx4_MUL_UNc(x, a, y, b)                   \
 
188
    do                                                                  \
 
189
    {                                                                   \
 
190
        comp4_t r1, r2, r3, t;                                          \
 
191
                                                                        \
 
192
        r1 = x;                                                         \
 
193
        r2 = a;                                                         \
 
194
        UNc_rb_MUL_UNc_rb (r1, r2, t);                                  \
 
195
        r2 = y;                                                         \
 
196
        UNc_rb_MUL_UNc (r2, b, t);                                      \
 
197
        UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 
198
                                                                        \
 
199
        r2 = x >> G_SHIFT;                                              \
 
200
        r3 = a >> G_SHIFT;                                              \
 
201
        UNc_rb_MUL_UNc_rb (r2, r3, t);                                  \
 
202
        r3 = y >> G_SHIFT;                                              \
 
203
        UNc_rb_MUL_UNc (r3, b, t);                                      \
 
204
        UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 
205
                                                                        \
 
206
        x = r1 | (r2 << G_SHIFT);                                       \
 
207
    } while (0)
 
208
 
 
209
/*
 
210
   x_c = min(x_c + y_c, 255)
 
211
 */
 
212
#define UNcx4_ADD_UNcx4(x, y)                                           \
 
213
    do                                                                  \
 
214
    {                                                                   \
 
215
        comp4_t r1, r2, r3, t;                                          \
 
216
                                                                        \
 
217
        r1 = x & RB_MASK;                                               \
 
218
        r2 = y & RB_MASK;                                               \
 
219
        UNc_rb_ADD_UNc_rb (r1, r2, t);                                  \
 
220
                                                                        \
 
221
        r2 = (x >> G_SHIFT) & RB_MASK;                                  \
 
222
        r3 = (y >> G_SHIFT) & RB_MASK;                                  \
 
223
        UNc_rb_ADD_UNc_rb (r2, r3, t);                                  \
 
224
                                                                        \
 
225
        x = r1 | (r2 << G_SHIFT);                                       \
 
226
    } while (0)