/*

 * Copyright (c) 2004, 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.

 */

#include <stdlib.h>

#include "jni_util.h"

#include "math.h"

#include "GraphicsPrimitiveMgr.h"

#include "Region.h"

#include "sun_java2d_loops_TransformHelper.h"

#include "java_awt_image_AffineTransformOp.h"

/*

 * The stub functions replace the bilinear and bicubic interpolation

 * functions with NOP versions so that the performance of the helper

 * functions that fetch the data can be more directly tested.  They

 * are not compiled or enabled by default.  Change the following

 * #undef to a #define to build the stub functions.

 *

 * When compiled, they are enabled by the environment variable TXSTUB.

 * When compiled, there is also code to disable the VIS versions and

 * use the C versions in this file in their place by defining the TXNOVIS

 * environment variable.

 */

#undef MAKE_STUBS

/* The number of IntArgbPre samples to store in the temporary buffer. */

#define LINE_SIZE       2048

/* The size of a stack allocated buffer to hold edge coordinates (see below). */

#define MAXEDGES 1024

/* Declare the software interpolation functions. */

static TransformInterpFunc BilinearInterp;

static TransformInterpFunc BicubicInterp;

#ifdef MAKE_STUBS

/* Optionally Declare the stub interpolation functions. */

static TransformInterpFunc BilinearInterpStub;

static TransformInterpFunc BicubicInterpStub;

#endif /* MAKE_STUBS */

/*

 * Initially choose the software interpolation functions.

 * These choices can be overridden by platform code that runs during the

 * primitive registration phase of initialization by storing pointers to

 * better functions in these pointers.

 * Compiling the stubs also turns on code below that can re-install the

 * software functions or stub functions on the first call to this primitive.

 */

TransformInterpFunc *pBilinearFunc = BilinearInterp;

TransformInterpFunc *pBicubicFunc = BicubicInterp;

/*

 * Fill the edge buffer with pairs of coordinates representing the maximum

 * left and right pixels of the destination surface that should be processed

 * on each scanline, clipped to the bounds parameter.

 * The number of scanlines to calculate is implied by the bounds parameter.

 * Only pixels that map back through the specified (inverse) transform to a

 * source coordinate that falls within the (0, 0, sw, sh) bounds of the

 * source image should be processed.

 * pEdgeBuf points to an array of jints that holds MAXEDGES*2 values.

 * If more storage is needed, then this function allocates a new buffer.

 * In either case, a pointer to the buffer actually used to store the

 * results is returned.

 * The caller is responsible for freeing the buffer if the return value

 * is not the same as the original pEdgeBuf passed in.

 */

static jint *

calculateEdges(jint *pEdgeBuf,

               SurfaceDataBounds *pBounds,

               TransformInfo *pItxInfo,

               jlong xbase, jlong ybase,

               juint sw, juint sh)

{

    jint *pEdges;

    jlong dxdxlong, dydxlong;

    jlong dxdylong, dydylong;

    jlong drowxlong, drowylong;

    jint dx1, dy1, dx2, dy2;

    dxdxlong = DblToLong(pItxInfo->dxdx);

    dydxlong = DblToLong(pItxInfo->dydx);

    dxdylong = DblToLong(pItxInfo->dxdy);

    dydylong = DblToLong(pItxInfo->dydy);

    dx1 = pBounds->x1;

    dy1 = pBounds->y1;

    dx2 = pBounds->x2;

    dy2 = pBounds->y2;

    if ((dy2-dy1) > MAXEDGES) {

        pEdgeBuf = malloc(2 * (dy2-dy1) * sizeof (*pEdges));

    }

    pEdges = pEdgeBuf;

    drowxlong = (dx2-dx1-1) * dxdxlong;

    drowylong = (dx2-dx1-1) * dydxlong;

    while (dy1 < dy2) {

        jlong xlong, ylong;

        dx1 = pBounds->x1;

        dx2 = pBounds->x2;

        xlong = xbase;

        ylong = ybase;

        while (dx1 < dx2 &&

               (((juint) WholeOfLong(ylong)) >= sh ||

                ((juint) WholeOfLong(xlong)) >= sw))

        {

            dx1++;

            xlong += dxdxlong;

            ylong += dydxlong;

        }

        xlong = xbase + drowxlong;

        ylong = ybase + drowylong;

        while (dx2 > dx1 &&

               (((juint) WholeOfLong(ylong)) >= sh ||

                ((juint) WholeOfLong(xlong)) >= sw))

        {

            dx2--;

            xlong -= dxdxlong;

            ylong -= dydxlong;

        }

        *pEdges++ = dx1;

        *pEdges++ = dx2;

        /* Increment to next scanline */

        xbase += dxdylong;

        ybase += dydylong;

        dy1++;

    }

    return pEdgeBuf;

}

/*

 * Class:     sun_java2d_loops_TransformHelper

 * Method:    Transform

 * Signature: (Lsun/java2d/loops/MaskBlit;Lsun/java2d/SurfaceData;Lsun/java2d/SurfaceData;Ljava/awt/Composite;Lsun/java2d/pipe/Region;Ljava/awt/geom/AffineTransform;IIIIIIIII[I)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_loops_TransformHelper_Transform

    (JNIEnv *env, jobject self,

     jobject maskblit,

     jobject srcData, jobject dstData,

     jobject comp, jobject clip,

     jobject itxform, jint txtype,

     jint sx1, jint sy1, jint sx2, jint sy2,

     jint dx1, jint dy1, jint dx2, jint dy2,

     jintArray edgeArray, jint dxoff, jint dyoff)

{

    SurfaceDataOps *srcOps;

    SurfaceDataOps *dstOps;

    SurfaceDataRasInfo srcInfo;

    SurfaceDataRasInfo dstInfo;

    NativePrimitive *pHelperPrim;

    NativePrimitive *pMaskBlitPrim;

    CompositeInfo compInfo;

    RegionData clipInfo;

    TransformInfo itxInfo;

    jint maxlinepix;

    TransformHelperFunc *pHelperFunc;

    TransformInterpFunc *pInterpFunc;

    jint edgebuf[MAXEDGES * 2];

    jint *pEdges;

    jdouble x, y;

    jlong xbase, ybase;

    jlong dxdxlong, dydxlong;

    jlong dxdylong, dydylong;

#ifdef MAKE_STUBS

    static int th_initialized;

    /* For debugging only - used to swap in alternate funcs for perf testing */

    if (!th_initialized) {

        if (getenv("TXSTUB") != 0) {

            pBilinearFunc = BilinearInterpStub;

            pBicubicFunc = BicubicInterpStub;

        } else if (getenv("TXNOVIS") != 0) {

            pBilinearFunc = BilinearInterp;

            pBicubicFunc = BicubicInterp;

        }

        th_initialized = 1;

    }

#endif /* MAKE_STUBS */

    pHelperPrim = GetNativePrim(env, self);

    if (pHelperPrim == NULL) {

        /* Should never happen... */

        return;

    }

    pMaskBlitPrim = GetNativePrim(env, maskblit);

    if (pMaskBlitPrim == NULL) {

        /* Exception was thrown by GetNativePrim */

        return;

    }

    if (pMaskBlitPrim->pCompType->getCompInfo != NULL) {

        (*pMaskBlitPrim->pCompType->getCompInfo)(env, &compInfo, comp);

    }

    if (Region_GetInfo(env, clip, &clipInfo)) {

        return;

    }

    srcOps = SurfaceData_GetOps(env, srcData);

    dstOps = SurfaceData_GetOps(env, dstData);

    if (srcOps == 0 || dstOps == 0) {

        return;

    }

    /*

     * Grab the appropriate pointer to the helper and interpolation

     * routines and calculate the maximum number of destination pixels

     * that can be processed in one intermediate buffer based on the

     * size of the buffer and the number of samples needed per pixel.

     */

    switch (txtype) {

    case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR:

        pHelperFunc = pHelperPrim->funcs.transformhelpers->nnHelper;

        pInterpFunc = NULL;

        maxlinepix = LINE_SIZE;

        break;

    case java_awt_image_AffineTransformOp_TYPE_BILINEAR:

        pHelperFunc = pHelperPrim->funcs.transformhelpers->blHelper;

        pInterpFunc = pBilinearFunc;

        maxlinepix = LINE_SIZE / 4;

        break;

    case java_awt_image_AffineTransformOp_TYPE_BICUBIC:

        pHelperFunc = pHelperPrim->funcs.transformhelpers->bcHelper;

        pInterpFunc = pBicubicFunc;

        maxlinepix = LINE_SIZE / 16;

        break;

    }

    srcInfo.bounds.x1 = sx1;

    srcInfo.bounds.y1 = sy1;

    srcInfo.bounds.x2 = sx2;

    srcInfo.bounds.y2 = sy2;

    dstInfo.bounds.x1 = dx1;

    dstInfo.bounds.y1 = dy1;

    dstInfo.bounds.x2 = dx2;

    dstInfo.bounds.y2 = dy2;

    SurfaceData_IntersectBounds(&dstInfo.bounds, &clipInfo.bounds);

    if (srcOps->Lock(env, srcOps, &srcInfo, pHelperPrim->srcflags)

        != SD_SUCCESS)

    {

        return;

    }

    if (dstOps->Lock(env, dstOps, &dstInfo, pMaskBlitPrim->dstflags)

        != SD_SUCCESS)

    {

        SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);

        return;

    }

    Region_IntersectBounds(&clipInfo, &dstInfo.bounds);

    Transform_GetInfo(env, itxform, &itxInfo);

    dxdxlong = DblToLong(itxInfo.dxdx);

    dydxlong = DblToLong(itxInfo.dydx);

    dxdylong = DblToLong(itxInfo.dxdy);

    dydylong = DblToLong(itxInfo.dydy);

    x = dxoff+dstInfo.bounds.x1+0.5; /* Center of pixel x1 */

    y = dyoff+dstInfo.bounds.y1+0.5; /* Center of pixel y1 */

    Transform_transform(&itxInfo, &x, &y);

    xbase = DblToLong(x);

    ybase = DblToLong(y);

    pEdges = calculateEdges(edgebuf, &dstInfo.bounds, &itxInfo,

                            xbase, ybase, sx2-sx1, sy2-sy1);

    if (!Region_IsEmpty(&clipInfo)) {

        srcOps->GetRasInfo(env, srcOps, &srcInfo);

        dstOps->GetRasInfo(env, dstOps, &dstInfo);

        if (srcInfo.rasBase && dstInfo.rasBase) {

            union {

                jlong align;

                jint data[LINE_SIZE];

            } rgb;

            SurfaceDataBounds span;

            Region_StartIteration(env, &clipInfo);

            while (Region_NextIteration(&clipInfo, &span)) {

                jlong rowxlong, rowylong;

                void *pDst;

                dy1 = span.y1;

                dy2 = span.y2;

                rowxlong = xbase + (dy1 - dstInfo.bounds.y1) * dxdylong;

                rowylong = ybase + (dy1 - dstInfo.bounds.y1) * dydylong;

                while (dy1 < dy2) {

                    jlong xlong, ylong;

                    /* Note - process at most one scanline at a time. */

                    dx1 = pEdges[(dy1 - dstInfo.bounds.y1) * 2];

                    dx2 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 1];

                    if (dx1 < span.x1) dx1 = span.x1;

                    if (dx2 > span.x2) dx2 = span.x2;

                    /* All pixels from dx1 to dx2 have centers in bounds */

                    while (dx1 < dx2) {

                        /* Can process at most one buffer full at a time */

                        jint numpix = dx2 - dx1;

                        if (numpix > maxlinepix) {

                            numpix = maxlinepix;

                        }

                        xlong =

                            rowxlong + ((dx1 - dstInfo.bounds.x1) * dxdxlong);

                        ylong =

                            rowylong + ((dx1 - dstInfo.bounds.x1) * dydxlong);

                        /* Get IntArgbPre pixel data from source */

                        (*pHelperFunc)(&srcInfo,

                                       rgb.data, numpix,

                                       xlong, dxdxlong,

                                       ylong, dydxlong);

                        /* Interpolate result pixels if needed */

                        if (pInterpFunc) {

                            (*pInterpFunc)(rgb.data, numpix,

                                           FractOfLong(xlong-LongOneHalf),

                                           FractOfLong(dxdxlong),

                                           FractOfLong(ylong-LongOneHalf),

                                           FractOfLong(dydxlong));

                        }

                        /* Store/Composite interpolated pixels into dest */

                        pDst = PtrCoord(dstInfo.rasBase,

                                        dx1, dstInfo.pixelStride,

                                        dy1, dstInfo.scanStride);

                        (*pMaskBlitPrim->funcs.maskblit)(pDst, rgb.data,

                                                         0, 0, 0,

                                                         numpix, 1,

                                                         &dstInfo, &srcInfo,

                                                         pMaskBlitPrim,

                                                         &compInfo);

                        /* Increment to next buffer worth of input pixels */

                        dx1 += maxlinepix;

                    }

                    /* Increment to next scanline */

                    rowxlong += dxdylong;

                    rowylong += dydylong;

                    dy1++;

                }

            }

            Region_EndIteration(env, &clipInfo);

        }

        SurfaceData_InvokeRelease(env, dstOps, &dstInfo);

        SurfaceData_InvokeRelease(env, srcOps, &srcInfo);

    }

    SurfaceData_InvokeUnlock(env, dstOps, &dstInfo);

    SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);

    if (!JNU_IsNull(env, edgeArray)) {

        (*env)->SetIntArrayRegion(env, edgeArray, 0, 1, &dstInfo.bounds.y1);

        (*env)->SetIntArrayRegion(env, edgeArray, 1, 1, &dstInfo.bounds.y2);

        (*env)->SetIntArrayRegion(env, edgeArray,

                                  2, (dstInfo.bounds.y2 - dstInfo.bounds.y1)*2,

                                  pEdges);

    }

    if (pEdges != edgebuf) {

        free(pEdges);

    }

}

#define BL_INTERP_V1_to_V2_by_F(v1, v2, f) \

    (((v1)<<8) + ((v2)-(v1))*(f))

#define BL_ACCUM(comp) \

    do { \

        jint c1 = ((jubyte *) pRGB)[comp]; \

        jint c2 = ((jubyte *) pRGB)[comp+4]; \

        jint cR = BL_INTERP_V1_to_V2_by_F(c1, c2, xfactor); \

        c1 = ((jubyte *) pRGB)[comp+8]; \

        c2 = ((jubyte *) pRGB)[comp+12]; \

        c2 = BL_INTERP_V1_to_V2_by_F(c1, c2, xfactor); \

        cR = BL_INTERP_V1_to_V2_by_F(cR, c2, yfactor); \

        ((jubyte *)pRes)[comp] = (jubyte) ((cR + (1<<15)) >> 16); \

    } while (0)

static void

BilinearInterp(jint *pRGB, jint numpix,

               jint xfract, jint dxfract,

               jint yfract, jint dyfract)

{

    jint j;

    jint *pRes = pRGB;

    for (j = 0; j < numpix; j++) {

        jint xfactor;

        jint yfactor;

        xfactor = URShift(xfract, 32-8);

        yfactor = URShift(yfract, 32-8);

        BL_ACCUM(0);

        BL_ACCUM(1);

        BL_ACCUM(2);

        BL_ACCUM(3);

        pRes++;

        pRGB += 4;

        xfract += dxfract;

        yfract += dyfract;

    }

}

#define SAT(val, max) \

    do { \

        val &= ~(val >> 31);  /* negatives become 0 */ \

        val -= max;           /* only overflows are now positive */ \

        val &= (val >> 31);   /* positives become 0 */ \

        val += max;           /* range is now [0 -> max] */ \

    } while (0)

#ifdef __sparc

/* For sparc, floating point multiplies are faster than integer */

#define BICUBIC_USE_DBL_LUT

#else

/* For x86, integer multiplies are faster than floating point */

/* Note that on x86 Linux the choice of best algorithm varies

 * depending on the compiler optimization and the processor type.

 * Currently, the sun/awt x86 Linux builds are not optimized so

 * all the variations produce mediocre performance.

 * For now we will use the choice that works best for the Windows

 * build until the (lack of) optimization issues on Linux are resolved.

 */

#define BICUBIC_USE_INT_MATH

#endif

#ifdef BICUBIC_USE_DBL_CAST

#define BC_DblToCoeff(v)        (v)

#define BC_COEFF_ONE            1.0

#define BC_TYPE                 jdouble

#define BC_V_HALF               0.5

#define BC_CompToV(v)           ((jdouble) (v))

#define BC_STORE_COMPS(pRes) \

    do { \

        jint a = (jint) accumA; \

        jint r = (jint) accumR; \

        jint g = (jint) accumG; \

        jint b = (jint) accumB; \

        SAT(a, 255); \

        SAT(r, a); \

        SAT(g, a); \

        SAT(b, a); \

        *pRes = ((a << 24) | (r << 16) | (g <<  8) | (b)); \

    } while (0)

#endif /* BICUBIC_USE_DBL_CAST */

#ifdef BICUBIC_USE_DBL_LUT

#define ItoD1(v)    ((jdouble) (v))

#define ItoD4(v)    ItoD1(v),  ItoD1(v+1),   ItoD1(v+2),   ItoD1(v+3)

#define ItoD16(v)   ItoD4(v),  ItoD4(v+4),   ItoD4(v+8),   ItoD4(v+12)

#define ItoD64(v)   ItoD16(v), ItoD16(v+16), ItoD16(v+32), ItoD16(v+48)

static jdouble ItoD_table[] = {

    ItoD64(0), ItoD64(64), ItoD64(128), ItoD64(192)

};

#define BC_DblToCoeff(v)        (v)

#define BC_COEFF_ONE            1.0

#define BC_TYPE                 jdouble

#define BC_V_HALF               0.5

#define BC_CompToV(v)           ItoD_table[v]

#define BC_STORE_COMPS(pRes) \

    do { \

        jint a = (jint) accumA; \

        jint r = (jint) accumR; \

        jint g = (jint) accumG; \

        jint b = (jint) accumB; \

        SAT(a, 255); \

        SAT(r, a); \

        SAT(g, a); \

        SAT(b, a); \

        *pRes = ((a << 24) | (r << 16) | (g <<  8) | (b)); \

    } while (0)

#endif /* BICUBIC_USE_DBL_LUT */

#ifdef BICUBIC_USE_INT_MATH

#define BC_DblToCoeff(v)        ((jint) ((v) * 256))

#define BC_COEFF_ONE            256

#define BC_TYPE                 jint

#define BC_V_HALF               (1 << 15)

#define BC_CompToV(v)           ((jint) v)

#define BC_STORE_COMPS(pRes) \

    do { \

        accumA >>= 16; \

        accumR >>= 16; \

        accumG >>= 16; \

        accumB >>= 16; \

        SAT(accumA, 255); \

        SAT(accumR, accumA); \

        SAT(accumG, accumA); \

        SAT(accumB, accumA); \

        *pRes = ((accumA << 24) | (accumR << 16) | (accumG << 8) | (accumB)); \

    } while (0)