/*

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

/*

 * The dxydxy parameters of the inverse transform determine how

 * quickly we step through the source image.  For tiny scale

 * factors (on the order of 1E-16 or so) the stepping distances

 * are huge.  The image has been scaled so small that stepping

 * a single pixel in device space moves the sampling point by

 * billions (or more) pixels in the source image space.  These

 * huge stepping values can overflow the whole part of the longs

 * we use for the fixed point stepping equations and so we need

 * a more robust solution.  We could simply iterate over every

 * device pixel, use the inverse transform to transform it back

 * into the source image coordinate system and then test it for

 * being in range and sample pixel-by-pixel, but that is quite

 * a bit more expensive.  Fortunately, if the scale factors are

 * so tiny that we overflow our long values then the number of

 * pixels we are planning to visit should be very tiny.  The only

 * exception to that rule is if the scale factor along one

 * dimension is tiny (creating the huge stepping values), and

 * the scale factor along the other dimension is fairly regular

 * or an up-scale.  In that case we have a lot of pixels along

 * the direction of the larger axis to sample, but few along the

 * smaller axis.  Though, pessimally, with an added shear factor

 * such a linearly tiny image could have bounds that cover a large

 * number of pixels.  Such odd transformations should be very

 * rare and the absolute limit on calculations would involve a

 * single reverse transform of every pixel in the output image

 * which is not fast, but it should not cause an undue stall

 * of the rendering software.

 *

 * The specific test we will use is to calculate the inverse

 * transformed values of every corner of the destination bounds

 * (in order to be user-clip independent) and if we can

 * perform a fixed-point-long inverse transform of all of

 * those points without overflowing we will use the fast

 * fixed point algorithm.  Otherwise we will use the safe

 * per-pixel transform algorithm.

 * The 4 corners are 0,0, 0,dsth, dstw,0, dstw,dsth

 * Transformed they are:

 *     tx,               ty

 *     tx       +dxdy*H, ty       +dydy*H

 *     tx+dxdx*W,        ty+dydx*W

 *     tx+dxdx*W+dxdy*H, ty+dydx*W+dydy*H

 */

/* We reject coordinates not less than 1<<30 so that the distance between */

/* any 2 of them is less than 1<<31 which would overflow into the sign */

/* bit of a signed long value used to represent fixed point coordinates. */

#define TX_FIXED_UNSAFE(v)  (fabs(v) >= (1<<30))

static jboolean

checkOverflow(jint dxoff, jint dyoff,

              SurfaceDataBounds *pBounds,

              TransformInfo *pItxInfo,

              jdouble *retx, jdouble *rety)

{

    jdouble x, y;

    x = dxoff+pBounds->x1+0.5; /* Center of pixel x1 */

    y = dyoff+pBounds->y1+0.5; /* Center of pixel y1 */

    Transform_transform(pItxInfo, &x, &y);

    *retx = x;

    *rety = y;

    if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) {

        return JNI_TRUE;

    }

    x = dxoff+pBounds->x2-0.5; /* Center of pixel x2-1 */

    y = dyoff+pBounds->y1+0.5; /* Center of pixel y1 */

    Transform_transform(pItxInfo, &x, &y);

    if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) {

        return JNI_TRUE;

    }

    x = dxoff+pBounds->x1+0.5; /* Center of pixel x1 */

    y = dyoff+pBounds->y2-0.5; /* Center of pixel y2-1 */

    Transform_transform(pItxInfo, &x, &y);

    if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) {

        return JNI_TRUE;

    }

    x = dxoff+pBounds->x2-0.5; /* Center of pixel x2-1 */

    y = dyoff+pBounds->y2-0.5; /* Center of pixel y2-1 */

    Transform_transform(pItxInfo, &x, &y);

    if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) {

        return JNI_TRUE;

    }

    return JNI_FALSE;

}

/*

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

 * pEdges points to an array of jints that holds 2 + numedges*2 values where

 * numedges should match (pBounds->y2 - pBounds->y1).

 * The first two jints in pEdges should be set to y1 and y2 and every pair

 * of jints after that represent the xmin,xmax of all pixels in range of

 * the transformed blit for the corresponding scanline.

 */

static void

calculateEdges(jint *pEdges,

               SurfaceDataBounds *pBounds,

               TransformInfo *pItxInfo,

               jlong xbase, jlong ybase,

               juint sw, juint sh)

{

    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;

    *pEdges++ = dy1;

    *pEdges++ = dy2;

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

    }

}

static void

Transform_SafeHelper(JNIEnv *env,

                     SurfaceDataOps *srcOps,

                     SurfaceDataOps *dstOps,

                     SurfaceDataRasInfo *pSrcInfo,

                     SurfaceDataRasInfo *pDstInfo,

                     NativePrimitive *pMaskBlitPrim,

                     CompositeInfo *pCompInfo,

                     TransformHelperFunc *pHelperFunc,

                     TransformInterpFunc *pInterpFunc,

                     RegionData *pClipInfo, TransformInfo *pItxInfo,

                     jint *pData, jint *pEdges,

                     jint dxoff, jint dyoff, jint sw, jint sh);

/*

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

    jdouble xorig, yorig;

    jlong numedges;

    jint *pEdges;

    jint edgebuf[2 + MAXEDGES * 2];

    union {

        jlong align;

        jint data[LINE_SIZE];

    } rgb;

#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);

    if (srcOps == 0) {

        return;

    }

    dstOps = SurfaceData_GetOps(env, dstData);

    if (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;

    default:

        // Should not happen, but just in case.

        return;

    }

    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)

    {

        /* edgeArray should already contain zeros for min/maxy */

        return;

    }

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

        != SD_SUCCESS)

    {

        SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);

        /* edgeArray should already contain zeros for min/maxy */

        return;

    }

    Region_IntersectBounds(&clipInfo, &dstInfo.bounds);

    numedges = (((jlong) dstInfo.bounds.y2) - ((jlong) dstInfo.bounds.y1));

    if (numedges <= 0) {

        pEdges = NULL;

    } else if (!JNU_IsNull(env, edgeArray)) {

        /*

         * Ideally Java should allocate an array large enough, but if

         * we ever have a miscommunication about the number of edge

         * lines, or if the Java array calculation should overflow to

         * a positive number and succeed in allocating an array that

         * is too small, we need to verify that it can still hold the

         * number of integers that we plan to store to be safe.

         */

        jsize edgesize = (*env)->GetArrayLength(env, edgeArray);

        /* (edgesize/2 - 1) should avoid any overflow or underflow. */

        pEdges = (((edgesize / 2) - 1) >= numedges)

            ? (*env)->GetPrimitiveArrayCritical(env, edgeArray, NULL)

            : NULL;

    } else if (numedges > MAXEDGES) {

        /* numedges variable (jlong) can be at most ((1<<32)-1) */

        /* memsize can overflow a jint, but not a jlong */

        jlong memsize = ((numedges * 2) + 2) * sizeof(*pEdges);

        pEdges = (memsize == ((size_t) memsize))

            ? malloc((size_t) memsize)

            : NULL;

    } else {

        pEdges = edgebuf;

    }

    if (pEdges == NULL) {

        if (!(*env)->ExceptionCheck(env) && numedges > 0) {

            JNU_ThrowInternalError(env, "Unable to allocate edge list");

        }

        SurfaceData_InvokeUnlock(env, dstOps, &dstInfo);

        SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);

        /* edgeArray should already contain zeros for min/maxy */

        return;

    }

    if (!Region_IsEmpty(&clipInfo)) {

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

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

        if (srcInfo.rasBase == NULL || dstInfo.rasBase == NULL) {

            pEdges[0] = pEdges[1] = 0;

        } else if (checkOverflow(dxoff, dyoff, &dstInfo.bounds,

                                 &itxInfo, &xorig, &yorig))

        {

            Transform_SafeHelper(env, srcOps, dstOps,

                                 &srcInfo, &dstInfo,

                                 pMaskBlitPrim, &compInfo,

                                 pHelperFunc, pInterpFunc,

                                 &clipInfo, &itxInfo, rgb.data, pEdges,

                                 dxoff, dyoff, sx2-sx1, sy2-sy1);

        } else {

            SurfaceDataBounds span;

            jlong dxdxlong, dydxlong;

            jlong dxdylong, dydylong;

            jlong xbase, ybase;

            dxdxlong = DblToLong(itxInfo.dxdx);

            dydxlong = DblToLong(itxInfo.dydx);

            dxdylong = DblToLong(itxInfo.dxdy);

            dydylong = DblToLong(itxInfo.dydy);

            xbase = DblToLong(xorig);

            ybase = DblToLong(yorig);

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

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

            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 + 2];

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

                    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,