AlphaMacros.h

/*
 * 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 */