| /* | |
| * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| #ifndef AlphaMath_h_Included | |
| #define AlphaMath_h_Included | |
| #include "jni.h" | |
| JNIEXPORT extern unsigned char mul8table[256][256]; | |
| JNIEXPORT extern unsigned char div8table[256][256]; | |
| extern void initAlphaTables(); | |
| /* | |
| * Multiply and Divide macros for single byte (8-bit) quantities representing | |
| * the values 0.0 to 1.0 as 0x00 to 0xff. | |
| * MUL8 multiplies its operands together | |
| * DIV8 divides the first operand by the second, clipping to 0xff | |
| * (Note that since the divisor for DIV8 is likely to be | |
| * the alpha quantity which is likely to be the same for | |
| * multiple adjacent invocations, the table is designed | |
| * with the first index being the divisor to hopefully | |
| * improve memory cache hits...) | |
| */ | |
| #define MUL8(a,b) mul8table[a][b] | |
| #define DIV8(a,b) div8table[b][a] | |
| /* | |
| * Multiply and Divide macros for operations involving a single short (16-bit) | |
| * quantity and a single byte (8-bit) quantity. Typically, promoting the | |
| * 8-bit value to 16 bits would lead to overflow when the operation occurs. | |
| * These macros have been modified somewhat so that overflow will not occur. | |
| * MUL8_16 multiplies an 8-bit value by a 16-bit value (the order of operands | |
| * is unimportant since multiplication is a commutative operation) | |
| * DIV16_8 divides the first (16-bit) operand by the second (8-bit) value | |
| */ | |
| #define MUL8_16(a,b) (((a) * (b)) / 255) | |
| #define DIV16_8(a,b) (((a) * 255) / (b)) | |
| /* | |
| * Multiply and Divide macros for single short (16-bit) quantities | |
| * representing the values 0.0 to 1.0 as 0x0000 to 0xffff. | |
| * MUL16 multiplies its operands using the standard multiplication operator | |
| * and normalizes the result to the appropriate range | |
| * DIV16 divides the first operand by the second and normalizes the result | |
| * to a 16-bit value | |
| */ | |
| #define MUL16(a,b) (((a) * (b)) / 65535) | |
| #define DIV16(a,b) (((a) * 65535) / (b)) | |
| /* | |
| * Macro for the sum of two normalized (16-bit) products. Refer to the | |
| * following equation and note that the right side reduces the number of | |
| * divide operations in the left side and increases the precision of the | |
| * result: | |
| * a*f1 + b*f2 a*f1 + b*f2 | |
| * ---- ---- = ----------- (where n in this case will be 65535) | |
| * n n n | |
| */ | |
| #define AddNormalizedProducts16(a, f1, b, f2) \ | |
| ((((a) * (f1)) + ((b) * (f2))) / 65535) | |
| /* | |
| * The following macros help to generalize the MaskBlit and MaskFill loops | |
| * found in AlphaMacros.h. The appropriate macros will be used based on the | |
| * strategy of the given loop. The strategy types take the form: | |
| * <number of components per pixel><component data type><colorspace> | |
| * For example, these are the current strategy types: | |
| * 3ByteRgb (currently only used as a glyph list blending strategy where | |
| * the alpha value itself is neither blended nor stored) | |
| * 4ByteArgb (eg. IntArgb, ThreeByteBgr, Ushort555Rgb, ByteIndexed, etc.) | |
| * 4ShortArgb (not used currently; could be used when surface types using | |
| * 16 bits per component are implemented) | |
| * 1ByteGray (eg. ByteGray) | |
| * 1ShortGray (eg. UshortGray) | |
| * Note that the macros which operate on alpha values have the word "Alpha" | |
| * somewhere in their name. Those macros that only operate on the color/gray | |
| * components of a given strategy will have the word "Components" or "Comps" | |
| * in their name. | |
| */ | |
| /* | |
| * MaxValFor ## STRATEGY | |
| */ | |
| #define MaxValFor4ByteArgb 0xff | |
| #define MaxValFor1ByteGray 0xff | |
| #define MaxValFor1ShortGray 0xffff | |
| /* | |
| * AlphaType ## STRATEGY | |
| */ | |
| #define AlphaType3ByteRgb jint | |
| #define AlphaType4ByteArgb jint | |
| #define AlphaType1ByteGray jint | |
| #define AlphaType1ShortGray juint | |
| /* | |
| * ComponentType ## STRATEGY | |
| */ | |
| #define ComponentType3ByteRgb jint | |
| #define ComponentType4ByteArgb jint | |
| #define ComponentType1ByteGray jint | |
| #define ComponentType1ShortGray juint | |
| /* | |
| * DeclareAlphaVarFor ## STRATEGY(VAR) | |
| * | |
| * jint a; | |
| */ | |
| #define DeclareAlphaVarFor3ByteRgb(VAR) \ | |
| AlphaType3ByteRgb VAR; | |
| #define DeclareAlphaVarFor4ByteArgb(VAR) \ | |
| AlphaType4ByteArgb VAR; | |
| #define DeclareAlphaVarFor1ByteGray(VAR) \ | |
| AlphaType1ByteGray VAR; | |
| #define DeclareAlphaVarFor1ShortGray(VAR) \ | |
| AlphaType1ShortGray VAR; | |
| /* | |
| * DeclareAndInitAlphaVarFor ## STRATEGY(VAR, initval) | |
| * | |
| * jint a = initval; | |
| */ | |
| #define DeclareAndInitAlphaVarFor4ByteArgb(VAR, initval) \ | |
| AlphaType4ByteArgb VAR = initval; | |
| #define DeclareAndInitAlphaVarFor1ByteGray(VAR, initval) \ | |
| AlphaType1ByteGray VAR = initval; | |
| #define DeclareAndInitAlphaVarFor1ShortGray(VAR, initval) \ | |
| AlphaType1ShortGray VAR = initval; | |
| /* | |
| * DeclareAndClearAlphaVarFor ## STRATEGY(VAR) | |
| * | |
| * jint a = 0; | |
| */ | |
| #define DeclareAndClearAlphaVarFor4ByteArgb(VAR) \ | |
| DeclareAndInitAlphaVarFor4ByteArgb(VAR, 0) | |
| #define DeclareAndClearAlphaVarFor1ByteGray(VAR) \ | |
| DeclareAndInitAlphaVarFor1ByteGray(VAR, 0) | |
| #define DeclareAndClearAlphaVarFor1ShortGray(VAR) \ | |
| DeclareAndInitAlphaVarFor1ShortGray(VAR, 0) | |
| /* | |
| * DeclareAndSetOpaqueAlphaVarFor ## STRATEGY(VAR) | |
| * | |
| * jint a = 0xff; | |
| */ | |
| #define DeclareAndSetOpaqueAlphaVarFor4ByteArgb(VAR) \ | |
| DeclareAndInitAlphaVarFor4ByteArgb(VAR, MaxValFor4ByteArgb) | |
| #define DeclareAndSetOpaqueAlphaVarFor1ByteGray(VAR) \ | |
| DeclareAndInitAlphaVarFor1ByteGray(VAR, MaxValFor1ByteGray) | |
| #define DeclareAndSetOpaqueAlphaVarFor1ShortGray(VAR) \ | |
| DeclareAndInitAlphaVarFor1ShortGray(VAR, MaxValFor1ShortGray) | |
| /* | |
| * DeclareAndInvertAlphaVarFor ## STRATEGY(VAR, invalpha) | |
| * | |
| * jint a = 0xff - resA; | |
| */ | |
| #define DeclareAndInvertAlphaVarFor4ByteArgb(VAR, invalpha) \ | |
| DeclareAndInitAlphaVarFor4ByteArgb(VAR, MaxValFor4ByteArgb - invalpha) | |
| #define DeclareAndInvertAlphaVarFor1ByteGray(VAR, invalpha) \ | |
| DeclareAndInitAlphaVarFor1ByteGray(VAR, MaxValFor1ByteGray - invalpha) | |
| #define DeclareAndInvertAlphaVarFor1ShortGray(VAR, invalpha) \ | |
| DeclareAndInitAlphaVarFor1ShortGray(VAR, MaxValFor1ShortGray - invalpha) | |
| /* | |
| * DeclareCompVarsFor ## STRATEGY(PREFIX) | |
| * | |
| * jint c; | |
| */ | |
| #define DeclareCompVarsFor3ByteRgb(PREFIX) \ | |
| ComponentType3ByteRgb PREFIX ## R, PREFIX ## G, PREFIX ## B; | |
| #define DeclareCompVarsFor4ByteArgb(PREFIX) \ | |
| ComponentType4ByteArgb PREFIX ## R, PREFIX ## G, PREFIX ## B; | |
| #define DeclareCompVarsFor1ByteGray(PREFIX) \ | |
| ComponentType1ByteGray PREFIX ## G; | |
| #define DeclareCompVarsFor1ShortGray(PREFIX) \ | |
| ComponentType1ShortGray PREFIX ## G; | |
| /* | |
| * DeclareAndInitExtraAlphaFor ## STRATEGY(VAR) | |
| * | |
| * jint extraA = (int)(pCompInfo->details.extraAlpha * 255.0 + 0.5); | |
| */ | |
| #define DeclareAndInitExtraAlphaFor4ByteArgb(VAR) \ | |
| AlphaType4ByteArgb VAR = \ | |
| (AlphaType4ByteArgb)(pCompInfo->details.extraAlpha * 255.0 + 0.5); | |
| #define DeclareAndInitExtraAlphaFor1ByteGray(VAR) \ | |
| AlphaType1ByteGray VAR = \ | |
| (AlphaType1ByteGray)(pCompInfo->details.extraAlpha * 255.0 + 0.5); | |
| #define DeclareAndInitExtraAlphaFor1ShortGray(VAR) \ | |
| AlphaType1ShortGray VAR = \ | |
| (AlphaType1ShortGray)(pCompInfo->details.extraAlpha * 65535.0 + 0.5); | |
| /* | |
| * PromoteByteAlphaFor ## STRATEGY(a) | |
| */ | |
| #define PromoteByteAlphaFor4ByteArgb(a) | |
| #define PromoteByteAlphaFor1ByteGray(a) | |
| #define PromoteByteAlphaFor1ShortGray(a) \ | |
| (a) = (((a) << 8) + (a)) | |
| /* | |
| * DeclareAndInitPathAlphaFor ## STRATEGY(VAR) | |
| * | |
| * jint pathA = *pMask++; | |
| */ | |
| #define DeclareAndInitPathAlphaFor4ByteArgb(VAR) \ | |
| AlphaType4ByteArgb VAR = *pMask++; | |
| #define DeclareAndInitPathAlphaFor1ByteGray(VAR) \ | |
| AlphaType1ByteGray VAR = *pMask++; | |
| #define DeclareAndInitPathAlphaFor1ShortGray(VAR) \ | |
| AlphaType1ShortGray VAR = *pMask++; | |
| /* | |
| * MultiplyAlphaFor ## STRATEGY(a, b) | |
| * | |
| * a * b | |
| */ | |
| #define MultiplyAlphaFor4ByteArgb(a, b) \ | |
| MUL8(a, b) | |
| #define MultiplyAlphaFor1ByteGray(a, b) \ | |
| MUL8(a, b) | |
| #define MultiplyAlphaFor1ShortGray(a, b) \ | |
| MUL16(a, b) | |
| /* | |
| * MultiplyAndStore ## STRATEGY ## Comps(PROD_PREFIX, M1, M2_PREFIX) | |
| * | |
| * c = m1 * m2; | |
| */ | |
| #define MultiplyAndStore3Components(PROD_PREFIX, M1, M2_PREFIX, PRECISION) \ | |
| do { \ | |
| PROD_PREFIX ## R = MUL ## PRECISION(M1, M2_PREFIX ## R); \ | |
| PROD_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G); \ | |
| PROD_PREFIX ## B = MUL ## PRECISION(M1, M2_PREFIX ## B); \ | |
| } while (0) | |
| #define MultiplyAndStore1Component(PROD_PREFIX, M1, M2_PREFIX, PRECISION) \ | |
| PROD_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) | |
| #define MultiplyAndStore4ByteArgbComps(PROD_PREFIX, M1, M2_PREFIX) \ | |
| MultiplyAndStore3Components(PROD_PREFIX, M1, M2_PREFIX, 8) | |
| #define MultiplyAndStore1ByteGrayComps(PROD_PREFIX, M1, M2_PREFIX) \ | |
| MultiplyAndStore1Component(PROD_PREFIX, M1, M2_PREFIX, 8) | |
| #define MultiplyAndStore1ShortGrayComps(PROD_PREFIX, M1, M2_PREFIX) \ | |
| MultiplyAndStore1Component(PROD_PREFIX, M1, M2_PREFIX, 16) | |
| /* | |
| * DivideAndStore ## STRATEGY ## Comps(QUOT_PREFIX, D1_PREFIX, D2) | |
| * | |
| * c = d1 / d2; | |
| */ | |
| #define DivideAndStore3Components(QUOT_PREFIX, D1_PREFIX, D2, PRECISION) \ | |
| do { \ | |
| QUOT_PREFIX ## R = DIV ## PRECISION(D1_PREFIX ## R, D2); \ | |
| QUOT_PREFIX ## G = DIV ## PRECISION(D1_PREFIX ## G, D2); \ | |
| QUOT_PREFIX ## B = DIV ## PRECISION(D1_PREFIX ## B, D2); \ | |
| } while (0) | |
| #define DivideAndStore1Component(QUOT_PREFIX, D1_PREFIX, D2, PRECISION) \ | |
| QUOT_PREFIX ## G = DIV ## PRECISION(D1_PREFIX ## G, D2) | |
| #define DivideAndStore4ByteArgbComps(QUOT_PREFIX, D1_PREFIX, D2) \ | |
| DivideAndStore3Components(QUOT_PREFIX, D1_PREFIX, D2, 8) | |
| #define DivideAndStore1ByteGrayComps(QUOT_PREFIX, D1_PREFIX, D2) \ | |
| DivideAndStore1Component(QUOT_PREFIX, D1_PREFIX, D2, 8) | |
| #define DivideAndStore1ShortGrayComps(QUOT_PREFIX, D1_PREFIX, D2) \ | |
| DivideAndStore1Component(QUOT_PREFIX, D1_PREFIX, D2, 16) | |
| /* | |
| * MultiplyAddAndStore ## STRATEGY ## Comps(RES_PREFIX, M1, \ | |
| * M2_PREFIX, A_PREFIX) | |
| * | |
| * c = (m1 * m2) + a; | |
| */ | |
| #define MultiplyAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, \ | |
| PRECISION) \ | |
| do { \ | |
| RES_PREFIX ## R = MUL ## PRECISION(M1, M2_PREFIX ## R) + \ | |
| A_PREFIX ## R; \ | |
| RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + \ | |
| A_PREFIX ## G; \ | |
| RES_PREFIX ## B = MUL ## PRECISION(M1, M2_PREFIX ## B) + \ | |
| A_PREFIX ## B; \ | |
| } while (0) | |
| #define MultiplyAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, \ | |
| PRECISION) \ | |
| RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + A_PREFIX ## G | |
| #define MultiplyAddAndStore4ByteArgbComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| A_PREFIX) \ | |
| MultiplyAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, 8) | |
| #define MultiplyAddAndStore1ByteGrayComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| A_PREFIX) \ | |
| MultiplyAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, 8) | |
| #define MultiplyAddAndStore1ShortGrayComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| A_PREFIX) \ | |
| MultiplyAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, A_PREFIX, 16) | |
| /* | |
| * MultMultAddAndStore ## STRATEGY ## Comps(RES_PREFIX, M1, M2_PREFIX, \ | |
| * M3, M4_PREFIX) | |
| * | |
| * c = (m1 * m2) + (m3 * m4); | |
| */ | |
| #define MultMultAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, PRECISION) \ | |
| do { \ | |
| RES_PREFIX ## R = MUL ## PRECISION(M1, M2_PREFIX ## R) + \ | |
| MUL ## PRECISION(M3, M4_PREFIX ## R); \ | |
| RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + \ | |
| MUL ## PRECISION(M3, M4_PREFIX ## G); \ | |
| RES_PREFIX ## B = MUL ## PRECISION(M1, M2_PREFIX ## B) + \ | |
| MUL ## PRECISION(M3, M4_PREFIX ## B); \ | |
| } while (0) | |
| #define MultMultAddAndStoreLCD3Components(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, PRECISION) \ | |
| do { \ | |
| RES_PREFIX ## R = MUL ## PRECISION(M1 ## R, M2_PREFIX ## R) + \ | |
| MUL ## PRECISION(M3 ## R, M4_PREFIX ## R); \ | |
| RES_PREFIX ## G = MUL ## PRECISION(M1 ## G, M2_PREFIX ## G) + \ | |
| MUL ## PRECISION(M3 ## G, M4_PREFIX ## G); \ | |
| RES_PREFIX ## B = MUL ## PRECISION(M1 ## B, M2_PREFIX ## B) + \ | |
| MUL ## PRECISION(M3 ## B, M4_PREFIX ## B); \ | |
| } while (0) | |
| #define MultMultAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, PRECISION) \ | |
| RES_PREFIX ## G = MUL ## PRECISION(M1, M2_PREFIX ## G) + \ | |
| MUL ## PRECISION(M3, M4_PREFIX ## G) | |
| #define MultMultAddAndStore3ByteRgbComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX) \ | |
| MultMultAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, 8) | |
| #define MultMultAddAndStoreLCD3ByteRgbComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX) \ | |
| MultMultAddAndStoreLCD3Components(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, 8) | |
| #define MultMultAddAndStore4ByteArgbComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX) \ | |
| MultMultAddAndStore3Components(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, 8) | |
| #define MultMultAddAndStoreLCD4ByteArgbComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX) \ | |
| MultMultAddAndStoreLCD3Components(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, 8) | |
| #define MultMultAddAndStore1ByteGrayComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX) \ | |
| MultMultAddAndStore1Component(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX, 8) | |
| #define MultMultAddAndStore1ShortGrayComps(RES_PREFIX, M1, M2_PREFIX, \ | |
| M3, M4_PREFIX) \ | |
| RES_PREFIX ## G = AddNormalizedProducts16(M1, M2_PREFIX ## G, \ | |
| M3, M4_PREFIX ## G) | |
| /* | |
| * Store ## STRATEGY ## CompsUsingOp(L_PREFIX, OP, R_PREFIX) | |
| * | |
| * l op r; // where op can be something like = or += | |
| */ | |
| #define Store3ComponentsUsingOp(L_PREFIX, OP, R_PREFIX) \ | |
| do { \ | |
| L_PREFIX ## R OP R_PREFIX ## R; \ | |
| L_PREFIX ## G OP R_PREFIX ## G; \ | |
| L_PREFIX ## B OP R_PREFIX ## B; \ | |
| } while (0) | |
| #define Store1ComponentUsingOp(L_PREFIX, OP, R_PREFIX) \ | |
| L_PREFIX ## G OP R_PREFIX ## G | |
| #define Store4ByteArgbCompsUsingOp(L_PREFIX, OP, R_PREFIX) \ | |
| Store3ComponentsUsingOp(L_PREFIX, OP, R_PREFIX) | |
| #define Store1ByteGrayCompsUsingOp(L_PREFIX, OP, R_PREFIX) \ | |
| Store1ComponentUsingOp(L_PREFIX, OP, R_PREFIX) | |
| #define Store1ShortGrayCompsUsingOp(L_PREFIX, OP, R_PREFIX) \ | |
| Store1ComponentUsingOp(L_PREFIX, OP, R_PREFIX) | |
| /* | |
| * Set ## STRATEGY ## CompsToZero(PREFIX) | |
| * | |
| * c = 0; | |
| */ | |
| #define Set4ByteArgbCompsToZero(PREFIX) \ | |
| PREFIX ## R = PREFIX ## G = PREFIX ## B = 0 | |
| #define Set1ByteGrayCompsToZero(PREFIX) \ | |
| PREFIX ## G = 0 | |
| #define Set1ShortGrayCompsToZero(PREFIX) \ | |
| PREFIX ## G = 0 | |
| #endif /* AlphaMath_h_Included */ |