1 /*
2 * Copyright (c) 2000, 2005, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #ifndef AlphaMath_h_Included
27 #define AlphaMath_h_Included
28
29 extern unsigned char mul8table[256][256];
30 extern unsigned char div8table[256][256];
31 extern void initAlphaTables();
32
33
34 /*
35 * Multiply and Divide macros for single byte (8-bit) quantities representing
36 * the values 0.0 to 1.0 as 0x00 to 0xff.
37 * MUL8 multiplies its operands together
38 * DIV8 divides the first operand by the second, clipping to 0xff
39 * (Note that since the divisor for DIV8 is likely to be
40 * the alpha quantity which is likely to be the same for
41 * multiple adjacent invocations, the table is designed
42 * with the first index being the divisor to hopefully
43 * improve memory cache hits...)
44 */
45 #define MUL8(a,b) mul8table[a][b]
46 #define DIV8(a,b) div8table[b][a]
47
48 /*
49 * Multiply and Divide macros for operations involving a single short (16-bit)
50 * quantity and a single byte (8-bit) quantity. Typically, promoting the
51 * 8-bit value to 16 bits would lead to overflow when the operation occurs.
52 * These macros have been modified somewhat so that overflow will not occur.
53 * MUL8_16 multiplies an 8-bit value by a 16-bit value (the order of operands
54 * is unimportant since multiplication is a commutative operation)
55 * DIV16_8 divides the first (16-bit) operand by the second (8-bit) value
56 */
57
58 #define MUL8_16(a,b) (((a) * (b)) / 255)
59 #define DIV16_8(a,b) (((a) * 255) / (b))
60
61 /*
62 * Multiply and Divide macros for single short (16-bit) quantities
63 * representing the values 0.0 to 1.0 as 0x0000 to 0xffff.
64 * MUL16 multiplies its operands using the standard multiplication operator
65 * and normalizes the result to the appropriate range
66 * DIV16 divides the first operand by the second and normalizes the result
67 * to a 16-bit value
68 */
69 #define MUL16(a,b) (((a) * (b)) / 65535)
70 #define DIV16(a,b) (((a) * 65535) / (b))
71
72 /*
73 * Macro for the sum of two normalized (16-bit) products. Refer to the
74 * following equation and note that the right side reduces the number of
75 * divide operations in the left side and increases the precision of the
76 * result:
77 * a*f1 + b*f2 a*f1 + b*f2
78 * ---- ---- = ----------- (where n in this case will be 65535)
79 * n n n
80 */
81 #define AddNormalizedProducts16(a, f1, b, f2) \
82 ((((a) * (f1)) + ((b) * (f2))) / 65535)
83
84
85 /*
86 * The following macros help to generalize the MaskBlit and MaskFill loops
87 * found in AlphaMacros.h. The appropriate macros will be used based on the
88 * strategy of the given loop. The strategy types take the form:
89 * <number of components per pixel><component data type><colorspace>
90 * For example, these are the current strategy types:
91 * 3ByteRgb (currently only used as a glyph list blending strategy where
92 * the alpha value itself is neither blended nor stored)
93 * 4ByteArgb (eg. IntArgb, ThreeByteBgr, Ushort555Rgb, ByteIndexed, etc.)
94 * 4ShortArgb (not used currently; could be used when surface types using
95 * 16 bits per component are implemented)
96 * 1ByteGray (eg. ByteGray)
97 * 1ShortGray (eg. UshortGray)
98 * Note that the macros which operate on alpha values have the word "Alpha"
99 * somewhere in their name. Those macros that only operate on the color/gray
100 * components of a given strategy will have the word "Components" or "Comps"
101 * in their name.
102 */
103
104
105 /*
106 * MaxValFor ## STRATEGY
107 */
108 #define MaxValFor4ByteArgb 0xff
109 #define MaxValFor1ByteGray 0xff
110 #define MaxValFor1ShortGray 0xffff
111
112
113 /*
114 * AlphaType ## STRATEGY
115 */
116 #define AlphaType3ByteRgb jint
117 #define AlphaType4ByteArgb jint
118 #define AlphaType1ByteGray jint
119 #define AlphaType1ShortGray juint
120
121
122 /*
123 * ComponentType ## STRATEGY
124 */
125 #define ComponentType3ByteRgb jint
126 #define ComponentType4ByteArgb jint
127 #define ComponentType1ByteGray jint
128 #define ComponentType1ShortGray juint
129
130
131 /*
132 * DeclareAlphaVarFor ## STRATEGY(VAR)
133 *
134 * jint a;
135 */
136 #define DeclareAlphaVarFor3ByteRgb(VAR) \
137 AlphaType3ByteRgb VAR;
138
139 #define DeclareAlphaVarFor4ByteArgb(VAR) \
140 AlphaType4ByteArgb VAR;
141
142 #define DeclareAlphaVarFor1ByteGray(VAR) \
143 AlphaType1ByteGray VAR;
144
145 #define DeclareAlphaVarFor1ShortGray(VAR) \
146 AlphaType1ShortGray VAR;
147
148
149 /*
150 * DeclareAndInitAlphaVarFor ## STRATEGY(VAR, initval)
151 *
152 * jint a = initval;
153 */
154 #define DeclareAndInitAlphaVarFor4ByteArgb(VAR, initval) \
155 AlphaType4ByteArgb VAR = initval;
156
157 #define DeclareAndInitAlphaVarFor1ByteGray(VAR, initval) \
158 AlphaType1ByteGray VAR = initval;
159
160 #define DeclareAndInitAlphaVarFor1ShortGray(VAR, initval) \
161 AlphaType1ShortGray VAR = initval;
162
163
164 /*
165 * DeclareAndClearAlphaVarFor ## STRATEGY(VAR)
166 *
167 * jint a = 0;
168 */
169 #define DeclareAndClearAlphaVarFor4ByteArgb(VAR) \
170 DeclareAndInitAlphaVarFor4ByteArgb(VAR, 0)
171
172 #define DeclareAndClearAlphaVarFor1ByteGray(VAR) \
173 DeclareAndInitAlphaVarFor1ByteGray(VAR, 0)
174
175 #define DeclareAndClearAlphaVarFor1ShortGray(VAR) \
176 DeclareAndInitAlphaVarFor1ShortGray(VAR, 0)
177
178
179 /*
180 * DeclareAndSetOpaqueAlphaVarFor ## STRATEGY(VAR)
181 *
182 * jint a = 0xff;
183 */
184 #define DeclareAndSetOpaqueAlphaVarFor4ByteArgb(VAR) \
185 DeclareAndInitAlphaVarFor4ByteArgb(VAR, MaxValFor4ByteArgb)
186
187 #define DeclareAndSetOpaqueAlphaVarFor1ByteGray(VAR) \
188 DeclareAndInitAlphaVarFor1ByteGray(VAR, MaxValFor1ByteGray)
189
190 #define DeclareAndSetOpaqueAlphaVarFor1ShortGray(VAR) \
191 DeclareAndInitAlphaVarFor1ShortGray(VAR, MaxValFor1ShortGray)
192
193
194 /*
195 * DeclareAndInvertAlphaVarFor ## STRATEGY(VAR, invalpha)
196 *
197 * jint a = 0xff - resA;
198 */
199 #define DeclareAndInvertAlphaVarFor4ByteArgb(VAR, invalpha) \
200 DeclareAndInitAlphaVarFor4ByteArgb(VAR, MaxValFor4ByteArgb - invalpha)
201
202 #define DeclareAndInvertAlphaVarFor1ByteGray(VAR, invalpha) \
203 DeclareAndInitAlphaVarFor1ByteGray(VAR, MaxValFor1ByteGray - invalpha)
204
205 #define DeclareAndInvertAlphaVarFor1ShortGray(VAR, invalpha) \
206 DeclareAndInitAlphaVarFor1ShortGray(VAR, MaxValFor1ShortGray - invalpha)
207
208
209 /*
210 * DeclareCompVarsFor ## STRATEGY(PREFIX)
211 *
212 * jint c;
213 */
214 #define DeclareCompVarsFor3ByteRgb(PREFIX) \
215 ComponentType3ByteRgb PREFIX ## R, PREFIX ## G, PREFIX ## B;
216
217 #define DeclareCompVarsFor4ByteArgb(PREFIX) \
218 ComponentType4ByteArgb PREFIX ## R, PREFIX ## G, PREFIX ## B;
219
220 #define DeclareCompVarsFor1ByteGray(PREFIX) \
221 ComponentType1ByteGray PREFIX ## G;
222
223 #define DeclareCompVarsFor1ShortGray(PREFIX) \
224 ComponentType1ShortGray PREFIX ## G;
225
226
227 /*
228 * DeclareAndInitExtraAlphaFor ## STRATEGY(VAR)
229 *
230 * jint extraA = (int)(pCompInfo->details.extraAlpha * 255.0 + 0.5);
231 */
232 #define DeclareAndInitExtraAlphaFor4ByteArgb(VAR) \
233 AlphaType4ByteArgb VAR = \
234 (AlphaType4ByteArgb)(pCompInfo->details.extraAlpha * 255.0 + 0.5);
235
236 #define DeclareAndInitExtraAlphaFor1ByteGray(VAR) \
237 AlphaType1ByteGray VAR = \
238 (AlphaType1ByteGray)(pCompInfo->details.extraAlpha * 255.0 + 0.5);
239
240 #define DeclareAndInitExtraAlphaFor1ShortGray(VAR) \
241 AlphaType1ShortGray VAR = \
242 (AlphaType1ShortGray)(pCompInfo->details.extraAlpha * 65535.0 + 0.5);
243
244
245 /*
246 * PromoteByteAlphaFor ## STRATEGY(a)
247 */
248 #define PromoteByteAlphaFor4ByteArgb(a)
249 #define PromoteByteAlphaFor1ByteGray(a)
250 #define PromoteByteAlphaFor1ShortGray(a) \
251 (a) = (((a) << 8) + (a))
252
253
254 /*
255 * DeclareAndInitPathAlphaFor ## STRATEGY(VAR)
256 *
257 * jint pathA = *pMask++;
258 */
259 #define DeclareAndInitPathAlphaFor4ByteArgb(VAR) \
260 AlphaType4ByteArgb VAR = *pMask++;
261
262 #define DeclareAndInitPathAlphaFor1ByteGray(VAR) \
263 AlphaType1ByteGray VAR = *pMask++;
264
265 #define DeclareAndInitPathAlphaFor1ShortGray(VAR) \
266 AlphaType1ShortGray VAR = *pMask++;
267
268
269 /*
270 * MultiplyAlphaFor ## STRATEGY(a, b)
271 *
272 * a * b
273 */
274 #define MultiplyAlphaFor4ByteArgb(a, b) \
275 MUL8(a, b)
276
277 #define MultiplyAlphaFor1ByteGray(a, b) \
278 MUL8(a, b)
279
280 #define MultiplyAlphaFor1ShortGray(a, b) \
281 MUL16(a, b)
282
283
284 /*
285 * MultiplyAndStore ## STRATEGY ## Comps(PROD_PREFIX, M1, M2_PREFIX)
286 *
287 * c = m1 * m2;
288 */
289 #define MultiplyAndStore3Components(PROD_PREFIX, M1, M2_PREFIX, PRECISION) \
290 do { \
291 PROD_PREFIX ## R = MUL ## PRECISION(M1, M2_PREFIX ## R); \
292 PROD_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G); \
293 PROD_PREFIX ## B = MUL ## PRECISION(M1, M2_PREFIX ## B); \
294 } while (0)
295
296 #define MultiplyAndStore1Component(PROD_PREFIX, M1, M2_PREFIX, PRECISION) \
297 PROD_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G)
298
299 #define MultiplyAndStore4ByteArgbComps(PROD_PREFIX, M1, M2_PREFIX) \
300 MultiplyAndStore3Components(PROD_PREFIX, M1, M2_PREFIX, 8)
301
302 #define MultiplyAndStore1ByteGrayComps(PROD_PREFIX, M1, M2_PREFIX) \
303 MultiplyAndStore1Component(PROD_PREFIX, M1, M2_PREFIX, 8)
304
305 #define MultiplyAndStore1ShortGrayComps(PROD_PREFIX, M1, M2_PREFIX) \
306 MultiplyAndStore1Component(PROD_PREFIX, M1, M2_PREFIX, 16)
307
308
309 /*
310 * DivideAndStore ## STRATEGY ## Comps(QUOT_PREFIX, D1_PREFIX, D2)
311 *
312 * c = d1 / d2;
313 */
314 #define DivideAndStore3Components(QUOT_PREFIX, D1_PREFIX, D2, PRECISION) \
315 do { \
316 QUOT_PREFIX ## R = DIV ## PRECISION(D1_PREFIX ## R, D2); \
317 QUOT_PREFIX ## G = DIV ## PRECISION(D1_PREFIX ## G, D2); \
318 QUOT_PREFIX ## B = DIV ## PRECISION(D1_PREFIX ## B, D2); \
319 } while (0)
320
321 #define DivideAndStore1Component(QUOT_PREFIX, D1_PREFIX, D2, PRECISION) \
322 QUOT_PREFIX ## G = DIV ## PRECISION(D1_PREFIX ## G, D2)
323
324 #define DivideAndStore4ByteArgbComps(QUOT_PREFIX, D1_PREFIX, D2) \
325 DivideAndStore3Components(QUOT_PREFIX, D1_PREFIX, D2, 8)
326
327 #define DivideAndStore1ByteGrayComps(QUOT_PREFIX, D1_PREFIX, D2) \
328 DivideAndStore1Component(QUOT_PREFIX, D1_PREFIX, D2, 8)
329
330 #define DivideAndStore1ShortGrayComps(QUOT_PREFIX, D1_PREFIX, D2) \
331 DivideAndStore1Component(QUOT_PREFIX, D1_PREFIX, D2, 16)
332
333
334 /*
335 * MultiplyAddAndStore ## STRATEGY ## Comps(RES_PREFIX, M1, \
336 * M2_PREFIX, A_PREFIX)
337 *
338 * c = (m1 * m2) + a;
339 */
340 #define MultiplyAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, \
341 PRECISION) \
342 do { \
343 RES_PREFIX ## R = MUL ## PRECISION(M1, M2_PREFIX ## R) + \
344 A_PREFIX ## R; \
345 RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + \
346 A_PREFIX ## G; \
347 RES_PREFIX ## B = MUL ## PRECISION(M1, M2_PREFIX ## B) + \
348 A_PREFIX ## B; \
349 } while (0)
350
351 #define MultiplyAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, \
352 PRECISION) \
353 RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + A_PREFIX ## G
354
355 #define MultiplyAddAndStore4ByteArgbComps(RES_PREFIX, M1, M2_PREFIX, \
356 A_PREFIX) \
357 MultiplyAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, 8)
358
359 #define MultiplyAddAndStore1ByteGrayComps(RES_PREFIX, M1, M2_PREFIX, \
360 A_PREFIX) \
361 MultiplyAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, 8)
362
363 #define MultiplyAddAndStore1ShortGrayComps(RES_PREFIX, M1, M2_PREFIX, \
364 A_PREFIX) \
365 MultiplyAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, 16)
366
367
368 /*
369 * MultMultAddAndStore ## STRATEGY ## Comps(RES_PREFIX, M1, M2_PREFIX, \
370 * M3, M4_PREFIX)
371 *
372 * c = (m1 * m2) + (m3 * m4);
373 */
374 #define MultMultAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, \
375 M3, M4_PREFIX, PRECISION) \
376 do { \
377 RES_PREFIX ## R = MUL ## PRECISION(M1, M2_PREFIX ## R) + \
378 MUL ## PRECISION(M3, M4_PREFIX ## R); \
379 RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + \
380 MUL ## PRECISION(M3, M4_PREFIX ## G); \
381 RES_PREFIX ## B = MUL ## PRECISION(M1, M2_PREFIX ## B) + \
382 MUL ## PRECISION(M3, M4_PREFIX ## B); \
383 } while (0)
384
385
386 #define MultMultAddAndStoreLCD3Components(RES_PREFIX, M1, M2_PREFIX, \
387 M3, M4_PREFIX, PRECISION) \
388 do { \
389 RES_PREFIX ## R = MUL ## PRECISION(M1 ## R, M2_PREFIX ## R) + \
390 MUL ## PRECISION(M3 ## R, M4_PREFIX ## R); \
391 RES_PREFIX ## G = MUL ## PRECISION(M1 ## G, M2_PREFIX ## G) + \
392 MUL ## PRECISION(M3 ## G, M4_PREFIX ## G); \
393 RES_PREFIX ## B = MUL ## PRECISION(M1 ## B, M2_PREFIX ## B) + \
394 MUL ## PRECISION(M3 ## B, M4_PREFIX ## B); \
395 } while (0)
396
397 #define MultMultAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, \
398 M3, M4_PREFIX, PRECISION) \
399 RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + \
400 MUL ## PRECISION(M3, M4_PREFIX ## G)
401
402 #define MultMultAddAndStore3ByteRgbComps(RES_PREFIX, M1, M2_PREFIX, \
403 M3, M4_PREFIX) \
404 MultMultAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, \
405 M3, M4_PREFIX, 8)
406
407 #define MultMultAddAndStoreLCD3ByteRgbComps(RES_PREFIX, M1, M2_PREFIX, \
408 M3, M4_PREFIX) \
409 MultMultAddAndStoreLCD3Components(RES_PREFIX, M1, M2_PREFIX, \
410 M3, M4_PREFIX, 8)
411
412 #define MultMultAddAndStore4ByteArgbComps(RES_PREFIX, M1, M2_PREFIX, \
413 M3, M4_PREFIX) \
414 MultMultAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, \
415 M3, M4_PREFIX, 8)
416
417 #define MultMultAddAndStoreLCD4ByteArgbComps(RES_PREFIX, M1, M2_PREFIX, \
418 M3, M4_PREFIX) \
419 MultMultAddAndStoreLCD3Components(RES_PREFIX, M1, M2_PREFIX, \
420 M3, M4_PREFIX, 8)
421
422 #define MultMultAddAndStore1ByteGrayComps(RES_PREFIX, M1, M2_PREFIX, \
423 M3, M4_PREFIX) \
424 MultMultAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, \
425 M3, M4_PREFIX, 8)
426
427 #define MultMultAddAndStore1ShortGrayComps(RES_PREFIX, M1, M2_PREFIX, \
428 M3, M4_PREFIX) \
429 RES_PREFIX ## G = AddNormalizedProducts16(M1, M2_PREFIX ## G, \
430 M3, M4_PREFIX ## G)
431
432
433 /*
434 * Store ## STRATEGY ## CompsUsingOp(L_PREFIX, OP, R_PREFIX)
435 *
436 * l op r; // where op can be something like = or +=
437 */
438 #define Store3ComponentsUsingOp(L_PREFIX, OP, R_PREFIX) \
439 do { \
440 L_PREFIX ## R OP R_PREFIX ## R; \
441 L_PREFIX ## G OP R_PREFIX ## G; \
442 L_PREFIX ## B OP R_PREFIX ## B; \
443 } while (0)
444
445 #define Store1ComponentUsingOp(L_PREFIX, OP, R_PREFIX) \
446 L_PREFIX ## G OP R_PREFIX ## G
447
448 #define Store4ByteArgbCompsUsingOp(L_PREFIX, OP, R_PREFIX) \
449 Store3ComponentsUsingOp(L_PREFIX, OP, R_PREFIX)
450
451 #define Store1ByteGrayCompsUsingOp(L_PREFIX, OP, R_PREFIX) \
452 Store1ComponentUsingOp(L_PREFIX, OP, R_PREFIX)
453
454 #define Store1ShortGrayCompsUsingOp(L_PREFIX, OP, R_PREFIX) \
455 Store1ComponentUsingOp(L_PREFIX, OP, R_PREFIX)
456
457
458 /*
459 * Set ## STRATEGY ## CompsToZero(PREFIX)
460 *
461 * c = 0;
462 */
463 #define Set4ByteArgbCompsToZero(PREFIX) \
464 PREFIX ## R = PREFIX ## G = PREFIX ## B = 0
465
466 #define Set1ByteGrayCompsToZero(PREFIX) \
467 PREFIX ## G = 0
468
469 #define Set1ShortGrayCompsToZero(PREFIX) \
470 PREFIX ## G = 0
471
472 #endif /* AlphaMath_h_Included */