/*

 * Copyright 1999-2007 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

#include "BufImgSurfaceData.h"

#include "malloc.h"

#include "sun_awt_image_BufImgSurfaceData.h"

#include "img_util_md.h"

#include "jni_util.h"

/* Define uintptr_t */

#include "gdefs.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         CMpDataID;

static jfieldID         allGrayID;

/*

 * Class:     sun_awt_image_BufImgSurfaceData

 * Method:    initIDs

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_sun_awt_image_BufImgSurfaceData_initIDs

    (JNIEnv *env, jclass bisd, jclass icm)

{

    if (sizeof(BufImgRIPrivate) > SD_RASINFO_PRIVATE_SIZE) {

        JNU_ThrowInternalError(env, "Private RasInfo structure too large!");

        return;

    }

    rgbID = (*env)->GetFieldID(env, icm, "rgb", "[I");

    allGrayID = (*env)->GetFieldID(env, icm, "allgrayopaque", "Z");

    mapSizeID = (*env)->GetFieldID(env, icm, "map_size", "I");

    CMpDataID = (*env)->GetFieldID(env, icm, "pData", "J");

    if (allGrayID == 0 || rgbID == 0 || mapSizeID == 0 || CMpDataID == 0) {

        JNU_ThrowInternalError(env, "Could not get field IDs");

    }

}

/*

 * Class:     sun_java2d_SurfaceData

 * Method:    freeNativeICMData

 * Signature: (Ljava/awt/image/IndexColorModel;)V

 */

JNIEXPORT void JNICALL

Java_sun_awt_image_BufImgSurfaceData_freeNativeICMData

    (JNIEnv *env, jclass sd, jobject icm)

{

    jlong pData;

    ColorData *cdata;

    if (JNU_IsNull(env, icm)) {

        JNU_ThrowNullPointerException(env, "IndexColorModel cannot be null");

        return;

    }

    pData = (*env)->GetLongField (env, icm, CMpDataID);

    cdata = (ColorData *)pData;

    freeICMColorData(cdata);

}

/*

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

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

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

        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;

}

/*

 * 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) {

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

    }

    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;

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

    }

}

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 ColorData *BufImg_SetupICM(JNIEnv *env,

                                  BufImgSDOps *bisdo)

{

    ColorData *cData;

    if (JNU_IsNull(env, bisdo->icm)) {

        return (ColorData *) NULL;

    }

    cData = (ColorData *) JNU_GetLongFieldAsPtr(env, bisdo->icm, CMpDataID);

    if (cData == NULL) {

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

            cData->img_clr_tbl = initCubemap(pRgb, bisdo->lutsize, 32);

            if (allGray == JNI_TRUE) {

                initInverseGrayLut(pRgb, bisdo->lutsize, cData);

            }

            (*env)->ReleasePrimitiveArrayCritical(env, bisdo->lutarray, pRgb,

                                                  JNI_ABORT);

            initDitherTables(cData);

            JNU_SetLongFieldFromPtr(env, bisdo->icm, CMpDataID, cData);

        }

    }

    return cData;

}