/*
 * Copyright (c) 1999, 2019, 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 "BufImgSurfaceData.h"
#include <stdlib.h>

#include "sun_awt_image_BufImgSurfaceData.h"

#include "img_util_md.h"
#include "jni_util.h"
/* Define uintptr_t */
#include "gdefs.h"
#include "Disposer.h"

/**
 * This include file contains support code for loops using the
 * SurfaceData interface to talk to an X11 drawable from native
 * code.
 */

static LockFunc                 BufImg_Lock;
static GetRasInfoFunc           BufImg_GetRasInfo;
static ReleaseFunc              BufImg_Release;
static DisposeFunc              BufImg_Dispose;

static ColorData *BufImg_SetupICM(JNIEnv *env, BufImgSDOps *bisdo);

static jfieldID         rgbID;
static jfieldID         mapSizeID;
static jfieldID         colorDataID;
static jfieldID         pDataID;
static jfieldID         allGrayID;

static jclass           clsICMCD;
static jmethodID        initICMCDmID;
/*
 * Class:     sun_awt_image_BufImgSurfaceData
 * Method:    initIDs
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_sun_awt_image_BufImgSurfaceData_initIDs
(JNIEnv *env, jclass bisd, jclass icm, jclass cd)
{
    if (sizeof(BufImgRIPrivate) > SD_RASINFO_PRIVATE_SIZE) {
        JNU_ThrowInternalError(env, "Private RasInfo structure too large!");
        return;
    }

    clsICMCD = (*env)->NewWeakGlobalRef(env, cd);
    JNU_CHECK_EXCEPTION(env);
    CHECK_NULL(initICMCDmID = (*env)->GetMethodID(env, cd, "<init>", "(J)V"));
    CHECK_NULL(pDataID = (*env)->GetFieldID(env, cd, "pData", "J"));
    CHECK_NULL(rgbID = (*env)->GetFieldID(env, icm, "rgb", "[I"));
    CHECK_NULL(allGrayID = (*env)->GetFieldID(env, icm, "allgrayopaque", "Z"));
    CHECK_NULL(mapSizeID = (*env)->GetFieldID(env, icm, "map_size", "I"));
    CHECK_NULL(colorDataID = (*env)->GetFieldID(env, icm, "colorData",
                                           "Lsun/awt/image/BufImgSurfaceData$ICMColorData;"));
}

/*
 * Class:     sun_awt_image_BufImgSurfaceData
 * Method:    initOps
 * Signature: (Ljava/lang/Object;IIIII)V
 */
JNIEXPORT void JNICALL
Java_sun_awt_image_BufImgSurfaceData_initRaster(JNIEnv *env, jobject bisd,
                                                jobject array,
                                                jint offset, jint bitoffset,
                                                jint width, jint height,
                                                jint pixStr, jint scanStr,
                                                jobject icm)
{
    BufImgSDOps *bisdo =
        (BufImgSDOps*)SurfaceData_InitOps(env, bisd, sizeof(BufImgSDOps));
    if (bisdo == NULL) {
        JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");
        return;
    }
    bisdo->sdOps.Lock = BufImg_Lock;
    bisdo->sdOps.GetRasInfo = BufImg_GetRasInfo;
    bisdo->sdOps.Release = BufImg_Release;
    bisdo->sdOps.Unlock = NULL;
    bisdo->sdOps.Dispose = BufImg_Dispose;
    bisdo->array = (*env)->NewWeakGlobalRef(env, array);
    JNU_CHECK_EXCEPTION(env);
    bisdo->offset = offset;
    bisdo->bitoffset = bitoffset;
    bisdo->scanStr = scanStr;
    bisdo->pixStr = pixStr;
    if (JNU_IsNull(env, icm)) {
        bisdo->lutarray = NULL;
        bisdo->lutsize = 0;
        bisdo->icm = NULL;
    } else {
        jobject lutarray = (*env)->GetObjectField(env, icm, rgbID);
        bisdo->lutarray = (*env)->NewWeakGlobalRef(env, lutarray);
        JNU_CHECK_EXCEPTION(env);
        bisdo->lutsize = (*env)->GetIntField(env, icm, mapSizeID);
        bisdo->icm = (*env)->NewWeakGlobalRef(env, icm);
    }
    bisdo->rasbounds.x1 = 0;
    bisdo->rasbounds.y1 = 0;
    bisdo->rasbounds.x2 = width;
    bisdo->rasbounds.y2 = height;
}

/*
 * Releases native structures associated with BufImgSurfaceData.ICMColorData.
 */
static void BufImg_Dispose_ICMColorData(JNIEnv *env, jlong pData)
{
    ColorData *cdata = (ColorData*)jlong_to_ptr(pData);
    freeICMColorData(cdata);
}

/*
 * Method for disposing native BufImgSD
 */
static void BufImg_Dispose(JNIEnv *env, SurfaceDataOps *ops)
{
    /* ops is assumed non-null as it is checked in SurfaceData_DisposeOps */
    BufImgSDOps *bisdo = (BufImgSDOps *)ops;
    (*env)->DeleteWeakGlobalRef(env, bisdo->array);
    if (bisdo->lutarray != NULL) {
        (*env)->DeleteWeakGlobalRef(env, bisdo->lutarray);
    }
    if (bisdo->icm != NULL) {
        (*env)->DeleteWeakGlobalRef(env, bisdo->icm);
    }
}

static jint BufImg_Lock(JNIEnv *env,
                        SurfaceDataOps *ops,
                        SurfaceDataRasInfo *pRasInfo,
                        jint lockflags)
{
    BufImgSDOps *bisdo = (BufImgSDOps *)ops;
    BufImgRIPrivate *bipriv = (BufImgRIPrivate *) &(pRasInfo->priv);

    if ((lockflags & (SD_LOCK_LUT)) != 0 && JNU_IsNull(env, bisdo->lutarray)) {
        /* REMIND: Should this be an InvalidPipe exception? */
        JNU_ThrowNullPointerException(env, "Attempt to lock missing colormap");
        return SD_FAILURE;
    }
    if ((lockflags & SD_LOCK_INVCOLOR) != 0 ||
        (lockflags & SD_LOCK_INVGRAY) != 0)
    {
        bipriv->cData = BufImg_SetupICM(env, bisdo);
        if (bipriv->cData == NULL) {
            (*env)->ExceptionClear(env);
            JNU_ThrowNullPointerException(env, "Could not initialize inverse tables");
            return SD_FAILURE;
        }
    } else {
        bipriv->cData = NULL;
    }

    bipriv->lockFlags = lockflags;
    bipriv->base = NULL;
    bipriv->lutbase = NULL;

    SurfaceData_IntersectBounds(&pRasInfo->bounds, &bisdo->rasbounds);

    return SD_SUCCESS;
}

static void BufImg_GetRasInfo(JNIEnv *env,
                              SurfaceDataOps *ops,
                              SurfaceDataRasInfo *pRasInfo)
{
    BufImgSDOps *bisdo = (BufImgSDOps *)ops;
    BufImgRIPrivate *bipriv = (BufImgRIPrivate *) &(pRasInfo->priv);

    if ((bipriv->lockFlags & (SD_LOCK_RD_WR)) != 0) {
        bipriv->base =
            (*env)->GetPrimitiveArrayCritical(env, bisdo->array, NULL);
        CHECK_NULL(bipriv->base);
    }
    if ((bipriv->lockFlags & (SD_LOCK_LUT)) != 0) {
        bipriv->lutbase =
            (*env)->GetPrimitiveArrayCritical(env, bisdo->lutarray, NULL);
    }

    if (bipriv->base == NULL) {
        pRasInfo->rasBase = NULL;
        pRasInfo->pixelStride = 0;
        pRasInfo->pixelBitOffset = 0;
        pRasInfo->scanStride = 0;
    } else {
        pRasInfo->rasBase = (void *)
            (((uintptr_t) bipriv->base) + bisdo->offset);
        pRasInfo->pixelStride = bisdo->pixStr;
        pRasInfo->pixelBitOffset = bisdo->bitoffset;
        pRasInfo->scanStride = bisdo->scanStr;
    }
    if (bipriv->lutbase == NULL) {
        pRasInfo->lutBase = NULL;
        pRasInfo->lutSize = 0;
    } else {
        pRasInfo->lutBase = bipriv->lutbase;
        pRasInfo->lutSize = bisdo->lutsize;
    }
    if (bipriv->cData == NULL) {
        pRasInfo->invColorTable = NULL;
        pRasInfo->redErrTable = NULL;
        pRasInfo->grnErrTable = NULL;
        pRasInfo->bluErrTable = NULL;
        pRasInfo->representsPrimaries = 0;
    } else {
        pRasInfo->invColorTable = bipriv->cData->img_clr_tbl;
        pRasInfo->redErrTable = bipriv->cData->img_oda_red;
        pRasInfo->grnErrTable = bipriv->cData->img_oda_green;
        pRasInfo->bluErrTable = bipriv->cData->img_oda_blue;
        pRasInfo->invGrayTable = bipriv->cData->pGrayInverseLutData;
        pRasInfo->representsPrimaries = bipriv->cData->representsPrimaries;
    }
}

static void BufImg_Release(JNIEnv *env,
                           SurfaceDataOps *ops,
                           SurfaceDataRasInfo *pRasInfo)
{
    BufImgSDOps *bisdo = (BufImgSDOps *)ops;
    BufImgRIPrivate *bipriv = (BufImgRIPrivate *) &(pRasInfo->priv);

    if (bipriv->base != NULL) {
        jint mode = (((bipriv->lockFlags & (SD_LOCK_WRITE)) != 0)
                     ? 0 : JNI_ABORT);
        (*env)->ReleasePrimitiveArrayCritical(env, bisdo->array,
                                              bipriv->base, mode);
    }
    if (bipriv->lutbase != NULL) {
        (*env)->ReleasePrimitiveArrayCritical(env, bisdo->lutarray,
                                              bipriv->lutbase, JNI_ABORT);
    }
}

static int calculatePrimaryColorsApproximation(int* cmap, unsigned char* cube, int cube_size) {
    int i, j, k;
    int index, value, color;
    // values calculated from cmap
    int r, g, b;
    // maximum positive/negative variation allowed for r, g, b values for primary colors
    int delta = 5;
    // get the primary color cmap indices from corner of inverse color table
    for (i = 0; i < cube_size; i += (cube_size - 1)) {
        for (j = 0; j < cube_size; j += (cube_size - 1)) {
            for (k = 0; k < cube_size; k += (cube_size - 1)) {
                // calculate inverse color table index
                index = i + cube_size * (j + cube_size * k);
                // get value present in corners of inverse color table
                value = cube[index];
                // use the corner values as index for cmap
                color = cmap[value];
                // extract r,g,b values from cmap value
                r = ((color) >> 16) & 0xff;
                g = ((color) >> 8) & 0xff;
                b = color & 0xff;
                /*
                 * If i/j/k value is 0 optimum value of b/g/r should be 0 but we allow
                 * maximum positive variation of 5. If i/j/k value is 31 optimum value
                 * of b/g/r should be 255 but we allow maximum negative variation of 5.
                 */
                if (i == 0) {
                    if (b > delta)
                        return 0;
                } else {
                    if (b < (255 - delta))
                        return 0;
                }
                if (j == 0) {
                    if (g > delta)
                        return 0;
                } else {
                    if (g < (255 - delta))
                        return 0;
                }
                if (k == 0) {
                    if (r > delta)
                        return 0;
                } else {
                    if (r < (255 - delta))
                        return 0;
                }
            }
        }
    }
    return 1;
}

static ColorData *BufImg_SetupICM(JNIEnv *env,
                                  BufImgSDOps *bisdo)
{
    ColorData *cData = NULL;
    jobject colorData;

    if (JNU_IsNull(env, bisdo->icm)) {
        return (ColorData *) NULL;
    }

    colorData = (*env)->GetObjectField(env, bisdo->icm, colorDataID);

    if (JNU_IsNull(env, colorData)) {
        if (JNU_IsNull(env, clsICMCD)) {
            // we are unable to create a wrapper object
            return (ColorData*)NULL;
        }
    } else {
        cData = (ColorData*)JNU_GetLongFieldAsPtr(env, colorData, pDataID);
    }

    if (cData != NULL) {
        return cData;
    }

    cData = (ColorData*)calloc(1, sizeof(ColorData));

    if (cData != NULL) {
        jboolean allGray
            = (*env)->GetBooleanField(env, bisdo->icm, allGrayID);
        int *pRgb = (int *)
            ((*env)->GetPrimitiveArrayCritical(env, bisdo->lutarray, NULL));

        if (pRgb == NULL) {
            free(cData);
            return (ColorData*)NULL;
        }

        cData->img_clr_tbl = initCubemap(pRgb, bisdo->lutsize, 32);
        if (cData->img_clr_tbl == NULL) {
            (*env)->ReleasePrimitiveArrayCritical(env, bisdo->lutarray, pRgb, JNI_ABORT);
            free(cData);
            return (ColorData*)NULL;
        }
        cData->representsPrimaries = calculatePrimaryColorsApproximation(pRgb, cData->img_clr_tbl, 32);
        if (allGray == JNI_TRUE) {
            initInverseGrayLut(pRgb, bisdo->lutsize, cData);
        }
        (*env)->ReleasePrimitiveArrayCritical(env, bisdo->lutarray, pRgb,
                                              JNI_ABORT);

        initDitherTables(cData);

        if (JNU_IsNull(env, colorData)) {
            jlong pData = ptr_to_jlong(cData);
            colorData = (*env)->NewObjectA(env, clsICMCD, initICMCDmID, (jvalue *)&pData);

            if ((*env)->ExceptionCheck(env))
            {
                free(cData);
                return (ColorData*)NULL;
            }

            (*env)->SetObjectField(env, bisdo->icm, colorDataID, colorData);
            Disposer_AddRecord(env, colorData, BufImg_Dispose_ICMColorData, pData);
        }
    }

    return cData;
}