/*
 * Copyright (c) 1997, 2014, 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 <string.h>

#include "jni.h"
#include "jni_util.h"
#include "awt_parseImage.h"
#include "imageInitIDs.h"
#include "sun_awt_image_ImageRepresentation.h"

static int compareLUTs(unsigned int *lut1, int numLut1, int transIdx,
                       unsigned int *lut2, int numLut2, unsigned char *cvtLut,
                       int *retNumLut1, int *retTransIdx, int *jniFlagP);

static int findIdx(unsigned int rgb, unsigned int *lut, int numLut1);

#define ALPHA_MASK    0xff000000
#ifndef FALSE
#  define FALSE 0
#endif
#ifndef TRUE
#  define TRUE 1
#endif

#define CHECK_STRIDE(yy, hh, ss)                            \
    if ((ss) != 0) {                                        \
        int limit = 0x7fffffff / ((ss) > 0 ? (ss) : -(ss)); \
        if (limit < (yy) || limit < ((yy) + (hh) - 1)) {    \
            /* integer overflow */                           \
            return JNI_FALSE;                               \
        }                                                   \
    }                                                       \

#define CHECK_SRC()                                      \
    do {                                                 \
        int pixeloffset;                                 \
        if (off < 0 || off >= srcDataLength) {           \
            return JNI_FALSE;                            \
        }                                                \
        CHECK_STRIDE(0, h, scansize);                    \
                                                         \
        /* check scansize */                             \
        pixeloffset = scansize * (h - 1);                \
        if ((w - 1) > (0x7fffffff - pixeloffset)) {      \
            return JNI_FALSE;                            \
        }                                                \
        pixeloffset += (w - 1);                          \
                                                         \
        if (off > (0x7fffffff - pixeloffset)) {          \
            return JNI_FALSE;                            \
        }                                                \
    } while (0)                                          \

#define CHECK_DST(xx, yy)                                \
    do {                                                 \
        int soffset = (yy) * sStride;                    \
        int poffset = (xx) * pixelStride;                \
        if (poffset > (0x7fffffff - soffset)) {          \
            return JNI_FALSE;                            \
        }                                                \
        poffset += soffset;                              \
        if (dstDataOff > (0x7fffffff - poffset)) {       \
            return JNI_FALSE;                            \
        }                                                \
        poffset += dstDataOff;                           \
                                                         \
        if (poffset < 0 || poffset >= dstDataLength) {   \
            return JNI_FALSE;                            \
        }                                                \
    } while (0)                                          \

static jfieldID s_JnumSrcLUTID;
static jfieldID s_JsrcLUTtransIndexID;

JNIEXPORT void JNICALL
Java_sun_awt_image_ImageRepresentation_initIDs(JNIEnv *env, jclass cls) {
    CHECK_NULL(s_JnumSrcLUTID = (*env)->GetFieldID(env, cls, "numSrcLUT", "I"));
    CHECK_NULL(s_JsrcLUTtransIndexID = (*env)->GetFieldID(env, cls,
                                                          "srcLUTtransIndex", "I"));
}

/*
 * This routine is used to draw ICM pixels into a default color model
 */
JNIEXPORT jboolean JNICALL
Java_sun_awt_image_ImageRepresentation_setICMpixels(JNIEnv *env, jclass cls,
                                                    jint x, jint y, jint w,
                                                    jint h, jintArray jlut,
                                                    jbyteArray jpix, jint off,
                                                    jint scansize,
                                                    jobject jict)
{
    unsigned char *srcData = NULL;
    jint srcDataLength;
    int *dstData;
    jint dstDataLength;
    jint dstDataOff;
    int *dstP, *dstyP;
    unsigned char *srcyP, *srcP;
    int *srcLUT = NULL;
    int yIdx, xIdx;
    int sStride;
    int *cOffs;
    int pixelStride;
    jobject joffs = NULL;
    jobject jdata = NULL;

    if (JNU_IsNull(env, jlut)) {
        JNU_ThrowNullPointerException(env, "NullPointerException");
        return JNI_FALSE;
    }

    if (JNU_IsNull(env, jpix)) {
        JNU_ThrowNullPointerException(env, "NullPointerException");
        return JNI_FALSE;
    }

    if (x < 0 || w < 1 || (0x7fffffff - x) < w) {
        return JNI_FALSE;
    }

    if (y < 0 || h < 1 || (0x7fffffff - y) < h) {
        return JNI_FALSE;
    }

    sStride = (*env)->GetIntField(env, jict, g_ICRscanstrID);
    pixelStride = (*env)->GetIntField(env, jict, g_ICRpixstrID);
    joffs = (*env)->GetObjectField(env, jict, g_ICRdataOffsetsID);
    jdata = (*env)->GetObjectField(env, jict, g_ICRdataID);

    if (JNU_IsNull(env, jdata)) {
        /* no destination buffer */
        return JNI_FALSE;
    }

    if (JNU_IsNull(env, joffs) || (*env)->GetArrayLength(env, joffs) < 1) {
        /* invalid data offstes in raster */
        return JNI_FALSE;
    }

    srcDataLength = (*env)->GetArrayLength(env, jpix);
    dstDataLength = (*env)->GetArrayLength(env, jdata);

    cOffs = (int *) (*env)->GetPrimitiveArrayCritical(env, joffs, NULL);
    if (cOffs == NULL) {
        (*env)->ExceptionClear(env);
        JNU_ThrowNullPointerException(env, "Null channel offset array");
        return JNI_FALSE;
    }

    dstDataOff = cOffs[0];

    /* the offset array is not needed anymore and can be released */
    (*env)->ReleasePrimitiveArrayCritical(env, joffs, cOffs, JNI_ABORT);
    joffs = NULL;
    cOffs = NULL;

    /* do basic validation: make sure that offsets for
    * first pixel and for last pixel are safe to calculate and use */
    CHECK_STRIDE(y, h, sStride);
    CHECK_STRIDE(x, w, pixelStride);

    CHECK_DST(x, y);
    CHECK_DST(x + w -1, y + h - 1);

    /* check source array */
    CHECK_SRC();

    srcLUT = (int *) (*env)->GetPrimitiveArrayCritical(env, jlut, NULL);
    if (srcLUT == NULL) {
        (*env)->ExceptionClear(env);
        JNU_ThrowNullPointerException(env, "Null IndexColorModel LUT");
        return JNI_FALSE;
    }

    srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix,
                                                                  NULL);
    if (srcData == NULL) {
        (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
        (*env)->ExceptionClear(env);
        JNU_ThrowNullPointerException(env, "Null data array");
        return JNI_FALSE;
    }

    dstData = (int *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL);
    if (dstData == NULL) {
        (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
        (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
        (*env)->ExceptionClear(env);
        JNU_ThrowNullPointerException(env, "Null tile data array");
        return JNI_FALSE;
    }

    dstyP = dstData + dstDataOff + y*sStride + x*pixelStride;
    srcyP = srcData + off;
    for (yIdx = 0; yIdx < h; yIdx++, srcyP += scansize, dstyP+=sStride) {
        srcP = srcyP;
        dstP = dstyP;
        for (xIdx = 0; xIdx < w; xIdx++, dstP+=pixelStride) {
            *dstP = srcLUT[*srcP++];
        }
    }

    /* Release the locked arrays */
    (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT,  JNI_ABORT);
    (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
    (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT);

    return JNI_TRUE;
}

JNIEXPORT jboolean JNICALL
Java_sun_awt_image_ImageRepresentation_setDiffICM(JNIEnv *env, jclass cls,
                                                  jint x, jint y, jint w,
                                                  jint h, jintArray jlut,
                                                  jint transIdx, jint numLut,
                                                  jobject jicm,
                                                  jbyteArray jpix, jint off,
                                                  jint scansize,
                                                  jobject jbct, jint dstDataOff)
{
    unsigned int *srcLUT = NULL;
    unsigned int *newLUT = NULL;
    int sStride;
    int pixelStride;
    int mapSize;
    jobject jdata = NULL;
    jobject jnewlut = NULL;
    jint srcDataLength;
    jint dstDataLength;
    unsigned char *srcData;
    unsigned char *dstData;
    unsigned char *dataP;
    unsigned char *pixP;
    int i;
    int j;
    int newNumLut;
    int newTransIdx;
    int jniFlag = JNI_ABORT;
    unsigned char *ydataP;
    unsigned char *ypixP;
    unsigned char cvtLut[256];

    if (JNU_IsNull(env, jlut)) {
        JNU_ThrowNullPointerException(env, "NullPointerException");
        return JNI_FALSE;
    }

    if (JNU_IsNull(env, jpix)) {
        JNU_ThrowNullPointerException(env, "NullPointerException");
        return JNI_FALSE;
    }

    if (x < 0 || w < 1 || (0x7fffffff - x) < w) {
        return JNI_FALSE;
    }

    if (y < 0 || h < 1 || (0x7fffffff - y) < h) {
        return JNI_FALSE;
    }


    sStride = (*env)->GetIntField(env, jbct, g_BCRscanstrID);
    pixelStride =(*env)->GetIntField(env, jbct, g_BCRpixstrID);
    jdata = (*env)->GetObjectField(env, jbct, g_BCRdataID);
    jnewlut = (*env)->GetObjectField(env, jicm, g_ICMrgbID);
    mapSize = (*env)->GetIntField(env, jicm, g_ICMmapSizeID);

    if (numLut < 0 || numLut > 256 || mapSize < 0 || mapSize > 256) {
        /* Ether old or new ICM has a palette that exceeds capacity
           of byte data type, so we have to convert the image data
           to default representation.
        */
        return JNI_FALSE;
    }

    if (JNU_IsNull(env, jdata)) {
        /* no destination buffer */
        return JNI_FALSE;
    }

    srcDataLength = (*env)->GetArrayLength(env, jpix);
    dstDataLength = (*env)->GetArrayLength(env, jdata);

    CHECK_STRIDE(y, h, sStride);
    CHECK_STRIDE(x, w, pixelStride);

    CHECK_DST(x, y);
    CHECK_DST(x + w -1, y + h - 1);

    /* check source array */
    CHECK_SRC();

    srcLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jlut,
                                                                NULL);
    if (srcLUT == NULL) {
        /* out of memory error already thrown */
        return JNI_FALSE;
    }

    newLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jnewlut,
                                                                NULL);
    if (newLUT == NULL) {
        (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT,
                                              JNI_ABORT);
        /* out of memory error already thrown */
        return JNI_FALSE;
    }

    newNumLut = numLut;
    newTransIdx = transIdx;
    if (compareLUTs(srcLUT, numLut, transIdx, newLUT, mapSize,
                    cvtLut, &newNumLut, &newTransIdx, &jniFlag) == FALSE) {
        /* Need to convert to ICR */
        (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT,
                                              JNI_ABORT);
        (*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT);
        return JNI_FALSE;
    }

    /* Don't need these any more */
    (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, jniFlag);
    (*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT);

    if (newNumLut != numLut) {
        /* Need to write back new number of entries in lut */
        (*env)->SetIntField(env, cls, s_JnumSrcLUTID, newNumLut);
    }

    if (newTransIdx != transIdx) {
        (*env)->SetIntField(env, cls, s_JsrcLUTtransIndexID, newTransIdx);
    }

    srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix,
                                                                  NULL);
    if (srcData == NULL) {
        /* out of memory error already thrown */
        return JNI_FALSE;
    }

    dstData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jdata,
                                                                  NULL);
    if (dstData == NULL) {
        (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
        /* out of memory error already thrown */
        return JNI_FALSE;
    }

    ydataP = dstData + dstDataOff + y*sStride + x*pixelStride;
    ypixP  = srcData + off;

    for (i=0; i < h; i++) {
        dataP = ydataP;
        pixP = ypixP;
        for (j=0; j < w; j++) {
            *dataP = cvtLut[*pixP];
            dataP += pixelStride;
            pixP++;
        }
        ydataP += sStride;
        ypixP  += scansize;
    }

    (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
    (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT);

    return JNI_TRUE;
}

static int compareLUTs(unsigned int *lut1, int numLut1, int transIdx,
                       unsigned int *lut2, int numLut2, unsigned char *cvtLut,
                       int *retNumLut1, int *retTransIdx, int *jniFlagP)
{
    int i;
    int idx;
    int newTransIdx = -1;
    unsigned int rgb;
    int changed = FALSE;
    int maxSize = (numLut1 > numLut2 ? numLut1 : numLut2);

    *jniFlagP = JNI_ABORT;

    for (i=0; i < maxSize; i++) {
        cvtLut[i] = i;
    }

    for (i=0; i < numLut2; i++) {
        /* If this slot in new palette is different from the
         * same slot in current palette, then we try to find
         * this color in other slots. On failure, add this color
         * to current palette.
         */
        if ((i >= numLut1) ||
            (lut1[i] != lut2[i]))
        {
            rgb = lut2[i];
            /* Transparent */
            if ((rgb & ALPHA_MASK) == 0) {
                if (transIdx == -1) {
                    if (numLut1 < 256) {
                        cvtLut[i] = numLut1;
                        newTransIdx = i;
                        transIdx = i;
                        numLut1++;
                        changed = TRUE;
                    }
                    else {
                        return FALSE;
                    }
                }
                cvtLut[i] = transIdx;
            }
            else {
                if ((idx = findIdx(rgb, lut1, numLut1)) == -1) {
                    if (numLut1 < 256) {
                        lut1[numLut1] = rgb;
                        cvtLut[i] = numLut1;
                        numLut1++;
                        changed = TRUE;
                    }
                    else {
                        /* Bad news...  need to convert image */
                        return FALSE;
                    }
                } else {
                    cvtLut[i] = idx;
                }
            }
        }
    }

    if (changed) {
        *jniFlagP = 0;
        *retNumLut1 = numLut1;
        if (newTransIdx != -1) {
            *retTransIdx = newTransIdx;
        }
    }
    return TRUE;
}

static int findIdx(unsigned int rgb, unsigned int *lut, int numLut) {
    int i;

    if ((rgb&0xff000000)==0) {
        for (i=0; i < numLut; i++) {
            if ((lut[i]&0xff000000)==0) return i;
        }
    }
    else {
        for (i=0; i < numLut; i++) {
            if (lut[i] == rgb) return i;
        }
    }
    return -1;
}
