/*

 * Copyright (c) 2000, 2016, 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 LoopMacros_h_Included

#define LoopMacros_h_Included

#include "j2d_md.h"

#include "LineUtils.h"

/*

 * This file contains macros to aid in defining native graphics

 * primitive functions.

 *

 * A number of useful building block macros are defined, but the

 * vast majority of primitives are defined completely by a single

 * macro expansion which uses macro names in the argument list to

 * choose not only from a small number of strategies but also to

 * choose macro packages specific to the source and destination

 * pixel formats - greatly simplifying all aspects of creating

 * a new loop.

 *

 * See the following macros which define entire functions with

 * just one or two surface names and sometimes a strategy name:

 *     DEFINE_ISOCOPY_BLIT(ANYTYPE)

 *     DEFINE_ISOXOR_BLIT(ANYTYPE)

 *     DEFINE_CONVERT_BLIT(SRC, DST, CONV_METHOD)

 *     DEFINE_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY)

 *     DEFINE_XPAR_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY)

 *     DEFINE_XPAR_BLITBG_LUT(SRC, DST, LUT_STRATEGY)

 *     DEFINE_SOLID_FILLRECT(DST)

 *     DEFINE_SOLID_FILLSPANS(DST)

 *     DEFINE_SOLID_DRAWLINE(DST)

 *

 * Many of these loop macros take the name of a SurfaceType as

 * an argument and use the ANSI CPP token concatenation operator

 * "##" to reference macro and type definitions that are specific

 * to that type of surface.

 *

 * A description of the various surface specific macro utilities

 * that are used by these loop macros appears at the end of the

 * file.  The definitions of these surface-specific macros will

 * usually appear in a header file named after the SurfaceType

 * name (i.e. IntArgb.h, ByteGray.h, etc.).

 */

/*

 * This loop is the standard "while (--height > 0)" loop used by

 * some of the blits below.

 */

#define BlitLoopHeight(SRCTYPE, SRCPTR, SRCBASE, SRCINFO, \

                       DSTTYPE, DSTPTR, DSTBASE, DSTINFO, DSTPREFIX, \

                       HEIGHT, BODY) \

    do { \

        SRCTYPE ## DataType *SRCPTR = (SRCTYPE ## DataType *) (SRCBASE); \

        DSTTYPE ## DataType *DSTPTR = (DSTTYPE ## DataType *) (DSTBASE); \

        jint srcScan = (SRCINFO)->scanStride; \

        jint dstScan = (DSTINFO)->scanStride; \

        Init ## DSTTYPE ## StoreVarsY(DSTPREFIX, DSTINFO); \

        do { \

            BODY; \

            SRCPTR = PtrAddBytes(SRCPTR, srcScan); \

            DSTPTR = PtrAddBytes(DSTPTR, dstScan); \

            Next ## DSTTYPE ## StoreVarsY(DSTPREFIX); \

        } while (--HEIGHT > 0); \

    } while (0)

/*

 * This loop is the standard nested "while (--width/height > 0)" loop

 * used by most of the basic blits below.

 */

#define BlitLoopWidthHeight(SRCTYPE, SRCPTR, SRCBASE, SRCINFO, \

                            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; \

        Init ## DSTTYPE ## StoreVarsY(DSTPREFIX, DSTINFO); \

        srcScan -= (WIDTH) * SRCTYPE ## PixelStride; \

        dstScan -= (WIDTH) * DSTTYPE ## PixelStride; \

        do { \

            juint w = WIDTH; \

            Init ## DSTTYPE ## StoreVarsX(DSTPREFIX, DSTINFO); \

            do { \

                BODY; \

                SRCPTR = PtrAddBytes(SRCPTR, SRCTYPE ## PixelStride); \

                DSTPTR = PtrAddBytes(DSTPTR, DSTTYPE ## PixelStride); \

                Next ## DSTTYPE ## StoreVarsX(DSTPREFIX); \

            } while (--w > 0); \

            SRCPTR = PtrAddBytes(SRCPTR, srcScan); \

            DSTPTR = PtrAddBytes(DSTPTR, dstScan); \

            Next ## DSTTYPE ## StoreVarsY(DSTPREFIX); \

        } while (--HEIGHT > 0); \

    } while (0)

/*

 * This loop is the standard nested "while (--width/height > 0)" loop

 * used by most of the scaled blits below.  It calculates the proper

 * X source variable

 */

#define BlitLoopScaleWidthHeight(SRCTYPE, SRCPTR, SRCBASE, SRCINFO, \

                                 DSTTYPE, DSTPTR, DSTBASE, DSTINFO, DSTPREFIX, \

                                 XVAR, WIDTH, HEIGHT, \

                                 SXLOC, SYLOC, SXINC, SYINC, SHIFT, \

                                 BODY) \

    do { \

        SRCTYPE ## DataType *SRCPTR; \

        DSTTYPE ## DataType *DSTPTR = (DSTTYPE ## DataType *) (DSTBASE); \

        jint srcScan = (SRCINFO)->scanStride; \

        jint dstScan = (DSTINFO)->scanStride; \

        Init ## DSTTYPE ## StoreVarsY(DSTPREFIX, DSTINFO); \

        dstScan -= (WIDTH) * DSTTYPE ## PixelStride; \

        do { \

            juint w = WIDTH; \

            jint tmpsxloc = SXLOC; \

            Init ## DSTTYPE ## StoreVarsX(DSTPREFIX, DSTINFO); \

            do { \

                jint XVAR = (tmpsxloc >> SHIFT); \

                BODY; \

                DSTPTR = PtrAddBytes(DSTPTR, DSTTYPE ## PixelStride); \

                Next ## DSTTYPE ## StoreVarsX(DSTPREFIX); \

                tmpsxloc += SXINC; \

            } while (--w > 0); \

            DSTPTR = PtrAddBytes(DSTPTR, dstScan); \

            Next ## DSTTYPE ## StoreVarsY(DSTPREFIX); \

            SYLOC += SYINC; \

        } while (--HEIGHT > 0); \

    } while (0)

/*

 * This loop is a standard horizontal loop iterating with a "relative"

 * X coordinate (0 <= X < WIDTH) used primarily by the LUT conversion

 * preprocessing loops below.

 */

#define BlitLoopXRel(DSTTYPE, DSTINFO, DSTPREFIX, \

                     XVAR, WIDTH, BODY) \

    do { \

        juint XVAR = 0; \

        Init ## DSTTYPE ## StoreVarsX(DSTPREFIX, DSTINFO); \

        do { \

            BODY; \

            Next ## DSTTYPE ## StoreVarsX(DSTPREFIX); \

        } while (++XVAR < WIDTH); \

    } while (0)

/*

 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT

 * macros.  It converts from the source pixel format to the destination

 * via an intermediate "jint rgb" format.

 */

#define ConvertVia1IntRgb(SRCPTR, SRCTYPE, SRCPREFIX, \

                          DSTPTR, DSTTYPE, DSTPREFIX, \

                          SXVAR, DXVAR) \

    do { \

        int rgb; \

        Load ## SRCTYPE ## To1IntRgb(SRCPTR, SRCPREFIX, SXVAR, rgb); \

        Store ## DSTTYPE ## From1IntRgb(DSTPTR, DSTPREFIX, DXVAR, rgb); \

    } while (0)

/*

 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT

 * macros.  It converts from the source pixel format to the destination

 * via an intermediate "jint argb" format.

 */

#define ConvertVia1IntArgb(SRCPTR, SRCTYPE, SRCPREFIX, \

                           DSTPTR, DSTTYPE, DSTPREFIX, \

                           SXVAR, DXVAR) \

    do { \

        int argb; \

        Load ## SRCTYPE ## To1IntArgb(SRCPTR, SRCPREFIX, SXVAR, argb); \

        Store ## DSTTYPE ## From1IntArgb(DSTPTR, DSTPREFIX, DXVAR, argb); \

    } while (0)

/*

 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT

 * macros.  It converts from the source pixel format to the destination

 * via an intermediate set of 3 component variables "jint r, g, b".

 */

#define ConvertVia3ByteRgb(SRCPTR, SRCTYPE, SRCPREFIX, \

                           DSTPTR, DSTTYPE, DSTPREFIX, \

                           SXVAR, DXVAR) \

    do { \

        jint r, g, b; \

        Load ## SRCTYPE ## To3ByteRgb(SRCPTR, SRCPREFIX, SXVAR, r, g, b); \

        Store ## DSTTYPE ## From3ByteRgb(DSTPTR, DSTPREFIX, DXVAR, r, g, b); \

    } while (0)

/*

 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT

 * macros.  It converts from the source pixel format to the destination

 * via an intermediate set of 4 component variables "jint a, r, g, b".

 */

#define ConvertVia4ByteArgb(SRCPTR, SRCTYPE, SRCPREFIX, \

                            DSTPTR, DSTTYPE, DSTPREFIX, \

                            SXVAR, DXVAR) \

    do { \

        jint a, r, g, b; \

        Load ## SRCTYPE ## To4ByteArgb(SRCPTR, SRCPREFIX, SXVAR, a, r, g, b); \

        Store ## DSTTYPE ## From4ByteArgb(DSTPTR, DSTPREFIX, DXVAR, \

                                          a, r, g, b); \

    } while (0)

/*

 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT

 * macros.  It converts from the source pixel format to the destination

 * via an intermediate "jint gray" format.

 */

#define ConvertVia1ByteGray(SRCPTR, SRCTYPE, SRCPREFIX, \

                            DSTPTR, DSTTYPE, DSTPREFIX, \

                            SXVAR, DXVAR) \

    do { \

        jint gray; \

        Load ## SRCTYPE ## To1ByteGray(SRCPTR, SRCPREFIX, SXVAR, gray); \

        Store ## DSTTYPE ## From1ByteGray(DSTPTR, DSTPREFIX, DXVAR, gray); \

    } while (0)

/*

 * This is a "conversion strategy" for use with the DEFINE_XPAR_CONVERT_BLIT

 * macros.  It converts from the source pixel format to the destination

 * via the specified intermediate format while testing for transparent pixels.

 */

#define ConvertXparVia1IntRgb(SRCPTR, SRCTYPE, SRCPREFIX, \

                              DSTPTR, DSTTYPE, DSTPREFIX, \

                              SXVAR, DXVAR) \

    do { \

        Declare ## SRCTYPE ## Data(XparLoad); \

        Load ## SRCTYPE ## Data(SRCPTR, SRCPREFIX, SXVAR, XparLoad); \

        if (! (Is ## SRCTYPE ## DataTransparent(XparLoad))) { \

            int rgb; \

            Convert ## SRCTYPE ## DataTo1IntRgb(XparLoad, rgb); \

            Store ## DSTTYPE ## From1IntRgb(DSTPTR, DSTPREFIX, DXVAR, rgb); \

        } \

    } while (0)

/*

 * This is a "conversion strategy" for use with the DEFINE_XPAR_BLITBG

 * macros.  It converts from the source pixel format to the destination

 * via the specified intermediate format while substituting the specified

 * bgcolor for transparent pixels.

 */

#define BgCopyXparVia1IntRgb(SRCPTR, SRCTYPE, SRCPREFIX, \

                             DSTPTR, DSTTYPE, DSTPREFIX, \

                             SXVAR, DXVAR, BGPIXEL, BGPREFIX) \

    do { \

        Declare ## SRCTYPE ## Data(XparLoad); \

        Load ## SRCTYPE ## Data(SRCPTR, SRCPREFIX, SXVAR, XparLoad); \

        if (Is ## SRCTYPE ## DataTransparent(XparLoad)) { \

            Store ## DSTTYPE ## PixelData(DSTPTR, DXVAR, BGPIXEL, BGPREFIX); \

        } else { \

            int rgb; \

            Convert ## SRCTYPE ## DataTo1IntRgb(XparLoad, rgb); \

            Store ## DSTTYPE ## From1IntRgb(DSTPTR, DSTPREFIX, DXVAR, rgb); \

        } \

    } while (0)

/*

 * This macro determines whether or not the given pixel is considered

 * "transparent" for XOR purposes.  The ARGB pixel is considered

 * "transparent" if the alpha value is < 0.5.

 */

#define IsArgbTransparent(pixel) \

    (((jint) pixel) >= 0)

/*

 * This is a "conversion strategy" for use with the DEFINE_XOR_BLIT macro.  It

 * converts the source pixel to an intermediate ARGB value and then converts

 * the ARGB value to the pixel representation for the destination surface.  It

 * then XORs the srcpixel, xorpixel, and destination pixel together and stores

 * the result in the destination surface.

 */

#define XorVia1IntArgb(SRCPTR, SRCTYPE, SRCPREFIX, \

                       DSTPTR, DSTTYPE, DSTANYTYPE, \

                       XVAR, XORPIXEL, XORPREFIX, \

                       MASK, MASKPREFIX, DSTINFOPTR) \

    do { \

        jint srcpixel; \

        Declare ## DSTANYTYPE ## PixelData(pix) \

        Load ## SRCTYPE ## To1IntArgb(SRCPTR, SRCPREFIX, XVAR, srcpixel); \

 \

        if (IsArgbTransparent(srcpixel)) { \

            break; \

        } \

 \

        DSTTYPE ## PixelFromArgb(srcpixel, srcpixel, DSTINFOPTR); \

 \

        Extract ## DSTANYTYPE ## PixelData(srcpixel, pix); \

        Xor ## DSTANYTYPE ## PixelData(srcpixel, pix, DSTPTR, XVAR, \

                                       XORPIXEL, XORPREFIX, \

                                       MASK, MASKPREFIX); \

    } while (0)

/*

 * "LUT_STRATEGY" macro sets.

 *

 * There are 2 major strategies for dealing with luts and 3

 * implementations of those strategies.

 *

 * The 2 strategies are "PreProcessLut" and "ConvertOnTheFly".

 *

 * For the "PreProcessLut" strategy, the raw ARGB lut supplied

 * by the SD_LOCK_LUT flag is converted at the beginning into a

 * form that is more suited for storing into the destination

 * pixel format.  The inner loop consists of a series of table

 * lookups with very little conversion from that intermediate

 * pixel format.

 *

 * For the "ConvertOnTheFly" strategy, the raw ARGB values are

 * converted on a pixel by pixel basis in the inner loop itself.

 * This strategy is most useful for formats which tend to use

 * the ARGB color format as their pixel format also.

 *

 * Each of these strategies has 3 implementations which are needed

 * for the special cases:

 * - straight conversion (invoked from DEFINE_CONVERT_BLIT_LUT)

 * - straight conversion with transparency handling (invoked from

 *   DEFINE_XPAR_CONVERT_BLIT_LUT)

 * - straight conversion with a bgcolor for the transparent pixels

 *   (invoked from DEFINE_XPAR_BLITBG_LUT)

 */

/***

 * Start of PreProcessLut strategy macros, CONVERT_BLIT implementation.

 */

#define LutSize(TYPE) \

    (1 << TYPE ## BitsPerPixel)

#define DeclarePreProcessLutLut(SRC, DST, PIXLUT) \

    DST ## PixelType PIXLUT[LutSize(SRC)];

#define SetupPreProcessLutLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \

    do { \

        jint *srcLut = (SRCINFO)->lutBase; \

        juint lutSize = (SRCINFO)->lutSize; \

        Declare ## DST ## StoreVars(PreLut) \

        Init ## DST ## StoreVarsY(PreLut, DSTINFO); \

        if (lutSize >= LutSize(SRC)) { \

            lutSize = LutSize(SRC); \

        } else { \

            DST ## PixelType *pPIXLUT = &PIXLUT[lutSize]; \

            do { \

                Store ## DST ## From1IntArgb(pPIXLUT, PreLut, 0, 0); \

            } while (++pPIXLUT < &PIXLUT[LutSize(SRC)]); \

        } \

        BlitLoopXRel(DST, DSTINFO, PreLut, x, lutSize, \

                     do { \

                         jint argb = srcLut[x]; \

                         Store ## DST ## From1IntArgb(PIXLUT, PreLut, x, argb); \

                     } while (0)); \

    } while (0)

#define BodyPreProcessLutLut(SRCPTR, SRCTYPE, PIXLUT, \

                             DSTPTR, DSTTYPE, DSTPREFIX, \

                             SXVAR, DXVAR) \

    DSTPTR[DXVAR] = PIXLUT[SRCPTR[SXVAR]]

/*

 * End of PreProcessLut/CONVERT_BLIT macros.

 ***/

/***

 * Start of ConvertOnTheFly strategy macros, CONVERT_BLIT implementation.

 */

#define DeclareConvertOnTheFlyLut(SRC, DST, PIXLUT) \

    Declare ## SRC ## LoadVars(PIXLUT)

#define SetupConvertOnTheFlyLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \

    Init ## SRC ## LoadVars(PIXLUT, SRCINFO)

#define BodyConvertOnTheFlyLut(SRCPTR, SRCTYPE, PIXLUT, \

                               DSTPTR, DSTTYPE, DSTPREFIX, \

                               SXVAR, DXVAR) \

    ConvertVia1IntArgb(SRCPTR, SRCTYPE, PIXLUT, \

                       DSTPTR, DSTTYPE, DSTPREFIX, \

                       SXVAR, DXVAR)

/*

 * End of ConvertOnTheFly/CONVERT_BLIT macros.

 ***/

/***

 * Start of PreProcessLut strategy macros, XPAR_CONVERT_BLIT implementation.

 */

#define DeclarePreProcessLutXparLut(SRC, DST, PIXLUT) \

    jint PIXLUT[LutSize(SRC)];

#define SetupPreProcessLutXparLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \

    do { \

        jint *srcLut = (SRCINFO)->lutBase; \

        juint lutSize = (SRCINFO)->lutSize; \

        Declare ## DST ## StoreVars(PreLut) \

        Init ## DST ## StoreVarsY(PreLut, DSTINFO); \

        if (lutSize >= LutSize(SRC)) { \

            lutSize = LutSize(SRC); \

        } else { \

            jint *pPIXLUT = &PIXLUT[lutSize]; \

            do { \

                pPIXLUT[0] = DST ## XparLutEntry; \

            } while (++pPIXLUT < &PIXLUT[LutSize(SRC)]); \

        } \

        BlitLoopXRel(DST, DSTINFO, PreLut, x, lutSize, \

                     do { \

                         jint argb = srcLut[x]; \

                         if (argb < 0) { \

                             Store ## DST ## NonXparFromArgb \

                                 (PIXLUT, PreLut, x, argb); \

                         } else { \

                             PIXLUT[x] = DST ## XparLutEntry; \

                         } \

                     } while (0)); \

    } while (0)

#define BodyPreProcessLutXparLut(SRCPTR, SRCTYPE, PIXLUT, \

                                 DSTPTR, DSTTYPE, DSTPREFIX, \

                                 SXVAR, DXVAR) \

    do { \

        jint pix = PIXLUT[SRCPTR[SXVAR]]; \

        if (! DSTTYPE ## IsXparLutEntry(pix)) { \

            DSTPTR[DXVAR] = (DSTTYPE ## PixelType) pix; \

        } \

    } while (0)

/*

 * End of PreProcessLut/XPAR_CONVERT_BLIT macros.

 ***/

/***

 * Start of ConvertOnTheFly strategy macros, CONVERT_BLIT implementation.

 */

#define DeclareConvertOnTheFlyXparLut(SRC, DST, PIXLUT) \

    Declare ## SRC ## LoadVars(PIXLUT)

#define SetupConvertOnTheFlyXparLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \

    Init ## SRC ## LoadVars(PIXLUT, SRCINFO)

#define BodyConvertOnTheFlyXparLut(SRCPTR, SRCTYPE, PIXLUT, \

                                   DSTPTR, DSTTYPE, DSTPREFIX, \

                                   SXVAR, DXVAR) \

    do { \

        jint argb; \

        Load ## SRCTYPE ## To1IntArgb(SRCPTR, PIXLUT, SXVAR, argb); \

        if (argb < 0) { \

            Store ## DSTTYPE ## From1IntArgb(DSTPTR, DSTPREFIX, DXVAR, argb); \

        } \

    } while (0)

/*

 * End of ConvertOnTheFly/CONVERT_BLIT macros.

 ***/

/***

 * Start of PreProcessLut strategy macros, BLITBG implementation.

 */

#define DeclarePreProcessLutBgLut(SRC, DST, PIXLUT) \

    jint PIXLUT[LutSize(SRC)];

#define SetupPreProcessLutBgLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO, BGPIXEL) \

    do { \

        jint *srcLut = (SRCINFO)->lutBase; \

        juint lutSize = (SRCINFO)->lutSize; \

        Declare ## DST ## StoreVars(PreLut) \

        Init ## DST ## StoreVarsY(PreLut, DSTINFO); \

        if (lutSize >= LutSize(SRC)) { \

            lutSize = LutSize(SRC); \

        } else { \

            jint *pPIXLUT = &PIXLUT[lutSize]; \

            do { \

                pPIXLUT[0] = BGPIXEL; \

            } while (++pPIXLUT < &PIXLUT[LutSize(SRC)]); \

        } \

        BlitLoopXRel(DST, DSTINFO, PreLut, x, lutSize, \

                     do { \

                         jint argb = srcLut[x]; \

                         if (argb < 0) { \

                             Store ## DST ## From1IntArgb(PIXLUT, PreLut, \

                                                          x, argb); \

                         } else { \

                             PIXLUT[x] = BGPIXEL; \

                         } \

                     } while (0)); \

    } while (0)

#define BodyPreProcessLutBgLut(SRCPTR, SRCTYPE, PIXLUT, \

                               DSTPTR, DSTTYPE, DSTPREFIX, \

                               SXVAR, DXVAR, BGPIXEL) \

    do { \

        jint pix = PIXLUT[SRCPTR[SXVAR]]; \

        Store ## DSTTYPE ## Pixel(DSTPTR, DXVAR, pix); \

    } while (0)

/*

 * End of PreProcessLut/BLITBG implementation.

 ***/

/***

 * Start of ConvertOnTheFly strategy macros, BLITBG implementation.

 */

#define DeclareConvertOnTheFlyBgLut(SRC, DST, PIXLUT) \

    Declare ## SRC ## LoadVars(PIXLUT) \

    Declare ## DST ## PixelData(bgpix);

#define SetupConvertOnTheFlyBgLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO, BGPIXEL) \

    do { \

        Init ## SRC ## LoadVars(PIXLUT, SRCINFO); \