| /* |
| * Copyright (c) 2000, 2013, 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 AnyByteBinary_h_Included |
| #define AnyByteBinary_h_Included |
| |
| #include <string.h> |
| |
| #include "AlphaMacros.h" |
| #include "GraphicsPrimitiveMgr.h" |
| #include "LoopMacros.h" |
| #include "LineUtils.h" |
| |
| /* |
| * This file contains macros that are similar to those found in LoopMacros.h |
| * and AlphaMacros.h, yet have been specialized to manipulate any one of the |
| * surfaces in the "ByteBinary" family. It also contains generalized versions |
| * of some macros that are used by the more specific ByteBinary surfaces. |
| */ |
| |
| /* REMIND: the ByteBinary store macros should probably do ordered dithering */ |
| #define DeclareByteBinaryLoadVars(PREFIX) \ |
| jint *PREFIX ## Lut; |
| |
| #define DeclareByteBinaryStoreVars(PREFIX) \ |
| unsigned char *PREFIX ## InvLut; |
| |
| #define SetByteBinaryStoreVarsYPos(PREFIX, pRasInfo, LOC) |
| #define SetByteBinaryStoreVarsXPos(PREFIX, pRasInfo, LOC) |
| |
| #define InitByteBinaryLoadVars(PREFIX, pRasInfo) \ |
| PREFIX ## Lut = (pRasInfo)->lutBase |
| |
| #define InitByteBinaryStoreVarsY(PREFIX, pRasInfo) \ |
| PREFIX ## InvLut = (pRasInfo)->invColorTable |
| |
| #define InitByteBinaryStoreVarsX(PREFIX, pRasInfo) |
| #define NextByteBinaryStoreVarsX(PREFIX) |
| #define NextByteBinaryStoreVarsY(PREFIX) |
| |
| |
| #define DeclareByteBinaryInitialLoadVars(TYPE, INFO, pRas, PREFIX, x) \ |
| int PREFIX ## adjx = (x) + (INFO)->pixelBitOffset / TYPE ## BitsPerPixel; \ |
| int PREFIX ## index = (PREFIX ## adjx) / TYPE ## PixelsPerByte; \ |
| int PREFIX ## bits = TYPE ## MaxBitOffset - \ |
| (((PREFIX ## adjx) % TYPE ## PixelsPerByte) * \ |
| TYPE ## BitsPerPixel); \ |
| int PREFIX ## bbpix = (pRas)[PREFIX ## index]; |
| |
| #define InitialLoadByteBinary(TYPE, pRas, PREFIX) \ |
| do { \ |
| if (PREFIX ## bits < 0) { \ |
| (pRas)[PREFIX ## index] = (jubyte) PREFIX ## bbpix; \ |
| PREFIX ## bbpix = (pRas)[++(PREFIX ## index)]; \ |
| PREFIX ## bits = TYPE ## MaxBitOffset; \ |
| } \ |
| } while (0) |
| |
| #define ShiftBitsByteBinary(TYPE, PREFIX) \ |
| PREFIX ## bits -= TYPE ## BitsPerPixel |
| |
| #define FinalStoreByteBinary(TYPE, pRas, PREFIX) \ |
| (pRas)[PREFIX ## index] = (jubyte) PREFIX ## bbpix |
| |
| #define CurrentPixelByteBinary(TYPE, PREFIX) \ |
| ((PREFIX ## bbpix >> PREFIX ## bits) & TYPE ## PixelMask) |
| |
| |
| #define StoreByteBinaryPixel(TYPE, pRas, x, pixel) |
| |
| #define StoreByteBinaryPixelData(TYPE, pPix, x, pixel, PREFIX) \ |
| do { \ |
| PREFIX ## bbpix &= ~(TYPE ## PixelMask << PREFIX ## bits); \ |
| PREFIX ## bbpix |= (pixel << PREFIX ## bits); \ |
| } while (0) |
| |
| #define ByteBinaryPixelFromArgb(TYPE, pixel, rgb, pRasInfo) \ |
| do { \ |
| jint r, g, b; \ |
| ExtractIntDcmComponentsX123(rgb, r, g, b); \ |
| (pixel) = SurfaceData_InvColorMap((pRasInfo)->invColorTable, \ |
| r, g, b); \ |
| } while (0) |
| |
| #define XorByteBinaryPixelData(TYPE, pDst, x, PREFIX, \ |
| srcpixel, xorpixel, mask) \ |
| PREFIX ## bbpix ^= ((((srcpixel) ^ (xorpixel)) & TYPE ## PixelMask) \ |
| << PREFIX ## bits) |
| |
| |
| #define LoadByteBinaryTo1IntRgb(TYPE, pRas, PREFIX, x, rgb) \ |
| (rgb) = PREFIX ## Lut[CurrentPixelByteBinary(TYPE, PREFIX)] |
| |
| #define LoadByteBinaryTo1IntArgb(TYPE, pRas, PREFIX, x, argb) \ |
| (argb) = PREFIX ## Lut[CurrentPixelByteBinary(TYPE, PREFIX)] |
| |
| #define LoadByteBinaryTo3ByteRgb(TYPE, pRas, PREFIX, x, r, g, b) \ |
| do { \ |
| jint rgb = PREFIX ## Lut[CurrentPixelByteBinary(TYPE, PREFIX)]; \ |
| ExtractIntDcmComponentsX123(rgb, r, g, b); \ |
| } while (0) |
| |
| #define LoadByteBinaryTo4ByteArgb(TYPE, pRas, PREFIX, x, a, r, g, b) \ |
| do { \ |
| jint argb = PREFIX ## Lut[CurrentPixelByteBinary(TYPE, PREFIX)]; \ |
| ExtractIntDcmComponents1234(argb, a, r, g, b); \ |
| } while (0) |
| |
| #define StoreByteBinaryFrom1IntRgb(TYPE, pRas, PREFIX, x, rgb) \ |
| do { \ |
| int r, g, b; \ |
| ExtractIntDcmComponentsX123(rgb, r, g, b); \ |
| StoreByteBinaryFrom3ByteRgb(TYPE, pRas, PREFIX, x, r, g, b); \ |
| } while (0) |
| |
| #define StoreByteBinaryFrom1IntArgb(TYPE, pRas, PREFIX, x, argb) \ |
| StoreByteBinaryFrom1IntRgb(TYPE, pRas, PREFIX, x, argb) |
| |
| #define StoreByteBinaryFrom3ByteRgb(TYPE, pRas, PREFIX, x, r, g, b) \ |
| StoreByteBinaryPixelData(TYPE, pRas, x, \ |
| SurfaceData_InvColorMap(PREFIX ## InvLut, \ |
| r, g, b), \ |
| PREFIX) |
| |
| #define StoreByteBinaryFrom4ByteArgb(TYPE, pRas, PREFIX, x, a, r, g, b) \ |
| StoreByteBinaryFrom3ByteRgb(TYPE, pRas, PREFIX, x, r, g, b) |
| |
| |
| #define DeclareByteBinaryAlphaLoadData(TYPE, PREFIX) \ |
| jint *PREFIX ## Lut; \ |
| jint PREFIX ## rgb; |
| |
| #define InitByteBinaryAlphaLoadData(TYPE, PREFIX, pRasInfo) \ |
| do { \ |
| PREFIX ## Lut = (pRasInfo)->lutBase; \ |
| PREFIX ## rgb = 0; \ |
| } while (0) |
| |
| #define LoadAlphaFromByteBinaryFor4ByteArgb(TYPE, pRas, PREFIX, COMP_PREFIX) \ |
| do { \ |
| PREFIX ## rgb = PREFIX ## Lut[CurrentPixelByteBinary(TYPE, PREFIX)]; \ |
| COMP_PREFIX ## A = ((juint) PREFIX ## rgb) >> 24; \ |
| } while (0) |
| |
| #define Postload4ByteArgbFromByteBinary(TYPE, pRas, PREFIX, COMP_PREFIX) \ |
| do { \ |
| COMP_PREFIX ## R = (PREFIX ## rgb >> 16) & 0xff; \ |
| COMP_PREFIX ## G = (PREFIX ## rgb >> 8) & 0xff; \ |
| COMP_PREFIX ## B = (PREFIX ## rgb >> 0) & 0xff; \ |
| } while (0) |
| |
| |
| #define ByteBinaryIsPremultiplied 0 |
| |
| #define StoreByteBinaryFrom4ByteArgbComps(TYPE, pRas, PREFIX, x, COMP_PREFIX)\ |
| StoreByteBinaryFrom4ByteArgb(TYPE, pRas, PREFIX, x, \ |
| COMP_PREFIX ## A, COMP_PREFIX ## R, \ |
| COMP_PREFIX ## G, COMP_PREFIX ## B) |
| |
| |
| |
| |
| #define BBBlitLoopWidthHeight(SRCTYPE, SRCPTR, SRCBASE, SRCINFO, SRCPREFIX, \ |
| DSTTYPE, DSTPTR, DSTBASE, DSTINFO, DSTPREFIX, \ |
| WIDTH, HEIGHT, BODY) \ |
| do { \ |
| SRCTYPE ## DataType *SRCPTR = (SRCTYPE ## DataType *) (SRCBASE); \ |
| DSTTYPE ## DataType *DSTPTR = (DSTTYPE ## DataType *) (DSTBASE); \ |
| jint srcScan = (SRCINFO)->scanStride; \ |
| jint dstScan = (DSTINFO)->scanStride; \ |
| jint srcx1 = (SRCINFO)->bounds.x1; \ |
| jint dstx1 = (DSTINFO)->bounds.x1; \ |
| Init ## DSTTYPE ## StoreVarsY(DSTPREFIX, DSTINFO); \ |
| srcScan -= (WIDTH) * SRCTYPE ## PixelStride; \ |
| dstScan -= (WIDTH) * DSTTYPE ## PixelStride; \ |
| do { \ |
| Declare ## SRCTYPE ## InitialLoadVars(SRCINFO, SRCPTR, SRCPREFIX, \ |
| srcx1) \ |
| Declare ## DSTTYPE ## InitialLoadVars(DSTINFO, DSTPTR, DSTPREFIX, \ |
| dstx1) \ |
| juint w = WIDTH; \ |
| Init ## DSTTYPE ## StoreVarsX(DSTPREFIX, DSTINFO); \ |
| do { \ |
| InitialLoad ## SRCTYPE(SRCPTR, SRCPREFIX); \ |
| InitialLoad ## DSTTYPE(DSTPTR, DSTPREFIX); \ |
| BODY; \ |
| ShiftBits ## SRCTYPE(SRCPREFIX); \ |
| ShiftBits ## DSTTYPE(DSTPREFIX); \ |
| SRCPTR = PtrAddBytes(SRCPTR, SRCTYPE ## PixelStride); \ |
| DSTPTR = PtrAddBytes(DSTPTR, DSTTYPE ## PixelStride); \ |
| Next ## DSTTYPE ## StoreVarsX(DSTPREFIX); \ |
| } while (--w > 0); \ |
| FinalStore ## DSTTYPE(DSTPTR, DSTPREFIX); \ |
| SRCPTR = PtrAddBytes(SRCPTR, srcScan); \ |
| DSTPTR = PtrAddBytes(DSTPTR, dstScan); \ |
| Next ## DSTTYPE ## StoreVarsY(DSTPREFIX); \ |
| } while (--HEIGHT > 0); \ |
| } while (0) |
| |
| #define BBXorVia1IntArgb(SRCPTR, SRCTYPE, SRCPREFIX, \ |
| DSTPTR, DSTTYPE, DSTPREFIX, \ |
| XVAR, XORPIXEL, MASK, DSTINFOPTR) \ |
| do { \ |
| jint srcpixel; \ |
| Load ## SRCTYPE ## To1IntArgb(SRCPTR, SRCPREFIX, XVAR, srcpixel); \ |
| \ |
| if (IsArgbTransparent(srcpixel)) { \ |
| break; \ |
| } \ |
| \ |
| DSTTYPE ## PixelFromArgb(srcpixel, srcpixel, DSTINFOPTR); \ |
| \ |
| Xor ## DSTTYPE ## PixelData(DSTPTR, XVAR, DSTPREFIX, srcpixel, \ |
| XORPIXEL, MASK); \ |
| } while (0) |
| |
| #define DEFINE_BYTE_BINARY_CONVERT_BLIT(SRC, DST, STRATEGY) \ |
| void NAME_CONVERT_BLIT(SRC, DST)(void *srcBase, void *dstBase, \ |
| juint width, juint height, \ |
| SurfaceDataRasInfo *pSrcInfo, \ |
| SurfaceDataRasInfo *pDstInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| Declare ## SRC ## LoadVars(SrcRead) \ |
| Declare ## DST ## StoreVars(DstWrite) \ |
| \ |
| Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \ |
| BBBlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, SrcRead, \ |
| DST, pDst, dstBase, pDstInfo, DstWrite, \ |
| width, height, \ |
| ConvertVia ## STRATEGY(pSrc, SRC, SrcRead, \ |
| pDst, DST, DstWrite, \ |
| 0, 0)); \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_XOR_BLIT(SRC, DST) \ |
| void NAME_XOR_BLIT(SRC, DST)(void *srcBase, void *dstBase, \ |
| juint width, juint height, \ |
| SurfaceDataRasInfo *pSrcInfo, \ |
| SurfaceDataRasInfo *pDstInfo, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| jint xorpixel = pCompInfo->details.xorPixel; \ |
| juint alphamask = pCompInfo->alphaMask; \ |
| Declare ## SRC ## LoadVars(SrcRead) \ |
| Declare ## DST ## StoreVars(DstWrite) \ |
| \ |
| Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \ |
| BBBlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, SrcRead, \ |
| DST, pDst, dstBase, pDstInfo, DstWrite, \ |
| width, height, \ |
| BBXorVia1IntArgb(pSrc, SRC, SrcRead, \ |
| pDst, DST, DstWrite, \ |
| 0, xorpixel, \ |
| alphamask, pDstInfo)); \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_SOLID_FILLRECT(DST) \ |
| void NAME_SOLID_FILLRECT(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| jint lox, jint loy, \ |
| jint hix, jint hiy, \ |
| jint pixel, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| DST ## DataType *pPix; \ |
| jint scan = pRasInfo->scanStride; \ |
| juint height = hiy - loy; \ |
| juint width = hix - lox; \ |
| \ |
| pPix = PtrCoord(pRasInfo->rasBase, lox, DST ## PixelStride, loy, scan); \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, lox) \ |
| jint w = width; \ |
| do { \ |
| InitialLoad ## DST(pPix, DstPix); \ |
| Store ## DST ## PixelData(pPix, 0, pixel, DstPix); \ |
| ShiftBits ## DST(DstPix); \ |
| } while (--w > 0); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| pPix = PtrAddBytes(pPix, scan); \ |
| } while (--height > 0); \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_SOLID_FILLSPANS(DST) \ |
| void NAME_SOLID_FILLSPANS(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| SpanIteratorFuncs *pSpanFuncs, void *siData, \ |
| jint pixel, NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| void *pBase = pRasInfo->rasBase; \ |
| jint scan = pRasInfo->scanStride; \ |
| jint bbox[4]; \ |
| \ |
| while ((*pSpanFuncs->nextSpan)(siData, bbox)) { \ |
| jint x = bbox[0]; \ |
| jint y = bbox[1]; \ |
| juint w = bbox[2] - x; \ |
| juint h = bbox[3] - y; \ |
| DST ## DataType *pPix = PtrCoord(pBase, \ |
| x, DST ## PixelStride, \ |
| y, scan); \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, x) \ |
| jint relx = w; \ |
| do { \ |
| InitialLoad ## DST(pPix, DstPix); \ |
| Store ## DST ## PixelData(pPix, 0, pixel, DstPix); \ |
| ShiftBits ## DST(DstPix); \ |
| } while (--relx > 0); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| pPix = PtrAddBytes(pPix, scan); \ |
| } while (--h > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_SOLID_DRAWLINE(DST) \ |
| void NAME_SOLID_DRAWLINE(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| jint x1, jint y1, jint pixel, \ |
| jint steps, jint error, \ |
| jint bumpmajormask, jint errmajor, \ |
| jint bumpminormask, jint errminor, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| jint scan = pRasInfo->scanStride; \ |
| DST ## DataType *pPix = PtrCoord(pRasInfo->rasBase, \ |
| x1, DST ## PixelStride, \ |
| y1, scan); \ |
| DeclareBumps(bumpmajor, bumpminor) \ |
| \ |
| scan *= DST ## PixelsPerByte; \ |
| InitBumps(bumpmajor, bumpminor, bumpmajormask, bumpminormask, 1, scan); \ |
| if (errmajor == 0) { \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, x1) \ |
| Store ## DST ## PixelData(pPix, 0, pixel, DstPix); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| x1 += bumpmajor; \ |
| } while (--steps > 0); \ |
| } else { \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, x1) \ |
| Store ## DST ## PixelData(pPix, 0, pixel, DstPix); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| if (error < 0) { \ |
| x1 += bumpmajor; \ |
| error += errmajor; \ |
| } else { \ |
| x1 += bumpminor; \ |
| error -= errminor; \ |
| } \ |
| } while (--steps > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_XOR_FILLRECT(DST) \ |
| void NAME_XOR_FILLRECT(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| jint lox, jint loy, \ |
| jint hix, jint hiy, \ |
| jint pixel, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| jint xorpixel = pCompInfo->details.xorPixel; \ |
| juint alphamask = pCompInfo->alphaMask; \ |
| DST ## DataType *pPix; \ |
| jint scan = pRasInfo->scanStride; \ |
| juint height = hiy - loy; \ |
| juint width = hix - lox; \ |
| \ |
| pPix = PtrCoord(pRasInfo->rasBase, lox, DST ## PixelStride, loy, scan); \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, lox) \ |
| jint w = width; \ |
| do { \ |
| InitialLoad ## DST(pPix, DstPix); \ |
| Xor ## DST ## PixelData(pPix, 0, DstPix, \ |
| pixel, xorpixel, alphamask); \ |
| ShiftBits ## DST(DstPix); \ |
| } while (--w > 0); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| pPix = PtrAddBytes(pPix, scan); \ |
| } while (--height > 0); \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_XOR_FILLSPANS(DST) \ |
| void NAME_XOR_FILLSPANS(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| SpanIteratorFuncs *pSpanFuncs, \ |
| void *siData, jint pixel, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| void *pBase = pRasInfo->rasBase; \ |
| jint xorpixel = pCompInfo->details.xorPixel; \ |
| juint alphamask = pCompInfo->alphaMask; \ |
| jint scan = pRasInfo->scanStride; \ |
| jint bbox[4]; \ |
| \ |
| while ((*pSpanFuncs->nextSpan)(siData, bbox)) { \ |
| jint x = bbox[0]; \ |
| jint y = bbox[1]; \ |
| juint w = bbox[2] - x; \ |
| juint h = bbox[3] - y; \ |
| DST ## DataType *pPix = PtrCoord(pBase, \ |
| x, DST ## PixelStride, \ |
| y, scan); \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, x) \ |
| jint relx = w; \ |
| do { \ |
| InitialLoad ## DST(pPix, DstPix); \ |
| Xor ## DST ## PixelData(pPix, 0, DstPix, \ |
| pixel, xorpixel, alphamask); \ |
| ShiftBits ## DST(DstPix); \ |
| } while (--relx > 0); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| pPix = PtrAddBytes(pPix, scan); \ |
| } while (--h > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_XOR_DRAWLINE(DST) \ |
| void NAME_XOR_DRAWLINE(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| jint x1, jint y1, jint pixel, \ |
| jint steps, jint error, \ |
| jint bumpmajormask, jint errmajor, \ |
| jint bumpminormask, jint errminor, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| jint xorpixel = pCompInfo->details.xorPixel; \ |
| juint alphamask = pCompInfo->alphaMask; \ |
| jint scan = pRasInfo->scanStride; \ |
| DST ## DataType *pPix = PtrCoord(pRasInfo->rasBase, \ |
| x1, DST ## PixelStride, \ |
| y1, scan); \ |
| DeclareBumps(bumpmajor, bumpminor) \ |
| \ |
| scan *= DST ## PixelsPerByte; \ |
| InitBumps(bumpmajor, bumpminor, bumpmajormask, bumpminormask, 1, scan); \ |
| \ |
| if (errmajor == 0) { \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, x1) \ |
| Xor ## DST ## PixelData(pPix, 0, DstPix, \ |
| pixel, xorpixel, alphamask); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| x1 += bumpmajor; \ |
| } while (--steps > 0); \ |
| } else { \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, x1) \ |
| Xor ## DST ## PixelData(pPix, 0, DstPix, \ |
| pixel, xorpixel, alphamask); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| if (error < 0) { \ |
| x1 += bumpmajor; \ |
| error += errmajor; \ |
| } else { \ |
| x1 += bumpminor; \ |
| error -= errminor; \ |
| } \ |
| } while (--steps > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_SOLID_DRAWGLYPHLIST(DST) \ |
| void NAME_SOLID_DRAWGLYPHLIST(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| ImageRef *glyphs, \ |
| jint totalGlyphs, jint fgpixel, \ |
| jint argbcolor, \ |
| jint clipLeft, jint clipTop, \ |
| jint clipRight, jint clipBottom, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| jint glyphCounter; \ |
| jint scan = pRasInfo->scanStride; \ |
| DST ## DataType *pPix; \ |
| \ |
| for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) { \ |
| DeclareDrawGlyphListClipVars(pixels, rowBytes, width, height, \ |
| left, top, right, bottom) \ |
| ClipDrawGlyphList(DST, pixels, 1, rowBytes, width, height, \ |
| left, top, right, bottom, \ |
| clipLeft, clipTop, clipRight, clipBottom, \ |
| glyphs, glyphCounter, continue) \ |
| pPix = PtrCoord(pRasInfo->rasBase,left,DST ## PixelStride,top,scan); \ |
| \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, left) \ |
| jint x = 0; \ |
| do { \ |
| InitialLoad ## DST(pPix, DstPix); \ |
| if (pixels[x]) { \ |
| Store ## DST ## PixelData(pPix, 0, fgpixel, DstPix); \ |
| } \ |
| ShiftBits ## DST(DstPix); \ |
| } while (++x < width); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| pPix = PtrAddBytes(pPix, scan); \ |
| pixels += rowBytes; \ |
| } while (--height > 0); \ |
| } \ |
| } |
| |
| /* |
| * REMIND: we shouldn't be attempting to do antialiased text for the |
| * ByteBinary surfaces in the first place |
| */ |
| #define DEFINE_BYTE_BINARY_SOLID_DRAWGLYPHLISTAA(DST, STRATEGY) \ |
| void NAME_SOLID_DRAWGLYPHLISTAA(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| ImageRef *glyphs, \ |
| jint totalGlyphs, jint fgpixel, \ |
| jint argbcolor, \ |
| jint clipLeft, jint clipTop, \ |
| jint clipRight, jint clipBottom, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| jint glyphCounter; \ |
| jint scan = pRasInfo->scanStride; \ |
| DST ## DataType *pPix; \ |
| DeclareAlphaVarFor ## STRATEGY(srcA) \ |
| DeclareCompVarsFor ## STRATEGY(src) \ |
| \ |
| Declare ## DST ## LoadVars(pix) \ |
| Declare ## DST ## StoreVars(pix) \ |
| \ |
| Init ## DST ## LoadVars(pix, pRasInfo); \ |
| Init ## DST ## StoreVarsY(pix, pRasInfo); \ |
| Init ## DST ## StoreVarsX(pix, pRasInfo); \ |
| Extract ## STRATEGY ## CompsAndAlphaFromArgb(argbcolor, src); \ |
| \ |
| for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) { \ |
| DeclareDrawGlyphListClipVars(pixels, rowBytes, width, height, \ |
| left, top, right, bottom) \ |
| ClipDrawGlyphList(DST, pixels, 1, rowBytes, width, height, \ |
| left, top, right, bottom, \ |
| clipLeft, clipTop, clipRight, clipBottom, \ |
| glyphs, glyphCounter, continue) \ |
| pPix = PtrCoord(pRasInfo->rasBase,left,DST ## PixelStride,top,scan); \ |
| \ |
| Set ## DST ## StoreVarsYPos(pix, pRasInfo, top); \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, pix, left) \ |
| int x = 0; \ |
| Set ## DST ## StoreVarsXPos(pix, pRasInfo, left); \ |
| do { \ |
| InitialLoad ## DST(pPix, pix); \ |
| GlyphListAABlend ## STRATEGY(DST, pixels, x, pPix, \ |
| fgpixel, pix, src); \ |
| ShiftBits ## DST(pix); \ |
| Next ## DST ## StoreVarsX(pix); \ |
| } while (++x < width); \ |
| FinalStore ## DST(pPix, pix); \ |
| pPix = PtrAddBytes(pPix, scan); \ |
| pixels += rowBytes; \ |
| Next ## DST ## StoreVarsY(pix); \ |
| } while (--height > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_XOR_DRAWGLYPHLIST(DST) \ |
| void NAME_XOR_DRAWGLYPHLIST(DST)(SurfaceDataRasInfo *pRasInfo, \ |
| ImageRef *glyphs, \ |
| jint totalGlyphs, jint fgpixel, \ |
| jint argbcolor, \ |
| jint clipLeft, jint clipTop, \ |
| jint clipRight, jint clipBottom, \ |
| NativePrimitive *pPrim, \ |
| CompositeInfo *pCompInfo) \ |
| { \ |
| jint glyphCounter; \ |
| jint scan = pRasInfo->scanStride; \ |
| jint xorpixel = pCompInfo->details.xorPixel; \ |
| juint alphamask = pCompInfo->alphaMask; \ |
| DST ## DataType *pPix; \ |
| \ |
| for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) { \ |
| DeclareDrawGlyphListClipVars(pixels, rowBytes, width, height, \ |
| left, top, right, bottom) \ |
| ClipDrawGlyphList(DST, pixels, 1, rowBytes, width, height, \ |
| left, top, right, bottom, \ |
| clipLeft, clipTop, clipRight, clipBottom, \ |
| glyphs, glyphCounter, continue) \ |
| pPix = PtrCoord(pRasInfo->rasBase,left,DST ## PixelStride,top,scan); \ |
| \ |
| do { \ |
| Declare ## DST ## InitialLoadVars(pRasInfo, pPix, DstPix, left) \ |
| jint x = 0; \ |
| do { \ |
| InitialLoad ## DST(pPix, DstPix); \ |
| if (pixels[x]) { \ |
| Xor ## DST ## PixelData(pPix, 0, DstPix, \ |
| fgpixel, xorpixel, alphamask); \ |
| } \ |
| ShiftBits ## DST(DstPix); \ |
| } while (++x < width); \ |
| FinalStore ## DST(pPix, DstPix); \ |
| pPix = PtrAddBytes(pPix, scan); \ |
| pixels += rowBytes; \ |
| } while (--height > 0); \ |
| } \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_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; \ |
| jint srcx1 = pSrcInfo->bounds.x1; \ |
| jint dstx1 = pDstInfo->bounds.x1; \ |
| SRC ## DataType *pSrc = (SRC ## DataType *) (srcBase); \ |
| DST ## DataType *pDst = (DST ## DataType *) (dstBase); \ |
| Declare ## SRC ## AlphaLoadData(SrcRead) \ |
| Declare ## DST ## AlphaLoadData(DstWrite) \ |
| 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(SrcRead, pSrcInfo); \ |
| Init ## DST ## AlphaLoadData(DstWrite, pDstInfo); \ |
| srcScan -= width * SRC ## PixelStride; \ |
| dstScan -= width * DST ## PixelStride; \ |
| maskScan -= width; \ |
| if (pMask) { \ |
| pMask += maskOff; \ |
| } \ |
| \ |
| Init ## DST ## StoreVarsY(DstWrite, pDstInfo); \ |
| do { \ |
| Declare ## SRC ## InitialLoadVars(pSrcInfo, pSrc, SrcRead, srcx1) \ |
| Declare ## DST ## InitialLoadVars(pDstInfo, pDst, DstWrite, dstx1) \ |
| jint w = width; \ |
| Init ## DST ## StoreVarsX(DstWrite, pDstInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| DeclareAlphaVarFor ## STRATEGY(dstF) \ |
| \ |
| InitialLoad ## SRC(pSrc, SrcRead); \ |
| InitialLoad ## DST(pDst, DstWrite); \ |
| if (pMask) { \ |
| pathA = *pMask++; \ |
| if (!pathA) { \ |
| ShiftBits ## SRC(SrcRead); \ |
| ShiftBits ## DST(DstWrite); \ |
| 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,SrcRead,src); \ |
| srcA = MultiplyAlphaFor ## STRATEGY(extraA, srcA); \ |
| } \ |
| if (loaddst) { \ |
| LoadAlphaFrom ## DST ## For ## STRATEGY(pDst,DstWrite,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, SrcRead, res); \ |
| if (srcF != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(res, \ |
| srcF, res); \ |
| } \ |
| } else { \ |
| Set ## STRATEGY ## CompsToZero(res); \ |
| } \ |
| } else { \ |
| if (dstF == MaxValFor ## STRATEGY) { \ |
| ShiftBits ## SRC(SrcRead); \ |
| ShiftBits ## DST(DstWrite); \ |
| 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,DstWrite,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); \ |
| ShiftBits ## SRC(SrcRead); \ |
| ShiftBits ## DST(DstWrite); \ |
| pSrc = PtrAddBytes(pSrc, SRC ## PixelStride); \ |
| pDst = PtrAddBytes(pDst, DST ## PixelStride); \ |
| Next ## DST ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| FinalStore ## DST(pDst, DstWrite); \ |
| pSrc = PtrAddBytes(pSrc, srcScan); \ |
| pDst = PtrAddBytes(pDst, dstScan); \ |
| Next ## DST ## StoreVarsY(DstWrite); \ |
| if (pMask) { \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } \ |
| } while (--height > 0); \ |
| } |
| |
| #define DEFINE_BYTE_BINARY_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; \ |
| jint x1 = pRasInfo->bounds.x1; \ |
| TYPE ## DataType *pRas = (TYPE ## DataType *) (rasBase); \ |
| Declare ## TYPE ## AlphaLoadData(DstWrite) \ |
| 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(DstWrite, pRasInfo); \ |
| maskScan -= width; \ |
| if (pMask) { \ |
| pMask += maskOff; \ |
| } \ |
| \ |
| Init ## TYPE ## StoreVarsY(DstWrite, pRasInfo); \ |
| do { \ |
| Declare ## TYPE ## InitialLoadVars(pRasInfo, pRas, DstWrite, x1) \ |
| jint w = width; \ |
| Init ## TYPE ## StoreVarsX(DstWrite, pRasInfo); \ |
| do { \ |
| DeclareAlphaVarFor ## STRATEGY(resA) \ |
| DeclareCompVarsFor ## STRATEGY(res) \ |
| DeclareAlphaVarFor ## STRATEGY(srcF) \ |
| \ |
| InitialLoad ## TYPE(pRas, DstWrite); \ |
| if (pMask) { \ |
| pathA = *pMask++; \ |
| if (!pathA) { \ |
| ShiftBits ## TYPE(DstWrite); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| continue; \ |
| } \ |
| PromoteByteAlphaFor ## STRATEGY(pathA); \ |
| dstF = dstFbase; \ |
| } \ |
| if (loaddst) { \ |
| LoadAlphaFrom ## TYPE ## For ## STRATEGY(pRas,DstWrite,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) { \ |
| ShiftBits ## TYPE(DstWrite); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| continue; \ |
| } \ |
| resA = 0; \ |
| Set ## STRATEGY ## CompsToZero(res); \ |
| } \ |
| if (dstF) { \ |
| dstA = MultiplyAlphaFor ## STRATEGY(dstF, dstA); \ |
| if (!(TYPE ## IsPremultiplied)) { \ |
| dstF = dstA; \ |
| } \ |
| resA += dstA; \ |
| if (dstF) { \ |
| DeclareCompVarsFor ## STRATEGY(tmp) \ |
| /* assert(loaddst); */ \ |
| Postload ## STRATEGY ## From ## TYPE(pRas,DstWrite,tmp); \ |
| if (dstF != MaxValFor ## STRATEGY) { \ |
| MultiplyAndStore ## STRATEGY ## Comps(tmp, \ |
| dstF, 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); \ |
| ShiftBits ## TYPE(DstWrite); \ |
| Next ## TYPE ## StoreVarsX(DstWrite); \ |
| } while (--w > 0); \ |
| FinalStore ## TYPE(pRas, DstWrite); \ |
| pRas = PtrAddBytes(pRas, rasScan); \ |
| Next ## TYPE ## StoreVarsY(DstWrite); \ |
| if (pMask) { \ |
| pMask = PtrAddBytes(pMask, maskScan); \ |
| } \ |
| } while (--height > 0); \ |
| } |
| |
| |
| /* |
| * The macros defined above use the following macro definitions supplied |
| * for the various ByteBinary-specific surface types to manipulate pixel data. |
| * |
| * In the macro names in the following definitions, the string <stype> |
| * is used as a place holder for the SurfaceType name (eg. ByteBinary2Bit). |
| * The macros above access these type specific macros using the ANSI |
| * CPP token concatenation operator "##". |
| * |
| * Declare<stype>InitialLoadVars Declare and initialize the variables used |
| * for managing byte/bit offsets |
| * InitialLoad<stype> Store the current byte, fetch the next |
| * byte, and reset the bit offset |
| * ShiftBits<stype> Advance to the next pixel by adjusting |
| * the bit offset (1, 2, or 4 bits) |
| * FinalStore<stype> Store the current byte |
| * CurrentPixel<stype> Represents the current pixel by shifting |
| * the value with the current bit offset and |
| * then masking the value to either 1, 2, or |
| * 4 bits |
| */ |
| |
| #endif /* AnyByteBinary_h_Included */ |
