/*

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

 */

/*

 * This file contains the code to link the Java Image I/O JPEG plug-in

 * to the IJG library used to read and write JPEG files.  Much of it has

 * been copied, updated, and annotated from the jpegdecoder.c AWT JPEG

 * decoder.  Where that code was unclear, the present author has either

 * rewritten the relevant section or commented it for the sake of future

 * maintainers.

 *

 * In particular, the way the AWT code handled progressive JPEGs seems

 * to me to be only accidentally correct and somewhat inefficient.  The

 * scheme used here represents the way I think it should work. (REV 11/00)

 */

#include <stdlib.h>

#include <setjmp.h>

#include <assert.h>

#include <string.h>

/* java native interface headers */

#include "jni.h"

#include "jni_util.h"

#include "com_sun_imageio_plugins_jpeg_JPEGImageReader.h"

#include "com_sun_imageio_plugins_jpeg_JPEGImageWriter.h"

/* headers from the JPEG library */

#include <jpeglib.h>

#include "jerror.h"

#undef MAX

#define MAX(a,b)        ((a) > (b) ? (a) : (b))

/* Cached Java method ids */

static jmethodID ImageInputStream_readID;

static jmethodID ImageInputStream_skipBytesID;

static jmethodID JPEGImageReader_warningOccurredID;

static jmethodID JPEGImageReader_warningWithMessageID;

static jmethodID JPEGImageReader_setImageDataID;

static jmethodID JPEGImageReader_acceptPixelsID;

static jmethodID JPEGImageReader_pushBackID;

static jmethodID JPEGImageReader_passStartedID;

static jmethodID JPEGImageReader_passCompleteID;

static jmethodID ImageOutputStream_writeID;

static jmethodID JPEGImageWriter_warningOccurredID;

static jmethodID JPEGImageWriter_warningWithMessageID;

static jmethodID JPEGImageWriter_writeMetadataID;

static jmethodID JPEGImageWriter_grabPixelsID;

static jfieldID JPEGQTable_tableID;

static jfieldID JPEGHuffmanTable_lengthsID;

static jfieldID JPEGHuffmanTable_valuesID;

/*

 * Defined in jpegdecoder.c.  Copy code from there if and

 * when that disappears. */

extern JavaVM *jvm;

/*

 * The following sets of defines must match the warning messages in the

 * Java code.

 */

/* Reader warnings */

#define READ_NO_EOI          0

/* Writer warnings */

/* Return codes for various ops */

#define OK     1

#define NOT_OK 0

/*

 * First we define two objects, one for the stream and buffer and one

 * for pixels.  Both contain references to Java objects and pointers to

 * pinned arrays.  These objects can be used for either input or

 * output.  Pixels can be accessed as either INT32s or bytes.

 * Every I/O operation will have one of each these objects, one for

 * the stream and the other to hold pixels, regardless of the I/O direction.

 */

/******************** StreamBuffer definition ************************/

typedef struct streamBufferStruct {

    jobject stream;            // ImageInputStream or ImageOutputStream

    jbyteArray hstreamBuffer;  // Handle to a Java buffer for the stream

    JOCTET *buf;               // Pinned buffer pointer */

    int bufferOffset;          // holds offset between unpin and the next pin

    int bufferLength;          // Allocated, nut just used

    int suspendable;           // Set to true to suspend input

    long remaining_skip;       // Used only on input

} streamBuffer, *streamBufferPtr;

/*

 * This buffer size was set to 64K in the old classes, 4K by default in the

 * IJG library, with the comment "an efficiently freadable size", and 1K

 * in AWT.

 * Unlike in the other Java designs, these objects will persist, so 64K

 * seems too big and 1K seems too small.  If 4K was good enough for the

 * IJG folks, it's good enough for me.

 */

#define STREAMBUF_SIZE 4096

/*

 * Used to signal that no data need be restored from an unpin to a pin.

 * I.e. the buffer is empty.

 */

#define NO_DATA -1

// Forward reference

static void resetStreamBuffer(JNIEnv *env, streamBufferPtr sb);

/*

 * Initialize a freshly allocated StreamBuffer object.  The stream is left

 * null, as it will be set from Java by setSource, but the buffer object

 * is created and a global reference kept.  Returns OK on success, NOT_OK

 * if allocating the buffer or getting a global reference for it failed.

 */

static int initStreamBuffer(JNIEnv *env, streamBufferPtr sb) {

    /* Initialize a new buffer */

    jbyteArray hInputBuffer = (*env)->NewByteArray(env, STREAMBUF_SIZE);

    if (hInputBuffer == NULL) {

        JNU_ThrowByName( env,

                         "java/lang/OutOfMemoryError",

                         "Initializing Reader");

        return NOT_OK;

    }

    sb->bufferLength = (*env)->GetArrayLength(env, hInputBuffer);

    sb->hstreamBuffer = (*env)->NewGlobalRef(env, hInputBuffer);

    if (sb->hstreamBuffer == NULL) {

        JNU_ThrowByName( env,

                         "java/lang/OutOfMemoryError",

                         "Initializing Reader");

        return NOT_OK;

    }

    sb->stream = NULL;

    sb->buf = NULL;

    resetStreamBuffer(env, sb);

    return OK;

}

/*

 * Free all resources associated with this streamBuffer.  This must

 * be called to dispose the object to avoid leaking global references, as

 * resetStreamBuffer does not release the buffer reference.

 */

static void destroyStreamBuffer(JNIEnv *env, streamBufferPtr sb) {

    resetStreamBuffer(env, sb);

    if (sb->hstreamBuffer != NULL) {

        (*env)->DeleteGlobalRef(env, sb->hstreamBuffer);

    }

}

// Forward reference

static void unpinStreamBuffer(JNIEnv *env,

                              streamBufferPtr sb,

                              const JOCTET *next_byte);

/*

 * Resets the state of a streamBuffer object that has been in use.

 * The global reference to the stream is released, but the reference

 * to the buffer is retained.  The buffer is unpinned if it was pinned.

 * All other state is reset.

 */

static void resetStreamBuffer(JNIEnv *env, streamBufferPtr sb) {

    if (sb->stream != NULL) {

        (*env)->DeleteGlobalRef(env, sb->stream);

        sb->stream = NULL;

    }

    unpinStreamBuffer(env, sb, NULL);

    sb->bufferOffset = NO_DATA;

    sb->suspendable = FALSE;

    sb->remaining_skip = 0;

}

/*

 * Pins the data buffer associated with this stream.  Returns OK on

 * success, NOT_OK on failure, as GetPrimitiveArrayCritical may fail.

 */

static int pinStreamBuffer(JNIEnv *env,

                           streamBufferPtr sb,

                           const JOCTET **next_byte) {

    if (sb->hstreamBuffer != NULL) {

        assert(sb->buf == NULL);

        sb->buf =

            (JOCTET *)(*env)->GetPrimitiveArrayCritical(env,

                                                        sb->hstreamBuffer,

                                                        NULL);

        if (sb->buf == NULL) {

            return NOT_OK;

        }

        if (sb->bufferOffset != NO_DATA) {

            *next_byte = sb->buf + sb->bufferOffset;

        }

    }

    return OK;

}

/*

 * Unpins the data buffer associated with this stream.

 */

static void unpinStreamBuffer(JNIEnv *env,

                              streamBufferPtr sb,

                              const JOCTET *next_byte) {

    if (sb->buf != NULL) {

        assert(sb->hstreamBuffer != NULL);

        if (next_byte == NULL) {

            sb->bufferOffset = NO_DATA;

        } else {

            sb->bufferOffset = next_byte - sb->buf;

        }

        (*env)->ReleasePrimitiveArrayCritical(env,

                                              sb->hstreamBuffer,

                                              sb->buf,

                                              0);

        sb->buf = NULL;

    }

}

/*

 * Clear out the streamBuffer.  This just invalidates the data in the buffer.

 */

static void clearStreamBuffer(streamBufferPtr sb) {

    sb->bufferOffset = NO_DATA;

}

/*************************** end StreamBuffer definition *************/

/*************************** Pixel Buffer definition ******************/

typedef struct pixelBufferStruct {

    jobject hpixelObject;   // Usually a DataBuffer bank as a byte array

    union pixptr {

        INT32         *ip;  // Pinned buffer pointer, as 32-bit ints

        unsigned char *bp;  // Pinned buffer pointer, as bytes

    } buf;

} pixelBuffer, *pixelBufferPtr;

/*

 * Initialize a freshly allocated PixelBuffer.  All fields are simply

 * set to NULL, as we have no idea what size buffer we will need.

 */

static void initPixelBuffer(pixelBufferPtr pb) {

    pb->hpixelObject = NULL;

    pb->buf.ip = NULL;

}

/*

 * Set the pixelBuffer to use the given buffer, acquiring a new global

 * reference for it.  Returns OK on success, NOT_OK on failure.

 */

static int setPixelBuffer(JNIEnv *env, pixelBufferPtr pb, jobject obj) {

    pb->hpixelObject = (*env)->NewGlobalRef(env, obj);

    if (pb->hpixelObject == NULL) {

        JNU_ThrowByName( env,

                         "java/lang/OutOfMemoryError",

                         "Setting Pixel Buffer");

        return NOT_OK;

    }

    return OK;

}

// Forward reference

static void unpinPixelBuffer(JNIEnv *env, pixelBufferPtr pb);

/*

 * Resets a pixel buffer to its initial state.  Unpins any pixel buffer,

 * releases the global reference, and resets fields to NULL.  Use this

 * method to dispose the object as well (there is no destroyPixelBuffer).

 */

static void resetPixelBuffer(JNIEnv *env, pixelBufferPtr pb) {

    if (pb->hpixelObject != NULL) {

        unpinPixelBuffer(env, pb);

        (*env)->DeleteGlobalRef(env, pb->hpixelObject);

        pb->hpixelObject = NULL;

    }

}

/*

 * Pins the data buffer.  Returns OK on success, NOT_OK on failure.

 */

static int pinPixelBuffer(JNIEnv *env, pixelBufferPtr pb) {

    if (pb->hpixelObject != NULL) {

        assert(pb->buf.ip == NULL);

        pb->buf.bp = (unsigned char *)(*env)->GetPrimitiveArrayCritical

            (env, pb->hpixelObject, NULL);

        if (pb->buf.bp == NULL) {

            return NOT_OK;

        }

    }

    return OK;

}

/*

 * Unpins the data buffer.

 */

static void unpinPixelBuffer(JNIEnv *env, pixelBufferPtr pb) {

    if (pb->buf.ip != NULL) {

        assert(pb->hpixelObject != NULL);

        (*env)->ReleasePrimitiveArrayCritical(env,

                                              pb->hpixelObject,

                                              pb->buf.ip,

                                              0);

        pb->buf.ip = NULL;

    }

}

/********************* end PixelBuffer definition *******************/

/********************* ImageIOData definition ***********************/

#define MAX_BANDS 4

#define JPEG_BAND_SIZE 8

#define NUM_BAND_VALUES (1<<JPEG_BAND_SIZE)

#define MAX_JPEG_BAND_VALUE (NUM_BAND_VALUES-1)

#define HALF_MAX_JPEG_BAND_VALUE (MAX_JPEG_BAND_VALUE>>1)

/* The number of possible incoming values to be scaled. */

#define NUM_INPUT_VALUES (1 << 16)

/*

 * The principal imageioData object, opaque to I/O direction.

 * Each JPEGImageReader will have associated with it a

 * jpeg_decompress_struct, and similarly each JPEGImageWriter will

 * have associated with it a jpeg_compress_struct.  In order to

 * ensure that these associations persist from one native call to

 * the next, and to provide a central locus of imageio-specific

 * data, we define an imageioData struct containing references

 * to the Java object and the IJG structs.  The functions

 * that manipulate these objects know whether input or output is being

 * performed and therefore know how to manipulate the contents correctly.

 * If for some reason they don't, the direction can be determined by

 * checking the is_decompressor field of the jpegObj.

 * In order for lower level code to determine a

 * Java object given an IJG struct, such as for dispatching warnings,

 * we use the client_data field of the jpeg object to store a pointer

 * to the imageIOData object.  Maintenance of this pointer is performed

 * exclusively within the following access functions.  If you

 * change that, you run the risk of dangling pointers.

 */

typedef struct imageIODataStruct {

    j_common_ptr jpegObj;     // Either struct is fine

    jobject imageIOobj;       // A JPEGImageReader or a JPEGImageWriter

    streamBuffer streamBuf;   // Buffer for the stream

    pixelBuffer pixelBuf;     // Buffer for pixels

    jboolean abortFlag;       // Passed down from Java abort method

} imageIOData, *imageIODataPtr;

/*

 * Allocate and initialize a new imageIOData object to associate the

 * jpeg object and the Java object.  Returns a pointer to the new object

 * on success, NULL on failure.

 */

static imageIODataPtr initImageioData (JNIEnv *env,

                                       j_common_ptr cinfo,

                                       jobject obj) {

    int i, j;

    imageIODataPtr data = (imageIODataPtr) malloc (sizeof(imageIOData));

    if (data == NULL) {

        return NULL;

    }

    data->jpegObj = cinfo;

    cinfo->client_data = data;

    printf("new structures: data is %p, cinfo is %p\n", data, cinfo);

#endif

    data->imageIOobj = (*env)->NewWeakGlobalRef(env, obj);

    if (data->imageIOobj == NULL) {

        free (data);

        return NULL;

    }

    if (initStreamBuffer(env, &data->streamBuf) == NOT_OK) {

        (*env)->DeleteWeakGlobalRef(env, data->imageIOobj);

        free (data);

        return NULL;

    }

    initPixelBuffer(&data->pixelBuf);

    data->abortFlag = JNI_FALSE;

    return data;

}

/*

 * Resets the imageIOData object to its initial state, as though

 * it had just been allocated and initialized.

 */

static void resetImageIOData(JNIEnv *env, imageIODataPtr data) {

    resetStreamBuffer(env, &data->streamBuf);

    resetPixelBuffer(env, &data->pixelBuf);

    data->abortFlag = JNI_FALSE;

}

/*

 * Releases all resources held by this object and its subobjects,

 * frees the object, and returns the jpeg object.  This method must

 * be called to avoid leaking global references.

 * Note that the jpeg object is not freed or destroyed, as that is

 * the client's responsibility, although the client_data field is

 * cleared.

 */

static j_common_ptr destroyImageioData(JNIEnv *env, imageIODataPtr data) {

    j_common_ptr ret = data->jpegObj;

    (*env)->DeleteWeakGlobalRef(env, data->imageIOobj);

    destroyStreamBuffer(env, &data->streamBuf);

    resetPixelBuffer(env, &data->pixelBuf);

    ret->client_data = NULL;

    free(data);

    return ret;

}

/******************** end ImageIOData definition ***********************/

/******************** Java array pinning and unpinning *****************/

/* We use Get/ReleasePrimitiveArrayCritical functions to avoid

 * the need to copy array elements for the above two objects.

 *

 * MAKE SURE TO:

 *

 * - carefully insert pairs of RELEASE_ARRAYS and GET_ARRAYS around

 *   callbacks to Java.

 * - call RELEASE_ARRAYS before returning to Java.

 *

 * Otherwise things will go horribly wrong. There may be memory leaks,

 * excessive pinning, or even VM crashes!

 *

 * Note that GetPrimitiveArrayCritical may fail!

 */

/*

 * Release (unpin) all the arrays in use during a read.

 */

static void RELEASE_ARRAYS(JNIEnv *env, imageIODataPtr data, const JOCTET *next_byte)

{

    unpinStreamBuffer(env, &data->streamBuf, next_byte);

    unpinPixelBuffer(env, &data->pixelBuf);

}

/*

 * Get (pin) all the arrays in use during a read.

 */

static int GET_ARRAYS(JNIEnv *env, imageIODataPtr data, const JOCTET **next_byte) {

    if (pinStreamBuffer(env, &data->streamBuf, next_byte) == NOT_OK) {

        return NOT_OK;

    }

    if (pinPixelBuffer(env, &data->pixelBuf) == NOT_OK) {

        RELEASE_ARRAYS(env, data, *next_byte);

        return NOT_OK;

    }

    return OK;

}

/****** end of Java array pinning and unpinning ***********/

/****** Error Handling *******/

/*

 * Set up error handling to use setjmp/longjmp.  This is the third such

 * setup, as both the AWT jpeg decoder and the com.sun... JPEG classes

 * setup thier own.  Ultimately these should be integrated, as they all

 * do pretty much the same thing.

 */

struct sun_jpeg_error_mgr {

  struct jpeg_error_mgr pub;    /* "public" fields */

  jmp_buf setjmp_buffer;        /* for return to caller */

};

typedef struct sun_jpeg_error_mgr * sun_jpeg_error_ptr;

/*

 * Here's the routine that will replace the standard error_exit method:

 */

METHODDEF(void)

sun_jpeg_error_exit (j_common_ptr cinfo)

{

  /* cinfo->err really points to a sun_jpeg_error_mgr struct */

  sun_jpeg_error_ptr myerr = (sun_jpeg_error_ptr) cinfo->err;

  /* For Java, we will format the message and put it in the error we throw. */

  /* Return control to the setjmp point */

  longjmp(myerr->setjmp_buffer, 1);

}

/*