← Back to branch summary

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

« back to all changes in this revision

Viewing changes to pixman/combine.h.inc

  • 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/combine.h.inc
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(x) ((x) >> A_SHIFT)
19
 
 
20
 
/*
21
 
 * Helper macros.
22
 
 */
23
 
 
24
 
#define IntMult(a,b,t) ( (t) = (a) * (b) + ONE_HALF, ( ( ( (t)>>G_SHIFT ) + (t) )>>G_SHIFT ) )
25
 
#define IntDiv(a,b)    (((comp2_t) (a) * MASK) / (b))
26
 
 
27
 
#define GetComp(v,i)   ((comp2_t) (comp1_t) ((v) >> i))
28
 
 
29
 
#define Add(x,y,i,t)   ((t) = GetComp(x,i) + GetComp(y,i),              \
30
 
                        (comp4_t) ((comp1_t) ((t) | (0 - ((t) >> G_SHIFT)))) << (i))
31
 
 
32
 
#define FbGen(x,y,i,ax,ay,t,u,v) ((t) = (IntMult(GetComp(y,i),ay,(u)) + \
33
 
                                         IntMult(GetComp(x,i),ax,(v))), \
34
 
                                  (comp4_t) ((comp1_t) ((t) |           \
35
 
                                                         (0 - ((t) >> G_SHIFT)))) << (i))
36
 
 
37
 
/*
38
 
  The methods below use some tricks to be able to do two color
39
 
  components at the same time.
40
 
*/
41
 
 
42
 
/*
43
 
  x_c = (x_c * a) / 255
44
 
*/
45
 
#define FbByteMul(x, a) do {                                            \
46
 
        comp4_t t = ((x & RB_MASK) * a) + RB_ONE_HALF;                  \
47
 
        t = (t + ((t >> COMPONENT_SIZE) & RB_MASK)) >> COMPONENT_SIZE;  \
48
 
        t &= RB_MASK;                                                   \
49
 
                                                                        \
50
 
        x = (((x >> COMPONENT_SIZE) & RB_MASK) * a) + RB_ONE_HALF;      \
51
 
        x = (x + ((x >> COMPONENT_SIZE) & RB_MASK));                    \
52
 
        x &= RB_MASK << COMPONENT_SIZE;                                 \
53
 
        x += t;                                                         \
54
 
    } while (0)
55
 
 
56
 
/*
57
 
  x_c = (x_c * a) / 255 + y
58
 
*/
59
 
#define FbByteMulAdd(x, a, y) do {                                      \
60
 
        /* multiply and divide: trunc((i + 128)*257/65536) */           \
61
 
        comp4_t t = ((x & RB_MASK) * a) + RB_ONE_HALF;                  \
62
 
        t = (t + ((t >> COMPONENT_SIZE) & RB_MASK)) >> COMPONENT_SIZE;  \
63
 
        t &= RB_MASK;                                                   \
64
 
                                                                        \
65
 
        /* add */                                                       \
66
 
        t += y & RB_MASK;                                               \
67
 
                                                                        \
68
 
        /* saturate */                                                  \
69
 
        t |= RB_MASK_PLUS_ONE - ((t >> COMPONENT_SIZE) & RB_MASK);      \
70
 
        t &= RB_MASK;                                                   \
71
 
                                                                        \
72
 
        /* multiply and divide */                                       \
73
 
        x = (((x >> COMPONENT_SIZE) & RB_MASK) * a) + RB_ONE_HALF;      \
74
 
        x = (x + ((x >> COMPONENT_SIZE) & RB_MASK)) >> COMPONENT_SIZE;  \
75
 
        x &= RB_MASK;                                                   \
76
 
                                                                        \
77
 
        /* add */                                                       \
78
 
        x += (y >> COMPONENT_SIZE) & RB_MASK;                           \
79
 
                                                                        \
80
 
        /* saturate */                                                  \
81
 
        x |= RB_MASK_PLUS_ONE - ((x >> COMPONENT_SIZE) & RB_MASK);      \
82
 
        x &= RB_MASK;                                                   \
83
 
                                                                        \
84
 
        /* recombine */                                                 \
85
 
        x <<= COMPONENT_SIZE;                                           \
86
 
        x += t;                                                         \
87
 
    } while (0)
88
 
 
89
 
/*
90
 
  x_c = (x_c * a + y_c * b) / 255
91
 
*/
92
 
#define FbByteAddMul(x, a, y, b) do {                                   \
93
 
        comp4_t t;                                                      \
94
 
        comp4_t r = (x >> A_SHIFT) * a + (y >> A_SHIFT) * b + ONE_HALF; \
95
 
        r += (r >> G_SHIFT);                                            \
96
 
        r >>= G_SHIFT;                                                  \
97
 
                                                                        \
98
 
        t = (x & G_MASK) * a + (y & G_MASK) * b;                        \
99
 
        t += (t >> G_SHIFT) + (ONE_HALF << G_SHIFT);                    \
100
 
        t >>= R_SHIFT;                                                  \
101
 
                                                                        \
102
 
        t |= r << R_SHIFT;                                              \
103
 
        t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
104
 
        t &= RB_MASK;                                                   \
105
 
        t <<= G_SHIFT;                                                  \
106
 
                                                                        \
107
 
        r = ((x >> R_SHIFT) & MASK) * a +                               \
108
 
            ((y >> R_SHIFT) & MASK) * b + ONE_HALF;                     \
109
 
        r += (r >> G_SHIFT);                                            \
110
 
        r >>= G_SHIFT;                                                  \
111
 
                                                                        \
112
 
        x = (x & MASK) * a + (y & MASK) * b + ONE_HALF;                 \
113
 
        x += (x >> G_SHIFT);                                            \
114
 
        x >>= G_SHIFT;                                                  \
115
 
        x |= r << R_SHIFT;                                              \
116
 
        x |= RB_MASK_PLUS_ONE - ((x >> G_SHIFT) & RB_MASK);             \
117
 
        x &= RB_MASK;                                                   \
118
 
        x |= t;                                                         \
119
 
    } while (0)
120
 
 
121
 
/*
122
 
  x_c = (x_c * a_c) / 255
123
 
*/
124
 
#define FbByteMulC(x, a) do {                                           \
125
 
        comp4_t t;                                                      \
126
 
        comp4_t r = (x & MASK) * (a & MASK);                            \
127
 
        r |= (x & R_MASK) * ((a >> R_SHIFT) & MASK);                    \
128
 
        r += RB_ONE_HALF;                                               \
129
 
        r = (r + ((r >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
130
 
        r &= RB_MASK;                                                   \
131
 
                                                                        \
132
 
        x >>= G_SHIFT;                                                  \
133
 
        t = (x & MASK) * ((a >> G_SHIFT) & MASK);                       \
134
 
        t |= (x & R_MASK) * (a >> A_SHIFT);                             \
135
 
        t += RB_ONE_HALF;                                               \
136
 
        t = t + ((t >> G_SHIFT) & RB_MASK);                             \
137
 
        x = r | (t & AG_MASK);                                          \
138
 
    } while (0)
139
 
 
140
 
/*
141
 
  x_c = (x_c * a) / 255 + y
142
 
*/
143
 
#define FbByteMulAddC(x, a, y) do {                                     \
144
 
        comp4_t t;                                                      \
145
 
        comp4_t r = (x & MASK) * (a & MASK);                            \
146
 
        r |= (x & R_MASK) * ((a >> R_SHIFT) & MASK);                    \
147
 
        r += RB_ONE_HALF;                                               \
148
 
        r = (r + ((r >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
149
 
        r &= RB_MASK;                                                   \
150
 
        r += y & RB_MASK;                                               \
151
 
        r |= RB_MASK_PLUS_ONE - ((r >> G_SHIFT) & RB_MASK);             \
152
 
        r &= RB_MASK;                                                   \
153
 
                                                                        \
154
 
        x >>= G_SHIFT;                                                  \
155
 
        t = (x & MASK) * ((a >> G_SHIFT) & MASK);                       \
156
 
        t |= (x & R_MASK) * (a >> A_SHIFT);                             \
157
 
        t += RB_ONE_HALF;                                               \
158
 
        t = (t + ((t >> G_SHIFT) & RB_MASK)) >> G_SHIFT;                \
159
 
        t &= RB_MASK;                                                   \
160
 
        t += (y >> G_SHIFT) & RB_MASK;                                  \
161
 
        t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
162
 
        t &= RB_MASK;                                                   \
163
 
        x = r | (t << G_SHIFT);                                         \
164
 
    } while (0)
165
 
 
166
 
/*
167
 
  x_c = (x_c * a_c + y_c * b) / 255
168
 
*/
169
 
#define FbByteAddMulC(x, a, y, b) do {                                  \
170
 
        comp4_t t;                                                      \
171
 
        comp4_t r = (x >> A_SHIFT) * (a >> A_SHIFT) +                   \
172
 
                     (y >> A_SHIFT) * b;                                \
173
 
        r += (r >> G_SHIFT) + ONE_HALF;                                 \
174
 
        r >>= G_SHIFT;                                                  \
175
 
                                                                        \
176
 
        t = (x & G_MASK) * ((a >> G_SHIFT) & MASK) + (y & G_MASK) * b;  \
177
 
        t += (t >> G_SHIFT) + (ONE_HALF << G_SHIFT);                    \
178
 
        t >>= R_SHIFT;                                                  \
179
 
                                                                        \
180
 
        t |= r << R_SHIFT;                                              \
181
 
        t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
182
 
        t &= RB_MASK;                                                   \
183
 
        t <<= G_SHIFT;                                                  \
184
 
                                                                        \
185
 
        r = ((x >> R_SHIFT) & MASK) * ((a >> R_SHIFT) & MASK) +         \
186
 
            ((y >> R_SHIFT) & MASK) * b + ONE_HALF;                     \
187
 
        r += (r >> G_SHIFT);                                            \
188
 
        r >>= G_SHIFT;                                                  \
189
 
                                                                        \
190
 
        x = (x & MASK) * (a & MASK) + (y & MASK) * b + ONE_HALF;        \
191
 
        x += (x >> G_SHIFT);                                            \
192
 
        x >>= G_SHIFT;                                                  \
193
 
        x |= r << R_SHIFT;                                              \
194
 
        x |= RB_MASK_PLUS_ONE - ((x >> G_SHIFT) & RB_MASK);             \
195
 
        x &= RB_MASK;                                                   \
196
 
        x |= t;                                                         \
197
 
    } while (0)
198
 
 
199
 
/*
200
 
  x_c = min(x_c + y_c, 255)
201
 
*/
202
 
#define FbByteAdd(x, y) do {                                            \
203
 
        comp4_t t;                                                      \
204
 
        comp4_t r = (x & RB_MASK) + (y & RB_MASK);                      \
205
 
        r |= RB_MASK_PLUS_ONE - ((r >> G_SHIFT) & RB_MASK);             \
206
 
        r &= RB_MASK;                                                   \
207
 
                                                                        \
208
 
        t = ((x >> G_SHIFT) & RB_MASK) + ((y >> G_SHIFT) & RB_MASK);    \
209
 
        t |= RB_MASK_PLUS_ONE - ((t >> G_SHIFT) & RB_MASK);             \
210
 
        r |= (t & RB_MASK) << G_SHIFT;                                  \
211
 
        x = r;                                                          \
212
 
    } while (0)
213