/*

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

#include <stdlib.h>

#include <string.h>

#include "sun_awt_image_ImagingLib.h"

#include "java_awt_Transparency.h"

#include "java_awt_image_AffineTransformOp.h"

#include "java_awt_image_BufferedImage.h"

#include "java_awt_color_ColorSpace.h"

#include "java_awt_image_ConvolveOp.h"

#include "sun_awt_image_IntegerComponentRaster.h"

#include "awt_ImagingLib.h"

#include "awt_parseImage.h"

#include "imageInitIDs.h"

#include <jni.h>

#include <jni_util.h>

#include <assert.h>

#include "awt_Mlib.h"

#include "gdefs.h"

#include "safe_alloc.h"

/***************************************************************************

 *                               Definitions                               *

 ***************************************************************************/

#define jio_fprintf fprintf

#ifndef TRUE

#define TRUE 1

#endif /* TRUE */

#ifndef FALSE

#define FALSE 0

#endif /* FALSE */

#define TYPE_CUSTOM         java_awt_image_BufferedImage_TYPE_CUSTOM

#define TYPE_INT_RGB        java_awt_image_BufferedImage_TYPE_INT_RGB

#define TYPE_INT_ARGB       java_awt_image_BufferedImage_TYPE_INT_ARGB

#define TYPE_INT_ARGB_PRE   java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE

#define TYPE_INT_BGR        java_awt_image_BufferedImage_TYPE_INT_BGR

#define TYPE_4BYTE_ABGR     java_awt_image_BufferedImage_TYPE_4BYTE_ABGR

#define TYPE_4BYTE_ABGR_PRE java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE

/* (alpha*color)>>nbits + alpha>>(nbits-1) */

#define BLEND(color, alpha, alphaNbits) \

    ((((alpha)*(color))>>(alphaNbits)) + ((alpha) >> ((alphaNbits)-1)))

    /* ((color - (alpha>>(nBits-1)))<<nBits)/alpha */

#define UNBLEND(color, alpha, alphaNbits) \

    ((((color)-((alpha)>>((alphaNbits)-1)))<<(alphaNbits))/(alpha))

/* Enumeration of all of the mlib functions used */

typedef enum {

    MLIB_CONVMxN,

    MLIB_AFFINE,

    MLIB_LOOKUP,

    MLIB_CONVKERNCVT

} mlibTypeE_t;

typedef struct {

    int dataType;           /* One of BYTE_DATA_TYPE, SHORT_DATA_TYPE, */

    int needToCopy;

    int cvtSrcToDefault;    /* If TRUE, convert the src to def CM (pre?) */

    int allocDefaultDst;    /* If TRUE, alloc def CM dst buffer */

    int cvtToDst;           /* If TRUE, convert dst buffer to Dst CM */

    int addAlpha;

} mlibHintS_t;

/***************************************************************************

 *                     Static Variables/Structures                         *

 ***************************************************************************/

static mlibSysFnS_t sMlibSysFns = {

    NULL, // placeholder for j2d_mlib_ImageCreate

    NULL, // placeholder for j2d_mlib_ImageCreateStruct

    NULL, // placeholder for j2d_mlib_ImageDelete

};

static mlibFnS_t sMlibFns[] = {

    {NULL, "j2d_mlib_ImageConvMxN"},

    {NULL, "j2d_mlib_ImageAffine"},

    {NULL, "j2d_mlib_ImageLookUp"},

    {NULL, "j2d_mlib_ImageConvKernelConvert"},

    {NULL, NULL},

};

static int s_timeIt = 0;

static int s_printIt = 0;

static int s_startOff = 0;

static int s_nomlib = 0;

/***************************************************************************

 *                          Static Function Prototypes                     *

 ***************************************************************************/

static int

allocateArray(JNIEnv *env, BufImageS_t *imageP,

              mlib_image **mlibImagePP, void **dataPP, int isSrc,

              int cvtToDefault, int addAlpha);

static int

allocateRasterArray(JNIEnv *env, RasterS_t *rasterP,

                    mlib_image **mlibImagePP, void **dataPP, int isSrc);

static void

freeArray(JNIEnv *env, BufImageS_t *srcimageP, mlib_image *srcmlibImP,

          void *srcdataP, BufImageS_t *dstimageP, mlib_image *dstmlibImP,

          void *dstdataP);

static void

freeDataArray(JNIEnv *env, jobject srcJdata, mlib_image *srcmlibImP,

          void *srcdataP, jobject dstJdata, mlib_image *dstmlibImP,

          void *dstdataP);

static int

storeImageArray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,

                mlib_image *mlibImP);

static int

storeRasterArray(JNIEnv *env, RasterS_t *srcP, RasterS_t *dstP,

                mlib_image *mlibImP);

static int

storeICMarray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,

              mlib_image *mlibImP);

static int

colorMatch(int r, int g, int b, int a, unsigned char *argb, int numColors);

static int

setImageHints(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,

              int expandICM, int useAlpha,

              int premultiply, mlibHintS_t *hintP);

static int expandICM(JNIEnv *env, BufImageS_t *imageP, unsigned int *mDataP);

static int expandPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,

                           unsigned char *outDataP);

static int expandPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,

                           unsigned char *outDataP);

static int expandPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,

                           unsigned char *outDataP);

static int expandPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,

                                  int component, unsigned char *outDataP,

                                  int forceAlpha);

static int expandPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,

                                  int component, unsigned char *outDataP,

                                  int forceAlpha);

static int expandPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,

                                  int component, unsigned char *outDataP,

                                  int forceAlpha);

static int setPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,

                        unsigned char *outDataP);

static int setPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,

                        unsigned char *outDataP);

static int setPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,

                        unsigned char *outDataP);

static int setPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,

                               int component, unsigned char *outDataP,

                               int supportsAlpha);

static int setPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,

                               int component, unsigned char *outDataP,

                               int supportsAlpha);

static int setPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,

                               int component, unsigned char *outDataP,

                               int supportsAlpha);

mlib_start_timer start_timer = NULL;

mlib_stop_timer stop_timer = NULL;

/***************************************************************************

 *                          Debugging Definitions                          *

 ***************************************************************************/

#ifdef DEBUG

static void

printMedialibError(int status) {

    switch(status) {

    case MLIB_FAILURE:

        jio_fprintf(stderr, "failure\n");

        break;

    case MLIB_NULLPOINTER:

        jio_fprintf(stderr, "null pointer\n");

        break;

    case MLIB_OUTOFRANGE:

        jio_fprintf (stderr, "out of range\n");

        break;

    default:

        jio_fprintf (stderr, "medialib error\n");

        break;

    }

}

#else /* ! DEBUG */

#  define printMedialibError(x)

#endif /* ! DEBUG */

static int

getMlibEdgeHint(jint edgeHint) {

    switch (edgeHint) {

    case java_awt_image_ConvolveOp_EDGE_NO_OP:

        return MLIB_EDGE_DST_COPY_SRC;

    case java_awt_image_ConvolveOp_EDGE_ZERO_FILL:

    default:

        return MLIB_EDGE_DST_FILL_ZERO;

    }

}

/***************************************************************************

 *                          External Functions                             *

 ***************************************************************************/

JNIEXPORT jint JNICALL

Java_sun_awt_image_ImagingLib_convolveBI(JNIEnv *env, jobject this,

                                         jobject jsrc, jobject jdst,

                                         jobject jkernel, jint edgeHint)

{

    void *sdata, *ddata;

    mlib_image *src;

    mlib_image *dst;

    int i, scale;

    mlib_d64 *dkern;

    mlib_s32 *kdata;

    int klen;

    float kmax;

    mlib_s32 cmask;

    mlib_status status;

    int retStatus = 1;

    float *kern;

    BufImageS_t *srcImageP, *dstImageP;

    jobject jdata;

    int kwidth;

    int kheight;

    int w, h;

    int x, y;

    mlibHintS_t hint;

    int nbands;

    /* This function requires a lot of local refs ??? Is 64 enough ??? */

    if ((*env)->EnsureLocalCapacity(env, 64) < 0)

        return 0;

    if (s_nomlib) return 0;

    if (s_timeIt)     (*start_timer)(3600);

    kwidth  = (*env)->GetIntField(env, jkernel, g_KernelWidthID);

    kheight = (*env)->GetIntField(env, jkernel, g_KernelHeightID);

    jdata = (*env)->GetObjectField(env, jkernel, g_KernelDataID);

    klen  = (*env)->GetArrayLength(env, jdata);

    kern  = (float *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL);

    if (kern == NULL) {

        /* out of memory exception already thrown */

        return 0;

    }

    if ((kwidth&0x1) == 0) {

        /* Kernel has even width */

        w = kwidth+1;

    }

    else {

        w = kwidth;

    }

    if ((kheight&0x1) == 0) {

        /* Kernel has even height */

        h = kheight+1;

    }

    else {

        h = kheight;

    }

    dkern = NULL;

    if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_d64))) {

        dkern = (mlib_d64 *)calloc(1, w * h * sizeof(mlib_d64));

    }

    if (dkern == NULL) {

        (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT);

        return 0;

    }

    /* Need to flip and find max value of the kernel.

     * Also, save the kernel values as mlib_d64 values.

     * The flip is to operate correctly with medialib,

     * which doesn't do the mathemetically correct thing,

     * i.e. it doesn't rotate the kernel by 180 degrees.

     * REMIND: This should perhaps be done at the Java

     * level by ConvolveOp.

     * REMIND: Should the max test be looking at absolute

     * values?

     * REMIND: What if klen != kheight * kwidth?

     */

    kmax = kern[klen-1];

    i = klen-1;

    for (y=0; y < kheight; y++) {

        for (x=0; x < kwidth; x++, i--) {

            dkern[y*w+x] = (mlib_d64) kern[i];

            if (kern[i] > kmax) {

                kmax = kern[i];

            }

        }

    }

    (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT);

    if (kmax > 1<<16) {

        /* We can only handle 16 bit max */

        free(dkern);

        return 0;

    }

    /* Parse the source image */

    if ((status = awt_parseImage(env, jsrc, &srcImageP, FALSE)) <= 0) {

        /* Can't handle any custom images */

        free(dkern);

        return 0;

    }

    /* Parse the destination image */

    if ((status = awt_parseImage(env, jdst, &dstImageP, FALSE)) <= 0) {

        /* Can't handle any custom images */

        awt_freeParsedImage(srcImageP, TRUE);

        free(dkern);

        return 0;

    }

    nbands = setImageHints(env, srcImageP, dstImageP, TRUE, TRUE,

                        FALSE, &hint);

    if (nbands < 1) {

        /* Can't handle any custom images */

        awt_freeParsedImage(srcImageP, TRUE);

        awt_freeParsedImage(dstImageP, TRUE);

        free(dkern);

        return 0;

    }

    /* Allocate the arrays */

    if (allocateArray(env, srcImageP, &src, &sdata, TRUE,

                      hint.cvtSrcToDefault, hint.addAlpha) < 0) {

        /* Must be some problem */

        awt_freeParsedImage(srcImageP, TRUE);

        awt_freeParsedImage(dstImageP, TRUE);

        free(dkern);

        return 0;

    }

    if (allocateArray(env, dstImageP, &dst, &ddata, FALSE,

                      hint.cvtToDst, FALSE) < 0) {

        /* Must be some problem */

        freeArray(env, srcImageP, src, sdata, NULL, NULL, NULL);

        awt_freeParsedImage(srcImageP, TRUE);

        awt_freeParsedImage(dstImageP, TRUE);

        free(dkern);

        return 0;

    }

    kdata = NULL;

    if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_s32))) {

        kdata = (mlib_s32 *)malloc(w * h * sizeof(mlib_s32));

    }

    if (kdata == NULL) {

        freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);

        awt_freeParsedImage(srcImageP, TRUE);

        awt_freeParsedImage(dstImageP, TRUE);

        free(dkern);

        return 0;

    }

    if ((*sMlibFns[MLIB_CONVKERNCVT].fptr)(kdata, &scale, dkern, w, h,

                                    mlib_ImageGetType(src)) != MLIB_SUCCESS) {

        freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);

        awt_freeParsedImage(srcImageP, TRUE);

        awt_freeParsedImage(dstImageP, TRUE);

        free(dkern);

        free(kdata);

        return 0;

    }

    if (s_printIt) {

        fprintf(stderr, "Orig Kernel(len=%d):\n",klen);

        for (y=kheight-1; y >= 0; y--) {

            for (x=kwidth-1; x >= 0; x--) {

                fprintf(stderr, "%g ", dkern[y*w+x]);

            }

            fprintf(stderr, "\n");

        }

        fprintf(stderr, "New Kernel(scale=%d):\n", scale);

        for (y=kheight-1; y >= 0; y--) {

            for (x=kwidth-1; x >= 0; x--) {

                fprintf(stderr, "%d ", kdata[y*w+x]);

            }

            fprintf(stderr, "\n");

        }

    }

    cmask = (1<<src->channels)-1;

    status = (*sMlibFns[MLIB_CONVMxN].fptr)(dst, src, kdata, w, h,

                               (w-1)/2, (h-1)/2, scale, cmask,

                               getMlibEdgeHint(edgeHint));

    if (status != MLIB_SUCCESS) {

        printMedialibError(status);

        retStatus = 0;

    }

    if (s_printIt) {

        unsigned int *dP;

        if (s_startOff != 0) {

            printf("Starting at %d\n", s_startOff);

        }

        if (sdata == NULL) {

            dP = (unsigned int *) mlib_ImageGetData(src);

        }

        else {

            dP = (unsigned int *) sdata;

        }

        printf("src is\n");

        for (i=0; i < 20; i++) {

            printf("%x ",dP[s_startOff+i]);

        }

        printf("\n");

        if (ddata == NULL) {

            dP = (unsigned int *)mlib_ImageGetData(dst);

        }

        else {

            dP = (unsigned int *) ddata;

        }

        printf("dst is \n");

        for (i=0; i < 20; i++) {

            printf("%x ",dP[s_startOff+i]);

        }

        printf("\n");

    }

    /* Means that we couldn't write directly into the destination buffer */

    if (ddata == NULL) {

        /* Need to store it back into the array */

        if (storeImageArray(env, srcImageP, dstImageP, dst) < 0) {

            /* Error */

            retStatus = 0;

        }

    }

    /* Release the pinned memory */

    freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);

    awt_freeParsedImage(srcImageP, TRUE);

    awt_freeParsedImage(dstImageP, TRUE);

    free(dkern);

    free(kdata);

    if (s_timeIt) (*stop_timer)(3600, 1);

    return retStatus;

}

JNIEXPORT jint JNICALL

Java_sun_awt_image_ImagingLib_convolveRaster(JNIEnv *env, jobject this,

                                             jobject jsrc, jobject jdst,

                                             jobject jkernel, jint edgeHint)

{

    mlib_image *src;

    mlib_image *dst;

    int i, scale;

    mlib_d64 *dkern;

    mlib_s32 *kdata;

    int klen;

    float kmax;

    int retStatus = 1;

    mlib_status status;

    mlib_s32 cmask;

    void *sdata;

    void *ddata;

    RasterS_t *srcRasterP;

    RasterS_t *dstRasterP;

    int kwidth;

    int kheight;

    int w, h;

    int x, y;

    jobject jdata;

    float *kern;

    /* This function requires a lot of local refs ??? Is 64 enough ??? */

    if ((*env)->EnsureLocalCapacity(env, 64) < 0)

        return 0;

    if (s_nomlib) return 0;

    if (s_timeIt)     (*start_timer)(3600);

    kwidth  = (*env)->GetIntField(env, jkernel, g_KernelWidthID);

    kheight = (*env)->GetIntField(env, jkernel, g_KernelHeightID);

    jdata = (*env)->GetObjectField(env, jkernel, g_KernelDataID);

    klen  = (*env)->GetArrayLength(env, jdata);

    kern  = (float *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL);

    if (kern == NULL) {

        /* out of memory exception already thrown */

        return 0;

    }

    if ((kwidth&0x1) == 0) {

        /* Kernel has even width */

        w = kwidth+1;

    }

    else {

        w = kwidth;

    }

    if ((kheight&0x1) == 0) {

        /* Kernel has even height */

        h = kheight+1;

    }