| /* |
| * Copyright (c) 2000, 2008, 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 AlphaMacros_h_Included |
| #define AlphaMacros_h_Included |
| |
| #include "GraphicsPrimitiveMgr.h" |
| #include "AlphaMath.h" |
| #include "IntArgb.h" /* for "Extract...FromArgb" macros */ |
| |
| #define DeclareAlphaOperands(PREFIX) \ |
| jint PREFIX ## And, PREFIX ## Xor, PREFIX ## Add; |
| |
| #define ExtractAlphaOperandsFor4ByteArgb(f, PREFIX) \ |
| do { \ |
| PREFIX ## And = (f).andval; \ |
| PREFIX ## Xor = (f).xorval; \ |
| PREFIX ## Add = (jint) (f).addval - PREFIX ## Xor; \ |
| } while (0) |
| |
| #define ExtractAlphaOperandsFor1ByteGray(f, PREFIX) \ |
| ExtractAlphaOperandsFor4ByteArgb(f, PREFIX) |
| |
| #define ExtractAlphaOperandsFor1ShortGray(f, PREFIX) \ |
| do { \ |
| PREFIX ## And = ((f).andval << 8) + (f).andval; \ |
| PREFIX ## Xor = (f).xorval; \ |
| PREFIX ## Add = (jint) (((f).addval << 8) + (f).addval) - \ |
| PREFIX ## Xor; \ |
| } while (0) |
| |
| #define ApplyAlphaOperands(PREFIX, a) \ |
| ((((a) & PREFIX ## And) ^ PREFIX ## Xor) + PREFIX ## Add) |
| |
| #define FuncNeedsAlpha(PREFIX) (PREFIX ## And != 0) |
| #define FuncIsZero(PREFIX) ((PREFIX ## And | PREFIX ## Add) == 0) |
| |
| typedef struct { |
| jubyte addval; |
| jubyte andval; |
| jshort xorval; |
| } AlphaOperands; |
| |
| typedef struct { |
| AlphaOperands srcOps; |
| AlphaOperands dstOps; |
| } AlphaFunc; |
| |
| extern AlphaFunc AlphaRules[]; |
| |
| #define DEFINE_ALPHA_MASKBLIT(SRC, DST, STRATEGY) \ |
| void NAME_ALPHA_MASKBLIT(SRC, DST) \ |
| (void *dstBase, void *srcBase, \ |
| jubyte *pMask, jint maskOff, jint maskScan, \ |
| jint width, jint height, \ |
| SurfaceDataRasInfo *pDstInfo, \ |
| SurfaceDataRasInfo *pSrcInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| DeclareAndSetOpaqueAlphaVarFor ## STRATEGY(pathA) \ |
| DeclareAndClearAlphaVarFor ## STRATEGY(srcA) \ |
| DeclareAndClearAlphaVarFor ## STRATEGY(dstA) \ |
| DeclareAndInitExtraAlphaFor ## STRATEGY(extraA) \ |
| jint srcScan = pSrcInfo->scanStride; \ |
| jint dstScan = pDstInfo->scanStride; \ |
| jboolean loadsrc, loaddst; \ |
| SRC ## DataType *pSrc = (SRC ## DataType *) (srcBase); \ |
| DST ## DataType *pDst = (DST ## DataType *) (dstBase); \ |
| Declare ## SRC ## AlphaLoadData(SrcPix) \ |
| Declare ## DST ## AlphaLoadData(DstPix) \ |
| Declare ## DST ## StoreVars(DstWrite) \ |
| DeclareAlphaOperands(SrcOp) \ |
| DeclareAlphaOperands(DstOp) \ |
| \ |
| ExtractAlphaOperandsFor ## STRATEGY(AlphaRules[pCompInfo->rule].srcOps, \ |
| SrcOp); \ |
| ExtractAlphaOperandsFor ## STRATEGY(AlphaRules[pCompInfo->rule].dstOps, \ |
| DstOp); \ |
| loadsrc = !FuncIsZero(SrcOp) || FuncNeedsAlpha(DstOp); \ |
| loaddst = pMask || !FuncIsZero(DstOp) || FuncNeedsAlpha(SrcOp); \ |
| \ |
| Init ## SRC ## AlphaLoadData(SrcPix, pSrcInfo); \ |
| Init ## DST ## AlphaLoadData(DstPix, pDstInfo); \ |
| srcScan -= width * SRC ## PixelStride; \ |
| dstScan -= width * DST ## PixelStride; \ |
| maskScan -= width; \ |
| if (pMask) { \ |
| pMask += maskOff; \ |
| } \ |
| \ |
| Init ## DST ## StoreVarsY(DstWrite, pDstInfo); \ |
| do { \ |
| jint w = width; \ |
| Init ## DST ## StoreVarsX(DstWrite, pDstInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| DeclareAlphaVarFor ## STRATEGY(dstF) \ |
| \ |
| if (pMask) { \ |
| pathA = *pMask++; \ |
| if (!pathA) { \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| continue; \ |
| } \ |
| PromoteByteAlphaFor ## STRATEGY(pathA); \ |
| } \ |
| if (loadsrc) { \ |
| LoadAlphaFrom ## SRC ## For ## STRATEGY(pSrc, SrcPix, src); \ |
| srcA = MultiplyAlphaFor ## STRATEGY(extraA, srcA); \ |
| } \ |
| if (loaddst) { \ |
| LoadAlphaFrom ## DST ## For ## STRATEGY(pDst, DstPix, dst); \ |
| } \ |
| srcF = ApplyAlphaOperands(SrcOp, dstA); \ |
| dstF = ApplyAlphaOperands(DstOp, srcA); \ |
| if (pathA != MaxValFor ## STRATEGY) { \ |
| srcF = MultiplyAlphaFor ## STRATEGY(pathA, srcF); \ |
| dstF = MaxValFor ## STRATEGY - pathA + \ |
| MultiplyAlphaFor ## STRATEGY(pathA, dstF); \ |
| } \ |
| if (srcF) { \ |
| resA = MultiplyAlphaFor ## STRATEGY(srcF, srcA); \ |
| if (!(SRC ## IsPremultiplied)) { \ |
| srcF = resA; \ |
| } else { \ |
| srcF = MultiplyAlphaFor ## STRATEGY(srcF, extraA); \ |
| } \ |
| if (srcF) { \ |
| /* assert(loadsrc); */ \ |
| Postload ## STRATEGY ## From ## SRC(pSrc, SrcPix, res); \ |
| if (srcF != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, \ |
| srcF, res); \ |
| } \ |
| } else { \ |
| if (dstF == MaxValFor ## STRATEGY) { \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| continue; \ |
| } \ |
| Set ## STRATEGY ## CompsToZero(res); \ |
| } \ |
| } else { \ |
| if (dstF == MaxValFor ## STRATEGY) { \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| continue; \ |
| } \ |
| resA = 0; \ |
| Set ## STRATEGY ## CompsToZero(res); \ |
| } \ |
| if (dstF) { \ |
| dstA = MultiplyAlphaFor ## STRATEGY(dstF, dstA); \ |
| if (!(DST ## IsPremultiplied)) { \ |
| dstF = dstA; \ |
| } \ |
| resA += dstA; \ |
| if (dstF) { \ |
| DeclareCompVarsFor ## STRATEGY(tmp) \ |
| /* assert(loaddst); */ \ |
| Postload ## STRATEGY ## From ## DST(pDst, DstPix, tmp); \ |
| if (dstF != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(tmp, \ |
| dstF, tmp); \ |
| } \ |
| Store ## STRATEGY ## CompsUsingOp(res, +=, tmp); \ |
| } \ |
| } \ |
| if (!(DST ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, res, resA); \ |
| } \ |
| Store ## DST ## From ## STRATEGY ## Comps(pDst, DstWrite, \ |
| 0, res); \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pSrc = PtrAddBytes(pSrc, srcScan); \ |
| pDst = PtrAddBytes(pDst, dstScan); \ |
| Next ## DST ## StoreVarsY(DstWrite); \ |
| if (pMask) { \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } \ |
| } while (--height > 0); \ |
| } |
| |
| /* REMIND: This macro is as yet, untested */ |
| #define DEFINE_SRC_MASKBLIT(SRC, DST, STRATEGY) \ |
| void NAME_SRC_MASKBLIT(SRC, DST) \ |
| (void *dstBase, void *srcBase, \ |
| jubyte *pMask, jint maskOff, jint maskScan, \ |
| jint width, jint height, \ |
| SurfaceDataRasInfo *pDstInfo, \ |
| SurfaceDataRasInfo *pSrcInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| DeclareAndInitExtraAlphaFor ## STRATEGY(extraA) \ |
| jint srcScan = pSrcInfo->scanStride; \ |
| jint dstScan = pDstInfo->scanStride; \ |
| SRC ## DataType *pSrc = (SRC ## DataType *) (srcBase); \ |
| DST ## DataType *pDst = (DST ## DataType *) (dstBase); \ |
| Declare ## SRC ## AlphaLoadData(SrcPix) \ |
| Declare ## DST ## AlphaLoadData(DstPix) \ |
| Declare ## DST ## StoreVars(DstWrite) \ |
| \ |
| Init ## SRC ## AlphaLoadData(SrcPix, pSrcInfo); \ |
| Init ## DST ## AlphaLoadData(DstPix, pDstInfo); \ |
| srcScan -= width * SRC ## PixelStride; \ |
| dstScan -= width * DST ## PixelStride; \ |
| \ |
| Init ## DST ## StoreVarsY(DstWrite, pDstInfo); \ |
| if (pMask) { \ |
| maskScan -= width; \ |
| pMask += maskOff; \ |
| do { \ |
| jint w = width; \ |
| Init ## DST ## StoreVarsX(DstWrite, pDstInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| DeclareAlphaVarFor ## STRATEGY(dstF) \ |
| DeclareAndInitPathAlphaFor ## STRATEGY(pathA) \ |
| \ |
| if (pathA) { \ |
| LoadAlphaFrom ## SRC ## For ## STRATEGY(pSrc, \ |
| SrcPix, res); \ |
| resA = MultiplyAlphaFor ## STRATEGY(extraA, resA); \ |
| if (SRC ## IsPremultiplied) { \ |
| srcF = extraA; \ |
| } else { \ |
| srcF = resA; \ |
| } \ |
| Postload ## STRATEGY ## From ## SRC(pSrc, SrcPix, res); \ |
| if (pathA < 0xff) { \ |
| DeclareAlphaVarFor ## STRATEGY(dstA) \ |
| DeclareCompVarsFor ## STRATEGY(dst) \ |
| PromoteByteAlphaFor ## STRATEGY(pathA); \ |
| srcF = MultiplyAlphaFor ## STRATEGY(pathA, srcF); \ |
| dstF = MaxValFor ## STRATEGY - pathA; \ |
| LoadAlphaFrom ## DST ## For ## STRATEGY(pDst, \ |
| DstPix, \ |
| dst); \ |
| dstA = MultiplyAlphaFor ## STRATEGY(dstF, dstA) \ |
| if (!(DST ## IsPremultiplied)) { \ |
| dstF = dstA; \ |
| } \ |
| Postload ## STRATEGY ## From ## DST(pDst, DstPix, \ |
| dst); \ |
| resA = dstA + \ |
| MultiplyAlphaFor ## STRATEGY(pathA, resA); \ |
| MultMultAddAndStore ## STRATEGY ## Comps(res, \ |
| dstF, dst, \ |
| srcF, res); \ |
| } else if (srcF < MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, \ |
| srcF, src); \ |
| } \ |
| if (!(DST ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, res, resA); \ |
| } \ |
| Store ## DST ## From ## STRATEGY ## Comps(pDst, DstWrite,\ |
| 0, res);\ |
| } \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pSrc = PtrAddBytes(pSrc, srcScan); \ |
| pDst = PtrAddBytes(pDst, dstScan); \ |
| Next ## DST ## StoreVarsY(DstWrite); \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } while (--height > 0); \ |
| } else /* pMask == 0 */ { \ |
| do { \ |
| jint w = width; \ |
| Init ## DST ## StoreVarsX(DstWrite, pDstInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| \ |
| LoadAlphaFrom ## SRC ## For ## STRATEGY(pSrc, SrcPix, res); \ |
| resA = MultiplyAlphaFor ## STRATEGY(extraA, resA); \ |
| if (SRC ## IsPremultiplied) { \ |
| srcF = extraA; \ |
| } else { \ |
| srcF = resA; \ |
| } \ |
| Postload ## STRATEGY ## From ## SRC(pSrc, SrcPix, res); \ |
| if (srcF < MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, srcF, src); \ |
| } \ |
| if (!(DST ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, res, resA); \ |
| } \ |
| Store ## DST ## From ## STRATEGY ## Comps(pDst, DstWrite, \ |
| 0, res); \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pSrc = PtrAddBytes(pSrc, srcScan); \ |
| pDst = PtrAddBytes(pDst, dstScan); \ |
| Next ## DST ## StoreVarsY(DstWrite); \ |
| } while (--height > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_SRCOVER_MASKBLIT(SRC, DST, STRATEGY) \ |
| void NAME_SRCOVER_MASKBLIT(SRC, DST) \ |
| (void *dstBase, void *srcBase, \ |
| jubyte *pMask, jint maskOff, jint maskScan, \ |
| jint width, jint height, \ |
| SurfaceDataRasInfo *pDstInfo, \ |
| SurfaceDataRasInfo *pSrcInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| DeclareAndInitExtraAlphaFor ## STRATEGY(extraA) \ |
| jint srcScan = pSrcInfo->scanStride; \ |
| jint dstScan = pDstInfo->scanStride; \ |
| SRC ## DataType *pSrc = (SRC ## DataType *) (srcBase); \ |
| DST ## DataType *pDst = (DST ## DataType *) (dstBase); \ |
| Declare ## SRC ## AlphaLoadData(SrcPix) \ |
| Declare ## DST ## AlphaLoadData(DstPix) \ |
| Declare ## DST ## StoreVars(DstWrite) \ |
| \ |
| Init ## SRC ## AlphaLoadData(SrcPix, pSrcInfo); \ |
| Init ## DST ## AlphaLoadData(DstPix, pDstInfo); \ |
| srcScan -= width * SRC ## PixelStride; \ |
| dstScan -= width * DST ## PixelStride; \ |
| \ |
| Init ## DST ## StoreVarsY(DstWrite, pDstInfo); \ |
| if (pMask) { \ |
| pMask += maskOff; \ |
| maskScan -= width; \ |
| do { \ |
| jint w = width; \ |
| Init ## DST ## StoreVarsX(DstWrite, pDstInfo); \ |
| do { \ |
| DeclareAndInitPathAlphaFor ## STRATEGY(pathA) \ |
| \ |
| if (pathA) { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| PromoteByteAlphaFor ## STRATEGY(pathA); \ |
| pathA = MultiplyAlphaFor ## STRATEGY(pathA, extraA); \ |
| LoadAlphaFrom ## SRC ## For ## STRATEGY(pSrc, \ |
| SrcPix, res); \ |
| resA = MultiplyAlphaFor ## STRATEGY(pathA, resA); \ |
| if (resA) { \ |
| if (SRC ## IsPremultiplied) { \ |
| srcF = pathA; \ |
| } else { \ |
| srcF = resA; \ |
| } \ |
| Postload ## STRATEGY ## From ## SRC(pSrc, SrcPix, \ |
| res); \ |
| if (resA < MaxValFor ## STRATEGY) { \ |
| DeclareAlphaVarFor ## STRATEGY(dstA) \ |
| DeclareCompVarsFor ## STRATEGY(dst) \ |
| DeclareAndInvertAlphaVarFor ## STRATEGY(dstF, \ |
| resA) \ |
| LoadAlphaFrom ## DST ## For ## STRATEGY(pDst, \ |
| DstPix, \ |
| dst); \ |
| dstA = MultiplyAlphaFor ## STRATEGY(dstF, dstA); \ |
| if (!(DST ## IsPremultiplied)) { \ |
| dstF = dstA; \ |
| } \ |
| Postload ## STRATEGY ## From ## DST(pDst, DstPix,\ |
| dst); \ |
| resA += dstA; \ |
| MultMultAddAndStore ## STRATEGY ## Comps(res, \ |
| dstF, dst, \ |
| srcF, res);\ |
| } else if (srcF < MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, \ |
| srcF, res);\ |
| } \ |
| if (!(DST ## IsOpaque) && \ |
| !(DST ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, \ |
| res, resA); \ |
| } \ |
| Store ## DST ## From ## STRATEGY ## Comps(pDst, \ |
| DstWrite, \ |
| 0, res); \ |
| } \ |
| } \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pSrc = PtrAddBytes(pSrc, srcScan); \ |
| pDst = PtrAddBytes(pDst, dstScan); \ |
| Next ## DST ## StoreVarsY(DstWrite); \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } while (--height > 0); \ |
| } else /* pMask == 0 */ { \ |
| do { \ |
| jint w = width; \ |
| Init ## DST ## StoreVarsX(DstWrite, pDstInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| \ |
| LoadAlphaFrom ## SRC ## For ## STRATEGY(pSrc, SrcPix, res); \ |
| resA = MultiplyAlphaFor ## STRATEGY(extraA, resA); \ |
| if (resA) { \ |
| if (SRC ## IsPremultiplied) { \ |
| srcF = extraA; \ |
| } else { \ |
| srcF = resA; \ |
| } \ |
| Postload ## STRATEGY ## From ## SRC(pSrc, SrcPix, res); \ |
| if (resA < MaxValFor ## STRATEGY) { \ |
| DeclareAlphaVarFor ## STRATEGY(dstA) \ |
| DeclareCompVarsFor ## STRATEGY(dst) \ |
| DeclareAndInvertAlphaVarFor ## STRATEGY(dstF, resA) \ |
| LoadAlphaFrom ## DST ## For ## STRATEGY(pDst, \ |
| DstPix, \ |
| dst); \ |
| dstA = MultiplyAlphaFor ## STRATEGY(dstF, dstA); \ |
| if (!(DST ## IsPremultiplied)) { \ |
| dstF = dstA; \ |
| } \ |
| Postload ## STRATEGY ## From ## DST(pDst, DstPix, \ |
| dst); \ |
| resA += dstA; \ |
| MultMultAddAndStore ## STRATEGY ## Comps(res, \ |
| dstF, dst, \ |
| srcF, res); \ |
| } else if (srcF < MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, \ |
| srcF, res); \ |
| } \ |
| if (!(DST ## IsOpaque) && \ |
| !(DST ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, res, resA); \ |
| } \ |
| Store ## DST ## From ## STRATEGY ## Comps(pDst, DstWrite,\ |
| 0, res); \ |
| } \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pSrc = PtrAddBytes(pSrc, srcScan); \ |
| pDst = PtrAddBytes(pDst, dstScan); \ |
| Next ## DST ## StoreVarsY(DstWrite); \ |
| } while (--height > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_ALPHA_MASKFILL(TYPE, STRATEGY) \ |
| void NAME_ALPHA_MASKFILL(TYPE) \ |
| (void *rasBase, \ |
| jubyte *pMask, jint maskOff, jint maskScan, \ |
| jint width, jint height, \ |
| jint fgColor, \ |
| SurfaceDataRasInfo *pRasInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| DeclareAndSetOpaqueAlphaVarFor ## STRATEGY(pathA) \ |
| DeclareAlphaVarFor ## STRATEGY(srcA) \ |
| DeclareCompVarsFor ## STRATEGY(src) \ |
| DeclareAndClearAlphaVarFor ## STRATEGY(dstA) \ |
| DeclareAlphaVarFor ## STRATEGY(dstF) \ |
| DeclareAlphaVarFor ## STRATEGY(dstFbase) \ |
| jint rasScan = pRasInfo->scanStride; \ |
| jboolean loaddst; \ |
| TYPE ## DataType *pRas = (TYPE ## DataType *) (rasBase); \ |
| Declare ## TYPE ## AlphaLoadData(DstPix) \ |
| Declare ## TYPE ## StoreVars(DstWrite) \ |
| DeclareAlphaOperands(SrcOp) \ |
| DeclareAlphaOperands(DstOp) \ |
| \ |
| Extract ## STRATEGY ## CompsAndAlphaFromArgb(fgColor, src); \ |
| if (srcA != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(src, srcA, src); \ |
| } \ |
| \ |
| ExtractAlphaOperandsFor ## STRATEGY(AlphaRules[pCompInfo->rule].srcOps, \ |
| SrcOp); \ |
| ExtractAlphaOperandsFor ## STRATEGY(AlphaRules[pCompInfo->rule].dstOps, \ |
| DstOp); \ |
| loaddst = pMask || !FuncIsZero(DstOp) || FuncNeedsAlpha(SrcOp); \ |
| \ |
| dstFbase = dstF = ApplyAlphaOperands(DstOp, srcA); \ |
| \ |
| Init ## TYPE ## AlphaLoadData(DstPix, pRasInfo); \ |
| rasScan -= width * TYPE ## PixelStride; \ |
| maskScan -= width; \ |
| if (pMask) { \ |
| pMask += maskOff; \ |
| } \ |
| \ |
| Init ## TYPE ## StoreVarsY(DstWrite, pRasInfo); \ |
| do { \ |
| jint w = width; \ |
| Init ## TYPE ## StoreVarsX(DstWrite, pRasInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| \ |
| if (pMask) { \ |
| pathA = *pMask++; \ |
| if (!pathA) { \ |
| pRas = PtrAddBytes(pRas, TYPE ## PixelStride); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| continue; \ |
| } \ |
| PromoteByteAlphaFor ## STRATEGY(pathA); \ |
| dstF = dstFbase; \ |
| } \ |
| if (loaddst) { \ |
| LoadAlphaFrom ## TYPE ## For ## STRATEGY(pRas, DstPix, dst);\ |
| } \ |
| srcF = ApplyAlphaOperands(SrcOp, dstA); \ |
| if (pathA != MaxValFor ## STRATEGY) { \ |
| srcF = MultiplyAlphaFor ## STRATEGY(pathA, srcF); \ |
| dstF = MaxValFor ## STRATEGY - pathA + \ |
| MultiplyAlphaFor ## STRATEGY(pathA, dstF); \ |
| } \ |
| if (srcF) { \ |
| if (srcF == MaxValFor ## STRATEGY) { \ |
| resA = srcA; \ |
| Store ## STRATEGY ## CompsUsingOp(res, =, src); \ |
| } else { \ |
| resA = MultiplyAlphaFor ## STRATEGY(srcF, srcA); \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, srcF, src); \ |
| } \ |
| } else { \ |
| if (dstF == MaxValFor ## STRATEGY) { \ |
| pRas = PtrAddBytes(pRas, TYPE ## PixelStride); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| continue; \ |
| } \ |
| resA = 0; \ |
| Set ## STRATEGY ## CompsToZero(res); \ |
| } \ |
| if (dstF) { \ |
| dstA = MultiplyAlphaFor ## STRATEGY(dstF, dstA); \ |
| resA += dstA; \ |
| if (TYPE ## IsPremultiplied) { \ |
| dstA = dstF; \ |
| } \ |
| if (dstA) { \ |
| DeclareCompVarsFor ## STRATEGY(tmp) \ |
| /* assert(loaddst); */ \ |
| Postload ## STRATEGY ## From ## TYPE(pRas, DstPix, tmp); \ |
| if (dstA != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(tmp, \ |
| dstA, tmp); \ |
| } \ |
| Store ## STRATEGY ## CompsUsingOp(res, +=, tmp); \ |
| } \ |
| } \ |
| if (!(TYPE ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, res, resA); \ |
| } \ |
| Store ## TYPE ## From ## STRATEGY ## Comps(pRas, DstWrite, \ |
| 0, res); \ |
| pRas = PtrAddBytes(pRas, TYPE ## PixelStride); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pRas = PtrAddBytes(pRas, rasScan); \ |
| Next ## TYPE ## StoreVarsY(DstWrite); \ |
| if (pMask) { \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } \ |
| } while (--height > 0); \ |
| } |
| |
| #define DEFINE_SRC_MASKFILL(TYPE, STRATEGY) \ |
| void NAME_SRC_MASKFILL(TYPE) \ |
| (void *rasBase, \ |
| jubyte *pMask, jint maskOff, jint maskScan, \ |
| jint width, jint height, \ |
| jint fgColor, \ |
| SurfaceDataRasInfo *pRasInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| DeclareAlphaVarFor ## STRATEGY(srcA) \ |
| DeclareCompVarsFor ## STRATEGY(src) \ |
| jint rasScan = pRasInfo->scanStride; \ |
| TYPE ## DataType *pRas = (TYPE ## DataType *) (rasBase); \ |
| Declare ## TYPE ## AlphaLoadData(DstPix) \ |
| Declare ## TYPE ## StoreVars(DstWrite) \ |
| Declare ## TYPE ## BlendFillVars(DstFill) \ |
| \ |
| Extract ## STRATEGY ## CompsAndAlphaFromArgb(fgColor, src); \ |
| if (srcA == 0) { \ |
| Set ## STRATEGY ## CompsToZero(src); \ |
| Clear ## TYPE ## BlendFillVars(DstFill, fgColor); \ |
| } else { \ |
| if (!(TYPE ## IsPremultiplied)) { \ |
| Init ## TYPE ## BlendFillVarsNonPre(DstFill, fgColor, src); \ |
| } \ |
| if (srcA != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(src, srcA, src); \ |
| } \ |
| if (TYPE ## IsPremultiplied) { \ |
| Init ## TYPE ## BlendFillVarsPre(DstFill, fgColor, src); \ |
| } \ |
| } \ |
| \ |
| Init ## TYPE ## AlphaLoadData(DstPix, pRasInfo); \ |
| Init ## TYPE ## StoreVarsY(DstWrite, pRasInfo); \ |
| \ |
| rasScan -= width * TYPE ## PixelStride; \ |
| if (pMask) { \ |
| pMask += maskOff; \ |
| maskScan -= width; \ |
| do { \ |
| jint w = width; \ |
| Init ## TYPE ## StoreVarsX(DstWrite, pRasInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(dstF) \ |
| DeclareAndInitPathAlphaFor ## STRATEGY(pathA) \ |
| \ |
| if (pathA > 0) { \ |
| if (pathA == 0xff) { \ |
| /* pathA ignored here, not promoted */ \ |
| Store ## TYPE ## BlendFill(pRas, DstFill, 0, \ |
| fgColor, src); \ |
| } else { \ |
| PromoteByteAlphaFor ## STRATEGY(pathA); \ |
| dstF = MaxValFor ## STRATEGY - pathA; \ |
| LoadAlphaFrom ## TYPE ## For ## STRATEGY(pRas, \ |
| DstPix, \ |
| res); \ |
| resA = MultiplyAlphaFor ## STRATEGY(dstF, resA); \ |
| if (!(TYPE ## IsPremultiplied)) { \ |
| dstF = resA; \ |
| } \ |
| resA += MultiplyAlphaFor ## STRATEGY(pathA, srcA); \ |
| Postload ## STRATEGY ## From ## TYPE(pRas, DstPix, \ |
| res); \ |
| MultMultAddAndStore ## STRATEGY ## Comps(res, \ |
| dstF, res, \ |
| pathA, src);\ |
| if (!(TYPE ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, \ |
| res, resA); \ |
| } \ |
| Store ## TYPE ## From ## STRATEGY ## Comps(pRas, \ |
| DstWrite, \ |
| 0, res); \ |
| } \ |
| } \ |
| pRas = PtrAddBytes(pRas, TYPE ## PixelStride); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pRas = PtrAddBytes(pRas, rasScan); \ |
| Next ## TYPE ## StoreVarsY(DstWrite); \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } while (--height > 0); \ |
| } else /* pMask == 0 */ { \ |
| do { \ |
| jint w = width; \ |
| Init ## TYPE ## StoreVarsX(DstWrite, pRasInfo); \ |
| do { \ |
| Store ## TYPE ## BlendFill(pRas, DstFill, 0, fgColor, src); \ |
| pRas = PtrAddBytes(pRas, TYPE ## PixelStride); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pRas = PtrAddBytes(pRas, rasScan); \ |
| Next ## TYPE ## StoreVarsY(DstWrite); \ |
| } while (--height > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_SRCOVER_MASKFILL(TYPE, STRATEGY) \ |
| void NAME_SRCOVER_MASKFILL(TYPE) \ |
| (void *rasBase, \ |
| jubyte *pMask, jint maskOff, jint maskScan, \ |
| jint width, jint height, \ |
| jint fgColor, \ |
| SurfaceDataRasInfo *pRasInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| DeclareAlphaVarFor ## STRATEGY(srcA) \ |
| DeclareCompVarsFor ## STRATEGY(src) \ |
| jint rasScan = pRasInfo->scanStride; \ |
| TYPE ## DataType *pRas = (TYPE ## DataType *) (rasBase); \ |
| Declare ## TYPE ## AlphaLoadData(DstPix) \ |
| Declare ## TYPE ## StoreVars(DstWrite) \ |
| \ |
| Extract ## STRATEGY ## CompsAndAlphaFromArgb(fgColor, src); \ |
| if (srcA != MaxValFor ## STRATEGY) { \ |
| if (srcA == 0) { \ |
| return; \ |
| } \ |
| MultiplyAndStore ## STRATEGY ## Comps(src, srcA, src); \ |
| } \ |
| \ |
| Init ## TYPE ## AlphaLoadData(DstPix, pRasInfo); \ |
| Init ## TYPE ## StoreVarsY(DstWrite, pRasInfo); \ |
| \ |
| rasScan -= width * TYPE ## PixelStride; \ |
| if (pMask) { \ |
| pMask += maskOff; \ |
| maskScan -= width; \ |
| do { \ |
| jint w = width; \ |
| Init ## TYPE ## StoreVarsX(DstWrite, pRasInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAndInitPathAlphaFor ## STRATEGY(pathA) \ |
| \ |
| if (pathA > 0) { \ |
| if (pathA != 0xff) { \ |
| PromoteByteAlphaFor ## STRATEGY(pathA); \ |
| resA = MultiplyAlphaFor ## STRATEGY(pathA, srcA); \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, \ |
| pathA, src); \ |
| } else { \ |
| /* pathA ignored here, not promoted */ \ |
| resA = srcA; \ |
| Store ## STRATEGY ## CompsUsingOp(res, =, src); \ |
| } \ |
| if (resA != MaxValFor ## STRATEGY) { \ |
| DeclareAndInvertAlphaVarFor ## STRATEGY(dstF, resA) \ |
| DeclareAndClearAlphaVarFor ## STRATEGY(dstA) \ |
| LoadAlphaFrom ## TYPE ## For ## STRATEGY(pRas, \ |
| DstPix, \ |
| dst); \ |
| dstA = MultiplyAlphaFor ## STRATEGY(dstF, dstA); \ |
| if (!(TYPE ## IsPremultiplied)) { \ |
| dstF = dstA; \ |
| } \ |
| resA += dstA; \ |
| if (dstF) { \ |
| DeclareCompVarsFor ## STRATEGY(tmp) \ |
| Postload ## STRATEGY ## From ## TYPE(pRas, \ |
| DstPix, \ |
| tmp); \ |
| if (dstF != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(tmp, \ |
| dstF, \ |
| tmp); \ |
| } \ |
| Store ## STRATEGY ## CompsUsingOp(res, +=, tmp); \ |
| } \ |
| } \ |
| if (!(TYPE ## IsOpaque) && \ |
| !(TYPE ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, res, resA); \ |
| } \ |
| Store ## TYPE ## From ## STRATEGY ## Comps(pRas, \ |
| DstWrite, 0, \ |
| res); \ |
| } \ |
| pRas = PtrAddBytes(pRas, TYPE ## PixelStride); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pRas = PtrAddBytes(pRas, rasScan); \ |
| Next ## TYPE ## StoreVarsY(DstWrite); \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } while (--height > 0); \ |
| } else /* pMask == 0 */ { \ |
| do { \ |
| jint w = width; \ |
| Init ## TYPE ## StoreVarsX(DstWrite, pRasInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAndInvertAlphaVarFor ## STRATEGY(dstF, srcA) \ |
| \ |
| LoadAlphaFrom ## TYPE ## For ## STRATEGY(pRas, DstPix, res);\ |
| resA = MultiplyAlphaFor ## STRATEGY(dstF, resA); \ |
| if (!(TYPE ## IsPremultiplied)) { \ |
| dstF = resA; \ |
| } \ |
| resA += srcA; \ |
| Postload ## STRATEGY ## From ## TYPE(pRas, DstPix, res); \ |
| MultiplyAddAndStore ## STRATEGY ## Comps(res, \ |
| dstF, res, src); \ |
| if (!(TYPE ## IsOpaque) && \ |
| !(TYPE ## IsPremultiplied) && resA && \ |
| resA < MaxValFor ## STRATEGY) \ |
| { \ |
| DivideAndStore ## STRATEGY ## Comps(res, res, resA); \ |
| } \ |
| Store ## TYPE ## From ## STRATEGY ## Comps(pRas, DstWrite, \ |
| 0, res); \ |
| pRas = PtrAddBytes(pRas, TYPE ## PixelStride); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| pRas = PtrAddBytes(pRas, rasScan); \ |
| Next ## TYPE ## StoreVarsY(DstWrite); \ |
| } while (--height > 0); \ |
| } \ |
| } |
| |
| |
| /* |
| * The macros defined above use the following macro definitions supplied |
| * for the various surface types to manipulate pixels and pixel data. |
| * The surface-specific macros are typically supplied by header files |
| * named after the SurfaceType name (eg. IntArgb.h, ByteGray.h, etc.). |
| * |
| * In the macro names in the following definitions, the string <stype> |
| * is used as a place holder for the SurfaceType name (eg. IntArgb). The |
| * string <strategy> is a place holder for the strategy name (eg. 4ByteArgb). |
| * The macros above access these type specific macros using the ANSI |
| * CPP token concatenation operator "##". |
| * |
| * Declare<stype>AlphaLoadData Declare the variables used when an alpha |
| * value is pre-fetched to see whether or |
| * not blending needs to occur |
| * Init<stype>AlphaLoadData Initialize the aforementioned variables |
| * LoadAlphaFrom<stype>For<strategy> Load the alpha value for the given pixel |
| * into a variable used later (the strategy |
| * type determines the bit depth of the |
| * alpha value) |
| * Postload<strategy>From<stype> Load the pixel components from the given |
| * surface type into the form required by |
| * the given strategy. Typically there will |
| * be a couple macros of this variety, one |
| * for 4ByteArgb, one for 1ByteGray, one |
| * for 1ShortGray, etc. Its code is only |
| * executed when blending needs to occur. |
| * |
| * <stype>IsPremultiplied Constant specifying whether the pixel |
| * components have been premultiplied with |
| * the alpha value |
| * Declare<stype>BlendFillVars Declare the variables used when alpha |
| * blending need not occur (mask and source |
| * pixel are opaque) |
| * Clear<stype>BlendFillVars Clear the variables used in a no-blend |
| * situation (may modify argb argument) |
| * Init<stype>BlendFillVarsNonPre Initialize the variables used for a |
| * no-blending situation (this macro is for |
| * surfaces that do not have premultiplied |
| * components) (may modify argb argument) |
| * Init<stype>BlendFillVarsPre Initialize the variables used for a |
| * no-blending situation (this macro is for |
| * surfaces that have premultiplied |
| * components) (may modify argb argument) |
| * Store<stype>BlendFill Simply store the pixel for the given |
| * surface (used when blending is |
| * unnecessary) |
| * Store<stype>From<strategy>Comps Store the pixel for the given surface |
| * type after converting it from a pixel of |
| * the given strategy |
| */ |
| |
| #endif /* AlphaMacros_h_Included */ |
