/home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/imageioJPEG.c

Bug Summary

File:	jdk/src/java.desktop/share/native/libjavajpeg/imageioJPEG.c
Warning:	line 999, column 20 Array access (via field 'buf') results in a null pointer dereference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name imageioJPEG.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.desktop -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused -Wno-clobbered -Wno-implicit-fallthrough -Wno-shift-negative-value -Wno-array-bounds -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/imageioJPEG.c
1/*
* Copyright (c) 2000, 2016, 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.
*/

26/*
* 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)
*/

39#include <stdlib.h>
40#include <setjmp.h>
41#include <assert.h>
42#include <string.h>
43#include <limits.h>

45/* java native interface headers */
46#include "jni.h"
47#include "jni_util.h"

49#include "com_sun_imageio_plugins_jpeg_JPEGImageReader.h"
50#include "com_sun_imageio_plugins_jpeg_JPEGImageWriter.h"

52/* headers from the JPEG library */
53#include <jpeglib.h>
54#include <jerror.h>

56#undef MAX
57#define MAX(a,b)((a) > (b) ? (a) : (b))        ((a) > (b) ? (a) : (b))

59#ifdef __APPLE__
60/* use setjmp/longjmp versions that do not save/restore the signal mask */
61#define setjmp _setjmp
62#define longjmp _longjmp
63#endif

65/* Cached Java method ids */
66static jmethodID JPEGImageReader_readInputDataID;
67static jmethodID JPEGImageReader_skipInputBytesID;
68static jmethodID JPEGImageReader_warningOccurredID;
69static jmethodID JPEGImageReader_warningWithMessageID;
70static jmethodID JPEGImageReader_setImageDataID;
71static jmethodID JPEGImageReader_acceptPixelsID;
72static jmethodID JPEGImageReader_pushBackID;
73static jmethodID JPEGImageReader_passStartedID;
74static jmethodID JPEGImageReader_passCompleteID;
75static jmethodID JPEGImageReader_skipPastImageID;
76static jmethodID JPEGImageWriter_writeOutputDataID;
77static jmethodID JPEGImageWriter_warningOccurredID;
78static jmethodID JPEGImageWriter_warningWithMessageID;
79static jmethodID JPEGImageWriter_writeMetadataID;
80static jmethodID JPEGImageWriter_grabPixelsID;
81static jfieldID JPEGQTable_tableID;
82static jfieldID JPEGHuffmanTable_lengthsID;
83static jfieldID JPEGHuffmanTable_valuesID;

85/*
* Defined in jpegdecoder.c.  Copy code from there if and
* when that disappears. */
88extern JavaVM *the_jvm;

90/*
* The following sets of defines must match the warning messages in the
* Java code.
*/

95/* Reader warnings */
96#define READ_NO_EOI0          0

98/* Writer warnings */

100/* Return codes for various ops */
101#define OK1     1
102#define NOT_OK0 0

104/*
* 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.
*/

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

115typedef struct streamBufferStruct {
  jweak ioRef;               // weak reference to a provider of I/O routines
  jbyteArray hstreamBuffer;  // Handle to a Java buffer for the stream
  JOCTET *buf;               // Pinned buffer pointer */
  size_t bufferOffset;          // holds offset between unpin and the next pin
  size_t bufferLength;          // Allocated, nut just used
  int suspendable;           // Set to true to suspend input
  long remaining_skip;       // Used only on input
123} streamBuffer, *streamBufferPtr;

125/*
* 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.
*/
133#define STREAMBUF_SIZE4096 4096

135#define GET_IO_REF(io_name)do { if ((*env)->IsSameObject(env, sb->ioRef, ((void*)0
)) || ((io_name) = (*env)->NewLocalRef(env, sb->ioRef))
 == ((void*)0)) { cinfo->err->error_exit((j_common_ptr)
 cinfo); } } while (0)                                            \
  do {                                                               \
      if ((*env)->IsSameObject(env, sb->ioRef, NULL((void*)0)) ||              \
          ((io_name) = (*env)->NewLocalRef(env, sb->ioRef)) == NULL((void*)0)) \
      {                                                              \
          cinfo->err->error_exit((j_common_ptr) cinfo);              \
      }                                                              \
  } while (0)                                                        \

144/*
* Used to signal that no data need be restored from an unpin to a pin.
* I.e. the buffer is empty.
*/
148#define NO_DATA((size_t)-1) ((size_t)-1)

150// Forward reference
151static void resetStreamBuffer(JNIEnv *env, streamBufferPtr sb);

153/*
* 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.
*/
159static int initStreamBuffer(JNIEnv *env, streamBufferPtr sb) {
  /* Initialize a new buffer */
  jbyteArray hInputBuffer = (*env)->NewByteArray(env, STREAMBUF_SIZE4096);
  if (hInputBuffer == NULL((void*)0)) {
      (*env)->ExceptionClear(env);
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Reader");
      return NOT_OK0;
  }
  sb->bufferLength = (*env)->GetArrayLength(env, hInputBuffer);
  sb->hstreamBuffer = (*env)->NewGlobalRef(env, hInputBuffer);
  if (sb->hstreamBuffer == NULL((void*)0)) {
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Reader");
      return NOT_OK0;
  }


  sb->ioRef = NULL((void*)0);

  sb->buf = NULL((void*)0);

  resetStreamBuffer(env, sb);

  return OK1;
186}

188/*
* 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.
*/
193static void destroyStreamBuffer(JNIEnv *env, streamBufferPtr sb) {
  resetStreamBuffer(env, sb);
  if (sb->hstreamBuffer != NULL((void*)0)) {
      (*env)->DeleteGlobalRef(env, sb->hstreamBuffer);
  }
198}

200// Forward reference
201static void unpinStreamBuffer(JNIEnv *env,
                            streamBufferPtr sb,
                            const JOCTET *next_byte);
204/*
* 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.
*/
210static void resetStreamBuffer(JNIEnv *env, streamBufferPtr sb) {
  if (sb->ioRef != NULL((void*)0)) {
      (*env)->DeleteWeakGlobalRef(env, sb->ioRef);
      sb->ioRef = NULL((void*)0);
  }
  unpinStreamBuffer(env, sb, NULL((void*)0));
  sb->bufferOffset = NO_DATA((size_t)-1);
  sb->suspendable = FALSE0;
  sb->remaining_skip = 0;
219}

221/*
* Pins the data buffer associated with this stream.  Returns OK on
* success, NOT_OK on failure, as GetPrimitiveArrayCritical may fail.
*/
225static int pinStreamBuffer(JNIEnv *env,
                         streamBufferPtr sb,
                         const JOCTET **next_byte) {
  if (sb->hstreamBuffer != NULL((void*)0)) {
      assert(sb->buf == NULL)((sb->buf == ((void*)0)) ? (void) (0) : __assert_fail ("sb->buf == NULL"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/imageioJPEG.c"
, 229, __extension__ __PRETTY_FUNCTION__));
      sb->buf =
          (JOCTET *)(*env)->GetPrimitiveArrayCritical(env,
                                                      sb->hstreamBuffer,
                                                      NULL((void*)0));
      if (sb->buf == NULL((void*)0)) {
          return NOT_OK0;
      }
      if (sb->bufferOffset != NO_DATA((size_t)-1)) {
          *next_byte = sb->buf + sb->bufferOffset;
      }
  }
  return OK1;
242}

244/*
* Unpins the data buffer associated with this stream.
*/
247static void unpinStreamBuffer(JNIEnv *env,
                            streamBufferPtr sb,
                            const JOCTET *next_byte) {
  if (sb->buf22.1
Field 'buf' is not equal to NULL
 != NULL((void*)0)) {
7
←
Assuming field 'buf' is equal to NULL→
8
←
Taking false branch→
23
←
Taking true branch→
      assert(sb->hstreamBuffer != NULL)((sb->hstreamBuffer != ((void*)0)) ? (void) (0) : __assert_fail
 ("sb->hstreamBuffer != NULL", "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/imageioJPEG.c"
, 251, __extension__ __PRETTY_FUNCTION__));
24
←
'?' condition is true→
      if (next_byte == NULL((void*)0)) {
25
←
Assuming 'next_byte' is equal to NULL→
26
←
Taking true branch→
          sb->bufferOffset = NO_DATA((size_t)-1);
      } else {
          sb->bufferOffset = next_byte - sb->buf;
      }
      (*env)->ReleasePrimitiveArrayCritical(env,
                                            sb->hstreamBuffer,
                                            sb->buf,
                                            0);
      sb->buf = NULL((void*)0);
27
←
Null pointer value stored to field 'buf'→
  }
263}
9
←
Returning without writing to 'sb->buf'→

265/*
* Clear out the streamBuffer.  This just invalidates the data in the buffer.
*/
268static void clearStreamBuffer(streamBufferPtr sb) {
  sb->bufferOffset = NO_DATA((size_t)-1);
270}

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

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

276typedef struct pixelBufferStruct {
  jobject hpixelObject;   // Usually a DataBuffer bank as a byte array
  unsigned int byteBufferLength;
  union pixptr {
      INT32         *ip;  // Pinned buffer pointer, as 32-bit ints
      unsigned char *bp;  // Pinned buffer pointer, as bytes
  } buf;
283} pixelBuffer, *pixelBufferPtr;

285/*
* Initialize a freshly allocated PixelBuffer.  All fields are simply
* set to NULL, as we have no idea what size buffer we will need.
*/
289static void initPixelBuffer(pixelBufferPtr pb) {
  pb->hpixelObject = NULL((void*)0);
  pb->byteBufferLength = 0;
  pb->buf.ip = NULL((void*)0);
293}

295/*
* Set the pixelBuffer to use the given buffer, acquiring a new global
* reference for it.  Returns OK on success, NOT_OK on failure.
*/
299static int setPixelBuffer(JNIEnv *env, pixelBufferPtr pb, jobject obj) {
  pb->hpixelObject = (*env)->NewGlobalRef(env, obj);
  if (pb->hpixelObject == NULL((void*)0)) {
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Setting Pixel Buffer");
      return NOT_OK0;
  }
  pb->byteBufferLength = (*env)->GetArrayLength(env, pb->hpixelObject);
  return OK1;
309}

311// Forward reference
312static void unpinPixelBuffer(JNIEnv *env, pixelBufferPtr pb);

314/*
* 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).
*/
319static void resetPixelBuffer(JNIEnv *env, pixelBufferPtr pb) {
  if (pb->hpixelObject != NULL((void*)0)) {
      unpinPixelBuffer(env, pb);
      (*env)->DeleteGlobalRef(env, pb->hpixelObject);
      pb->hpixelObject = NULL((void*)0);
      pb->byteBufferLength = 0;
  }
326}

328/*
* Pins the data buffer.  Returns OK on success, NOT_OK on failure.
*/
331static int pinPixelBuffer(JNIEnv *env, pixelBufferPtr pb) {
  if (pb->hpixelObject != NULL((void*)0)) {
      assert(pb->buf.ip == NULL)((pb->buf.ip == ((void*)0)) ? (void) (0) : __assert_fail (
"pb->buf.ip == NULL", "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/imageioJPEG.c"
, 333, __extension__ __PRETTY_FUNCTION__));
      pb->buf.bp = (unsigned char *)(*env)->GetPrimitiveArrayCritical
          (env, pb->hpixelObject, NULL((void*)0));
      if (pb->buf.bp == NULL((void*)0)) {
          return NOT_OK0;
      }
  }
  return OK1;
341}

343/*
* Unpins the data buffer.
*/
346static void unpinPixelBuffer(JNIEnv *env, pixelBufferPtr pb) {

  if (pb->buf.ip != NULL((void*)0)) {
      assert(pb->hpixelObject != NULL)((pb->hpixelObject != ((void*)0)) ? (void) (0) : __assert_fail
 ("pb->hpixelObject != NULL", "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/imageioJPEG.c"
, 349, __extension__ __PRETTY_FUNCTION__));
      (*env)->ReleasePrimitiveArrayCritical(env,
                                            pb->hpixelObject,
                                            pb->buf.ip,
                                            0);
      pb->buf.ip = NULL((void*)0);
  }
356}

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

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

362#define MAX_BANDS4 4
363#define JPEG_BAND_SIZE8 8
364#define NUM_BAND_VALUES(1<<8) (1<<JPEG_BAND_SIZE8)
365#define MAX_JPEG_BAND_VALUE((1<<8)-1) (NUM_BAND_VALUES(1<<8)-1)
366#define HALF_MAX_JPEG_BAND_VALUE(((1<<8)-1)>>1) (MAX_JPEG_BAND_VALUE((1<<8)-1)>>1)

368/* The number of possible incoming values to be scaled. */
369#define NUM_INPUT_VALUES(1 << 16) (1 << 16)

371/*
* 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.
*/
391typedef 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
399} imageIOData, *imageIODataPtr;

401/*
* 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.
*/
406static imageIODataPtr initImageioData (JNIEnv *env,
                                     j_common_ptr cinfo,
                                     jobject obj) {

  imageIODataPtr data = (imageIODataPtr) malloc (sizeof(imageIOData));
  if (data == NULL((void*)0)) {
      return NULL((void*)0);
  }

  data->jpegObj = cinfo;
  cinfo->client_data = data;

418#ifdef DEBUG_IIO_JPEG
  printf("new structures: data is %p, cinfo is %p\n", data, cinfo)__printf_chk (2 - 1, "new structures: data is %p, cinfo is %p\n"
, data, cinfo);
420#endif

  data->imageIOobj = (*env)->NewWeakGlobalRef(env, obj);
  if (data->imageIOobj == NULL((void*)0)) {
      free (data);
      return NULL((void*)0);
  }
  if (initStreamBuffer(env, &data->streamBuf) == NOT_OK0) {
      (*env)->DeleteWeakGlobalRef(env, data->imageIOobj);
      free (data);
      return NULL((void*)0);
  }
  initPixelBuffer(&data->pixelBuf);

  data->abortFlag = JNI_FALSE0;

  return data;
437}

439/*
* Resets the imageIOData object to its initial state, as though
* it had just been allocated and initialized.
*/
443static void resetImageIOData(JNIEnv *env, imageIODataPtr data) {
  resetStreamBuffer(env, &data->streamBuf);
  resetPixelBuffer(env, &data->pixelBuf);
  data->abortFlag = JNI_FALSE0;
447}

449/*
* 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.
*/
457static 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((void*)0);
  free(data);
  return ret;
465}

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

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

471/* 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!
*/

486/*
* Release (unpin) all the arrays in use during a read.
*/
489static void RELEASE_ARRAYS(JNIEnv *env, imageIODataPtr data, const JOCTET *next_byte)
490{
  unpinStreamBuffer(env, &data->streamBuf, next_byte);
6
←
Calling 'unpinStreamBuffer'→
10
←
Returning from 'unpinStreamBuffer'→
22
←
Calling 'unpinStreamBuffer'→
28
←
Returning from 'unpinStreamBuffer'→

  unpinPixelBuffer(env, &data->pixelBuf);

495}
11
←
Returning without writing to 'data->streamBuf.buf'→

497/*
* Get (pin) all the arrays in use during a read.
*/
500static int GET_ARRAYS(JNIEnv *env, imageIODataPtr data, const JOCTET **next_byte) {
  if (pinStreamBuffer(env, &data->streamBuf, next_byte) == NOT_OK0) {
      return NOT_OK0;
  }

  if (pinPixelBuffer(env, &data->pixelBuf) == NOT_OK0) {
      RELEASE_ARRAYS(env, data, *next_byte);
      return NOT_OK0;
  }
  return OK1;
510}

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

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

516/*
* 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.
*/

523struct sun_jpeg_error_mgr {
struct jpeg_error_mgr pub;    /* "public" fields */

jmp_buf setjmp_buffer;        /* for return to caller */
527};

529typedef struct sun_jpeg_error_mgr * sun_jpeg_error_ptr;

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

535METHODDEF(void)static void
536sun_jpeg_error_exit (j_common_ptr cinfo)
537{
/* 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);
545}

547/*
* Error Message handling
*
* This overrides the output_message method to send JPEG messages
*
*/

554METHODDEF(void)static void
555sun_jpeg_output_message (j_common_ptr cinfo)
556{
  char buffer[JMSG_LENGTH_MAX200];
  jstring string;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);
  jobject theObject;

  /* Create the message */
  (*cinfo->err->format_message) (cinfo, buffer);

  // Create a new java string from the message
  string = (*env)->NewStringUTF(env, buffer);
  CHECK_NULL(string)do { if ((string) == ((void*)0)) { return; } } while (0);

  theObject = data->imageIOobj;

  if (cinfo->is_decompressor) {
      struct jpeg_source_mgr *src = ((j_decompress_ptr)cinfo)->src;
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      (*env)->CallVoidMethod(env, theObject,
          JPEGImageReader_warningWithMessageID,
          string);
      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
          cinfo->err->error_exit(cinfo);
      }
  } else {
      struct jpeg_destination_mgr *dest = ((j_compress_ptr)cinfo)->dest;
      RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));
      (*env)->CallVoidMethod(env, theObject,
          JPEGImageWriter_warningWithMessageID,
          string);
      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data,
          (const JOCTET **)(&dest->next_output_byte))) {
          cinfo->err->error_exit(cinfo);
      }
  }
594}

596/* End of verbatim copy from jpegdecoder.c */

598/*************** end of error handling *********************/

600/*************** Shared utility code ***********************/

602static void imageio_set_stream(JNIEnv *env,
                             j_common_ptr cinfo,
                             imageIODataPtr data,
                             jobject io){
  streamBufferPtr sb;
  sun_jpeg_error_ptr jerr;

  sb = &data->streamBuf;

  resetStreamBuffer(env, sb);  // Removes any old stream

  /* Now we need a new weak global reference for the I/O provider */
  if (io != NULL((void*)0)) { // Fix for 4411955
      sb->ioRef = (*env)->NewWeakGlobalRef(env, io);
      CHECK_NULL(sb->ioRef)do { if ((sb->ioRef) == ((void*)0)) { return; } } while (0
);
  }

  /* And finally reset state */
  data->abortFlag = JNI_FALSE0;

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  jerr = (sun_jpeg_error_ptr) cinfo->err;

  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error
         while aborting. */
      if (!(*env)->ExceptionOccurred(env)) {
          char buffer[JMSG_LENGTH_MAX200];
          (*cinfo->err->format_message) (cinfo,
                                         buffer);
          JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      }
      return;
  }

  jpeg_abortjAbort(cinfo);  // Frees any markers, but not tables

639}

641static void imageio_reset(JNIEnv *env,
                        j_common_ptr cinfo,
                        imageIODataPtr data) {
  sun_jpeg_error_ptr jerr;

  resetImageIOData(env, data);  // Mapping to jpeg object is retained.

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  jerr = (sun_jpeg_error_ptr) cinfo->err;

  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error
         while aborting. */
      if (!(*env)->ExceptionOccurred(env)) {
          char buffer[JMSG_LENGTH_MAX200];
          (*cinfo->err->format_message) (cinfo, buffer);
          JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      }
      return;
  }

  jpeg_abortjAbort(cinfo);  // Does not reset tables

664}

666static void imageio_dispose(j_common_ptr info) {

  if (info != NULL((void*)0)) {
      free(info->err);
      info->err = NULL((void*)0);
      if (info->is_decompressor) {
          j_decompress_ptr dinfo = (j_decompress_ptr) info;
          free(dinfo->src);
          dinfo->src = NULL((void*)0);
      } else {
          j_compress_ptr cinfo = (j_compress_ptr) info;
          free(cinfo->dest);
          cinfo->dest = NULL((void*)0);
      }
      jpeg_destroyjDestroy(info);
      free(info);
  }
683}

685static void imageio_abort(JNIEnv *env, jobject this,
                        imageIODataPtr data) {
  data->abortFlag = JNI_TRUE1;
688}

690static int setQTables(JNIEnv *env,
                    j_common_ptr cinfo,
                    jobjectArray qtables,
                    boolean write) {
  jsize qlen;
  jobject table;
  jintArray qdata;
  jint *qdataBody;
  JQUANT_TBL *quant_ptr;
  int i, j;
  j_compress_ptr comp;
  j_decompress_ptr decomp;

  qlen = (*env)->GetArrayLength(env, qtables);
704#ifdef DEBUG_IIO_JPEG
  printf("in setQTables, qlen = %d, write is %d\n", qlen, write)__printf_chk (2 - 1, "in setQTables, qlen = %d, write is %d\n"
, qlen, write);
706#endif
  if (qlen > NUM_QUANT_TBLS4) {
      /* Ignore extra qunterization tables. */
      qlen = NUM_QUANT_TBLS4;
  }
  for (i = 0; i < qlen; i++) {
      table = (*env)->GetObjectArrayElement(env, qtables, i);
      CHECK_NULL_RETURN(table, 0)do { if ((table) == ((void*)0)) { return (0); } } while (0);
      qdata = (*env)->GetObjectField(env, table, JPEGQTable_tableID);
      qdataBody = (*env)->GetPrimitiveArrayCritical(env, qdata, NULL((void*)0));

      if (cinfo->is_decompressor) {
          decomp = (j_decompress_ptr) cinfo;
          if (decomp->quant_tbl_ptrs[i] == NULL((void*)0)) {
              decomp->quant_tbl_ptrs[i] =
                  jpeg_alloc_quant_tablejAlcQTable(cinfo);
          }
          quant_ptr = decomp->quant_tbl_ptrs[i];
      } else {
          comp = (j_compress_ptr) cinfo;
          if (comp->quant_tbl_ptrs[i] == NULL((void*)0)) {
              comp->quant_tbl_ptrs[i] =
                  jpeg_alloc_quant_tablejAlcQTable(cinfo);
          }
          quant_ptr = comp->quant_tbl_ptrs[i];
      }

      for (j = 0; j < 64; j++) {
          quant_ptr->quantval[j] = (UINT16)qdataBody[j];
      }
      quant_ptr->sent_table = !write;
      (*env)->ReleasePrimitiveArrayCritical(env,
                                            qdata,
                                            qdataBody,
                                            0);
  }
  return qlen;
743}

745static boolean setHuffTable(JNIEnv *env,
                       JHUFF_TBL *huff_ptr,
                       jobject table) {

  jshortArray huffLens;
  jshortArray huffValues;
  jshort *hlensBody, *hvalsBody;
  jsize hlensLen, hvalsLen;
  int i;

  // lengths
  huffLens = (*env)->GetObjectField(env,
                                    table,
                                    JPEGHuffmanTable_lengthsID);
  hlensLen = (*env)->GetArrayLength(env, huffLens);
  hlensBody = (*env)->GetShortArrayElements(env,
                                            huffLens,
                                            NULL((void*)0));
  CHECK_NULL_RETURN(hlensBody, FALSE)do { if ((hlensBody) == ((void*)0)) { return (0); } } while (
0);

  if (hlensLen > 16) {
      /* Ignore extra elements of bits array. Only 16 elements can be
         stored. 0-th element is not used. (see jpeglib.h, line 107)  */
      hlensLen = 16;
  }
  for (i = 1; i <= hlensLen; i++) {
      huff_ptr->bits[i] = (UINT8)hlensBody[i-1];
  }
  (*env)->ReleaseShortArrayElements(env,
                                    huffLens,
                                    hlensBody,
                                    JNI_ABORT2);
  // values
  huffValues = (*env)->GetObjectField(env,
                                      table,
                                      JPEGHuffmanTable_valuesID);
  hvalsLen = (*env)->GetArrayLength(env, huffValues);
  hvalsBody = (*env)->GetShortArrayElements(env,
                                            huffValues,
                                            NULL((void*)0));
  CHECK_NULL_RETURN(hvalsBody, FALSE)do { if ((hvalsBody) == ((void*)0)) { return (0); } } while (
0);

  if (hvalsLen > 256) {
      /* Ignore extra elements of hufval array. Only 256 elements
         can be stored. (see jpeglib.h, line 109)                  */
      hlensLen = 256;
  }
  for (i = 0; i < hvalsLen; i++) {
      huff_ptr->huffval[i] = (UINT8)hvalsBody[i];
  }
  (*env)->ReleaseShortArrayElements(env,
                                    huffValues,
                                    hvalsBody,
                                    JNI_ABORT2);
  return TRUE1;
800}

802static int setHTables(JNIEnv *env,
                    j_common_ptr cinfo,
                    jobjectArray DCHuffmanTables,
                    jobjectArray ACHuffmanTables,
                    boolean write) {
  int i;
  jobject table;
  JHUFF_TBL *huff_ptr;
  j_compress_ptr comp;
  j_decompress_ptr decomp;
  jsize hlen = (*env)->GetArrayLength(env, DCHuffmanTables);

  if (hlen > NUM_HUFF_TBLS4) {
      /* Ignore extra DC huffman tables. */
      hlen = NUM_HUFF_TBLS4;
  }
  for (i = 0; i < hlen; i++) {
      if (cinfo->is_decompressor) {
          decomp = (j_decompress_ptr) cinfo;
          if (decomp->dc_huff_tbl_ptrs[i] == NULL((void*)0)) {
              decomp->dc_huff_tbl_ptrs[i] =
                  jpeg_alloc_huff_tablejAlcHTable(cinfo);
          }
          huff_ptr = decomp->dc_huff_tbl_ptrs[i];
      } else {
          comp = (j_compress_ptr) cinfo;
          if (comp->dc_huff_tbl_ptrs[i] == NULL((void*)0)) {
              comp->dc_huff_tbl_ptrs[i] =
                  jpeg_alloc_huff_tablejAlcHTable(cinfo);
          }
          huff_ptr = comp->dc_huff_tbl_ptrs[i];
      }
      table = (*env)->GetObjectArrayElement(env, DCHuffmanTables, i);
      if (table == NULL((void*)0) || !setHuffTable(env, huff_ptr, table)) {
          return 0;
      }
      huff_ptr->sent_table = !write;
  }
  hlen = (*env)->GetArrayLength(env, ACHuffmanTables);
  if (hlen > NUM_HUFF_TBLS4) {
      /* Ignore extra AC huffman tables. */
      hlen = NUM_HUFF_TBLS4;
  }
  for (i = 0; i < hlen; i++) {
      if (cinfo->is_decompressor) {
          decomp = (j_decompress_ptr) cinfo;
          if (decomp->ac_huff_tbl_ptrs[i] == NULL((void*)0)) {
              decomp->ac_huff_tbl_ptrs[i] =
                  jpeg_alloc_huff_tablejAlcHTable(cinfo);
          }
          huff_ptr = decomp->ac_huff_tbl_ptrs[i];
      } else {
          comp = (j_compress_ptr) cinfo;
          if (comp->ac_huff_tbl_ptrs[i] == NULL((void*)0)) {
              comp->ac_huff_tbl_ptrs[i] =
                  jpeg_alloc_huff_tablejAlcHTable(cinfo);
          }
          huff_ptr = comp->ac_huff_tbl_ptrs[i];
      }
      table = (*env)->GetObjectArrayElement(env, ACHuffmanTables, i);
      if(table == NULL((void*)0) || !setHuffTable(env, huff_ptr, table)) {
          return 0;
      }
      huff_ptr->sent_table = !write;
  }
  return hlen;
868}


871/*************** end of shared utility code ****************/

873/********************** Reader Support **************************/

875/********************** Source Management ***********************/

877/*
* INPUT HANDLING:
*
* The JPEG library's input management is defined by the jpeg_source_mgr
* structure which contains two fields to convey the information in the
* buffer and 5 methods which perform all buffer management.  The library
* defines a standard input manager that uses stdio for obtaining compressed
* jpeg data, but here we need to use Java to get our data.
*
* We use the library jpeg_source_mgr but our own routines that access
* imageio-specific information in the imageIOData structure.
*/

890/*
* Initialize source.  This is called by jpeg_read_header() before any
* data is actually read.  Unlike init_destination(), it may leave
* bytes_in_buffer set to 0 (in which case a fill_input_buffer() call
* will occur immediately).
*/

897GLOBAL(void)void
898imageio_init_source(j_decompress_ptr cinfo)
899{
  struct jpeg_source_mgr *src = cinfo->src;
  src->next_input_byte = NULL((void*)0);
  src->bytes_in_buffer = 0;
903}

905/*
* This is called whenever bytes_in_buffer has reached zero and more
* data is wanted.  In typical applications, it should read fresh data
* into the buffer (ignoring the current state of next_input_byte and
* bytes_in_buffer), reset the pointer & count to the start of the
* buffer, and return TRUE indicating that the buffer has been reloaded.
* It is not necessary to fill the buffer entirely, only to obtain at
* least one more byte.  bytes_in_buffer MUST be set to a positive value
* if TRUE is returned.  A FALSE return should only be used when I/O
* suspension is desired (this mode is discussed in the next section).
*/
916/*
* Note that with I/O suspension turned on, this procedure should not
* do any work since the JPEG library has a very simple backtracking
* mechanism which relies on the fact that the buffer will be filled
* only when it has backed out to the top application level.  When
* suspendable is turned on, imageio_fill_suspended_buffer will
* do the actual work of filling the buffer.
*/

925GLOBAL(boolean)boolean
926imageio_fill_input_buffer(j_decompress_ptr cinfo)
927{
  struct jpeg_source_mgr *src = cinfo->src;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  streamBufferPtr sb = &data->streamBuf;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);
  int ret;
  jobject input = NULL((void*)0);

  /* This is where input suspends */
  if (sb->suspendable) {
1
Assuming field 'suspendable' is 0→
2
←
Taking false branch→
      return FALSE0;
  }

940#ifdef DEBUG_IIO_JPEG
  printf("Filling input buffer, remaining skip is %ld, ",__printf_chk (2 - 1, "Filling input buffer, remaining skip is %ld, "
, sb->remaining_skip)
         sb->remaining_skip)__printf_chk (2 - 1, "Filling input buffer, remaining skip is %ld, "
, sb->remaining_skip);
  printf("Buffer length is %d\n", sb->bufferLength)__printf_chk (2 - 1, "Buffer length is %d\n", sb->bufferLength
);
944#endif

  /*
   * Definitively skips.  Could be left over if we tried to skip
   * more than a buffer's worth but suspended when getting the next
   * buffer.  Now we aren't suspended, so we can catch up.
   */
  if (sb->remaining_skip) {
3
←
Assuming field 'remaining_skip' is 0→
4
←
Taking false branch→
      src->skip_input_data(cinfo, 0);
  }

  /*
   * Now fill a complete buffer, or as much of one as the stream
   * will give us if we are near the end.
   */
  RELEASE_ARRAYS(env, data, src->next_input_byte);
5
←
Calling 'RELEASE_ARRAYS'→
12
←
Returning from 'RELEASE_ARRAYS'→

  GET_IO_REF(input)do { if ((*env)->IsSameObject(env, sb->ioRef, ((void*)0
)) || ((input) = (*env)->NewLocalRef(env, sb->ioRef)) ==
 ((void*)0)) { cinfo->err->error_exit((j_common_ptr) cinfo
); } } while (0);
13
←
Assuming the condition is false→
14
←
Assuming the condition is false→
15
←
Taking false branch→
16
←
Loop condition is false.  Exiting loop→

  ret = (*env)->CallIntMethod(env,
                              input,
                              JPEGImageReader_readInputDataID,
                              sb->hstreamBuffer, 0,
                              sb->bufferLength);
  if ((ret > 0) && ((unsigned int)ret > sb->bufferLength)) {
17
←
Assuming 'ret' is <= 0→
       ret = (int)sb->bufferLength;
  }
  if ((*env)->ExceptionOccurred(env)
18
←
Assuming the condition is false→
19
←
Taking false branch→
      || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
  }

976#ifdef DEBUG_IIO_JPEG
    printf("Buffer filled. ret = %d\n", ret)__printf_chk (2 - 1, "Buffer filled. ret = %d\n", ret);
978#endif
  /*
   * If we have reached the end of the stream, then the EOI marker
   * is missing.  We accept such streams but generate a warning.
   * The image is likely to be corrupted, though everything through
   * the end of the last complete MCU should be usable.
   */
  if (ret19.1
'ret' is <= 0
 <= 0) {
20
←
Taking true branch→
      jobject reader = data->imageIOobj;
987#ifdef DEBUG_IIO_JPEG
    printf("YO! Early EOI! ret = %d\n", ret)__printf_chk (2 - 1, "YO! Early EOI! ret = %d\n", ret);
989#endif
      RELEASE_ARRAYS(env, data, src->next_input_byte);
21
←
Calling 'RELEASE_ARRAYS'→
29
←
Returning from 'RELEASE_ARRAYS'→
      (*env)->CallVoidMethod(env, reader,
                             JPEGImageReader_warningOccurredID,
                             READ_NO_EOI0);
      if ((*env)->ExceptionOccurred(env)
30
←
Assuming the condition is true→
          || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
      }

      sb->buf[0] = (JOCTET) 0xFF;
31
←
Array access (via field 'buf') results in a null pointer dereference
      sb->buf[1] = (JOCTET) JPEG_EOI0xD9;
      ret = 2;
  }

  src->next_input_byte = sb->buf;
  src->bytes_in_buffer = ret;

  return TRUE1;
1008}

1010/*
* With I/O suspension turned on, the JPEG library requires that all
* buffer filling be done at the top application level, using this
* function.  Due to the way that backtracking works, this procedure
* saves all of the data that was left in the buffer when suspension
* occurred and read new data only at the end.
*/

1018GLOBAL(void)void
1019imageio_fill_suspended_buffer(j_decompress_ptr cinfo)
1020{
  struct jpeg_source_mgr *src = cinfo->src;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  streamBufferPtr sb = &data->streamBuf;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);
  jint ret;
  size_t offset, buflen;
  jobject input = NULL((void*)0);

  /*
   * The original (jpegdecoder.c) had code here that called
   * InputStream.available and just returned if the number of bytes
   * available was less than any remaining skip.  Presumably this was
   * to avoid blocking, although the benefit was unclear, as no more
   * decompression can take place until more data is available, so
   * the code would block on input a little further along anyway.
   * ImageInputStreams don't have an available method, so we'll just
   * block in the skip if we have to.
   */

  if (sb->remaining_skip) {
      src->skip_input_data(cinfo, 0);
  }

  /* Save the data currently in the buffer */
  offset = src->bytes_in_buffer;
  if (src->next_input_byte > sb->buf) {
      memcpy(sb->buf, src->next_input_byte, offset);
  }


  RELEASE_ARRAYS(env, data, src->next_input_byte);

  GET_IO_REF(input)do { if ((*env)->IsSameObject(env, sb->ioRef, ((void*)0
)) || ((input) = (*env)->NewLocalRef(env, sb->ioRef)) ==
 ((void*)0)) { cinfo->err->error_exit((j_common_ptr) cinfo
); } } while (0);

  buflen = sb->bufferLength - offset;
  if (buflen <= 0) {
      if (!GET_ARRAYS(env, data, &(src->next_input_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
      }
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      return;
  }

  ret = (*env)->CallIntMethod(env, input,
                              JPEGImageReader_readInputDataID,
                              sb->hstreamBuffer,
                              offset, buflen);
  if ((ret > 0) && ((unsigned int)ret > buflen)) ret = (int)buflen;
  if ((*env)->ExceptionOccurred(env)
      || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
      cinfo->err->error_exit((j_common_ptr) cinfo);
  }
  /*
   * If we have reached the end of the stream, then the EOI marker
   * is missing.  We accept such streams but generate a warning.
   * The image is likely to be corrupted, though everything through
   * the end of the last complete MCU should be usable.
   */
  if (ret <= 0) {
      jobject reader = data->imageIOobj;
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      (*env)->CallVoidMethod(env, reader,
                             JPEGImageReader_warningOccurredID,
                             READ_NO_EOI0);
      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
      }

      sb->buf[offset] = (JOCTET) 0xFF;
      sb->buf[offset + 1] = (JOCTET) JPEG_EOI0xD9;
      ret = 2;
  }

  src->next_input_byte = sb->buf;
  src->bytes_in_buffer = ret + offset;

  return;
1099}

1101/*
* Skip num_bytes worth of data.  The buffer pointer and count are
* advanced over num_bytes input bytes, using the input stream
* skipBytes method if the skip is greater than the number of bytes
* in the buffer.  This is used to skip over a potentially large amount of
* uninteresting data (such as an APPn marker).  bytes_in_buffer will be
* zero on return if the skip is larger than the current contents of the
* buffer.
*
* A negative skip count is treated as a no-op.  A zero skip count
* skips any remaining skip from a previous skip while suspended.
*
* Note that with I/O suspension turned on, this procedure does not
* call skipBytes since the JPEG library has a very simple backtracking
* mechanism which relies on the fact that the application level has
* exclusive control over actual I/O.
*/

1119GLOBAL(void)void
1120imageio_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
1121{
  struct jpeg_source_mgr *src = cinfo->src;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  streamBufferPtr sb = &data->streamBuf;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);
  jlong ret;
  jobject reader;
  jobject input = NULL((void*)0);

  if (num_bytes < 0) {
      return;
  }
  num_bytes += sb->remaining_skip;
  sb->remaining_skip = 0;

  /* First the easy case where we are skipping <= the current contents. */
  ret = src->bytes_in_buffer;
  if (ret >= num_bytes) {
      src->next_input_byte += num_bytes;
      src->bytes_in_buffer -= num_bytes;
      return;
  }

  /*
   * We are skipping more than is in the buffer.  We empty the buffer and,
   * if we aren't suspended, call the Java skipBytes method.  We always
   * leave the buffer empty, to be filled by either fill method above.
   */
  src->bytes_in_buffer = 0;
  src->next_input_byte = sb->buf;

  num_bytes -= (long)ret;
  if (sb->suspendable) {
      sb->remaining_skip = num_bytes;
      return;
  }

  RELEASE_ARRAYS(env, data, src->next_input_byte);

  GET_IO_REF(input)do { if ((*env)->IsSameObject(env, sb->ioRef, ((void*)0
)) || ((input) = (*env)->NewLocalRef(env, sb->ioRef)) ==
 ((void*)0)) { cinfo->err->error_exit((j_common_ptr) cinfo
); } } while (0);

  ret = (*env)->CallLongMethod(env,
                               input,
                               JPEGImageReader_skipInputBytesID,
                               (jlong) num_bytes);
  if ((*env)->ExceptionOccurred(env)
      || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
  }

  /*
   * If we have reached the end of the stream, then the EOI marker
   * is missing.  We accept such streams but generate a warning.
   * The image is likely to be corrupted, though everything through
   * the end of the last complete MCU should be usable.
   */
  if (ret <= 0) {
      reader = data->imageIOobj;
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      (*env)->CallVoidMethod(env,
                             reader,
                             JPEGImageReader_warningOccurredID,
                             READ_NO_EOI0);

      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
              cinfo->err->error_exit((j_common_ptr) cinfo);
      }
      sb->buf[0] = (JOCTET) 0xFF;
      sb->buf[1] = (JOCTET) JPEG_EOI0xD9;
      src->bytes_in_buffer = 2;
      src->next_input_byte = sb->buf;
  }
1194}

1196/*
* Terminate source --- called by jpeg_finish_decompress() after all
* data for an image has been read.  In our case pushes back any
* remaining data, as it will be for another image and must be available
* for java to find out that there is another image.  Also called if
* reseting state after reading a tables-only image.
*/

1204GLOBAL(void)void
1205imageio_term_source(j_decompress_ptr cinfo)
1206{
  // To pushback, just seek back by src->bytes_in_buffer
  struct jpeg_source_mgr *src = cinfo->src;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);
  jobject reader = data->imageIOobj;
  if (src->bytes_in_buffer > 0) {
       RELEASE_ARRAYS(env, data, src->next_input_byte);
       (*env)->CallVoidMethod(env,
                              reader,
                              JPEGImageReader_pushBackID,
                              src->bytes_in_buffer);

       if ((*env)->ExceptionOccurred(env)
           || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
           cinfo->err->error_exit((j_common_ptr) cinfo);
       }
       src->bytes_in_buffer = 0;
       //src->next_input_byte = sb->buf;
  }
1226}

1228/********************* end of source manager ******************/

1230/********************* ICC profile support ********************/
1231/*
* The following routines are modified versions of the ICC
* profile support routines available from the IJG website.
* The originals were written by Todd Newman
* <tdn@eccentric.esd.sgi.com> and modified by Tom Lane for
* the IJG.  They are further modified to fit in the context
* of the imageio JPEG plug-in.
*/

1240/*
* Since an ICC profile can be larger than the maximum size of a JPEG marker
* (64K), we need provisions to split it into multiple markers.  The format
* defined by the ICC specifies one or more APP2 markers containing the
* following data:
*      Identifying string      ASCII "ICC_PROFILE\0"  (12 bytes)
*      Marker sequence number  1 for first APP2, 2 for next, etc (1 byte)
*      Number of markers       Total number of APP2's used (1 byte)
*      Profile data            (remainder of APP2 data)
* Decoders should use the marker sequence numbers to reassemble the profile,
* rather than assuming that the APP2 markers appear in the correct sequence.
*/

1253#define ICC_MARKER(0xE0 + 2)  (JPEG_APP00xE0 + 2)     /* JPEG marker code for ICC */
1254#define ICC_OVERHEAD_LEN14  14            /* size of non-profile data in APP2 */
1255#define MAX_BYTES_IN_MARKER65533  65533      /* maximum data len of a JPEG marker */
1256#define MAX_DATA_BYTES_IN_ICC_MARKER(65533 - 14)  (MAX_BYTES_IN_MARKER65533 - ICC_OVERHEAD_LEN14)


1259/*
* Handy subroutine to test whether a saved marker is an ICC profile marker.
*/

1263static boolean
1264marker_is_icc (jpeg_saved_marker_ptr marker)
1265{
return
  marker->marker == ICC_MARKER(0xE0 + 2) &&
  marker->data_length >= ICC_OVERHEAD_LEN14 &&
  /* verify the identifying string */
  GETJOCTET(marker->data[0])(marker->data[0]) == 0x49 &&
  GETJOCTET(marker->data[1])(marker->data[1]) == 0x43 &&
  GETJOCTET(marker->data[2])(marker->data[2]) == 0x43 &&
  GETJOCTET(marker->data[3])(marker->data[3]) == 0x5F &&
  GETJOCTET(marker->data[4])(marker->data[4]) == 0x50 &&
  GETJOCTET(marker->data[5])(marker->data[5]) == 0x52 &&
  GETJOCTET(marker->data[6])(marker->data[6]) == 0x4F &&
  GETJOCTET(marker->data[7])(marker->data[7]) == 0x46 &&
  GETJOCTET(marker->data[8])(marker->data[8]) == 0x49 &&
  GETJOCTET(marker->data[9])(marker->data[9]) == 0x4C &&
  GETJOCTET(marker->data[10])(marker->data[10]) == 0x45 &&
  GETJOCTET(marker->data[11])(marker->data[11]) == 0x0;
1282}

1284/*
* See if there was an ICC profile in the JPEG file being read;
* if so, reassemble and return the profile data as a new Java byte array.
* If there was no ICC profile, return NULL.
*
* If the file contains invalid ICC APP2 markers, we throw an IIOException
* with an appropriate message.
*/

1293jbyteArray
1294read_icc_profile (JNIEnv *env, j_decompress_ptr cinfo)
1295{
  jpeg_saved_marker_ptr marker;
  int num_markers = 0;
  int num_found_markers = 0;
  int seq_no;
  JOCTET *icc_data;
  JOCTET *dst_ptr;
  unsigned int total_length;
1303#define MAX_SEQ_NO255  255         // sufficient since marker numbers are bytes
  jpeg_saved_marker_ptr icc_markers[MAX_SEQ_NO255 + 1];
  int first;         // index of the first marker in the icc_markers array
  int last;          // index of the last marker in the icc_markers array
  jbyteArray data = NULL((void*)0);

  /* This first pass over the saved markers discovers whether there are
   * any ICC markers and verifies the consistency of the marker numbering.
   */

  for (seq_no = 0; seq_no <= MAX_SEQ_NO255; seq_no++)
      icc_markers[seq_no] = NULL((void*)0);


  for (marker = cinfo->marker_list; marker != NULL((void*)0); marker = marker->next) {
      if (marker_is_icc(marker)) {
          if (num_markers == 0)
              num_markers = GETJOCTET(marker->data[13])(marker->data[13]);
          else if (num_markers != GETJOCTET(marker->data[13])(marker->data[13])) {
              JNU_ThrowByName(env, "javax/imageio/IIOException",
                   "Invalid icc profile: inconsistent num_markers fields");
              return NULL((void*)0);
          }
          seq_no = GETJOCTET(marker->data[12])(marker->data[12]);

          /* Some third-party tools produce images with profile chunk
           * numeration started from zero. It is inconsistent with ICC
           * spec, but seems to be recognized by majority of image
           * processing tools, so we should be more tolerant to this
           * departure from the spec.
           */
          if (seq_no < 0 || seq_no > num_markers) {
              JNU_ThrowByName(env, "javax/imageio/IIOException",
                   "Invalid icc profile: bad sequence number");
              return NULL((void*)0);
          }
          if (icc_markers[seq_no] != NULL((void*)0)) {
              JNU_ThrowByName(env, "javax/imageio/IIOException",
                   "Invalid icc profile: duplicate sequence numbers");
              return NULL((void*)0);
          }
          icc_markers[seq_no] = marker;
          num_found_markers ++;
      }
  }

  if (num_markers == 0)
      return NULL((void*)0);  // There is no profile

  if (num_markers != num_found_markers) {
      JNU_ThrowByName(env, "javax/imageio/IIOException",
                      "Invalid icc profile: invalid number of icc markers");
      return NULL((void*)0);
  }

  first = icc_markers[0] ? 0 : 1;
  last = num_found_markers + first;

  /* Check for missing markers, count total space needed.
   */
  total_length = 0;
  for (seq_no = first; seq_no < last; seq_no++) {
      unsigned int length;
      if (icc_markers[seq_no] == NULL((void*)0)) {
          JNU_ThrowByName(env, "javax/imageio/IIOException",
               "Invalid icc profile: missing sequence number");
          return NULL((void*)0);
      }
      /* check the data length correctness */
      length = icc_markers[seq_no]->data_length;
      if (ICC_OVERHEAD_LEN14 > length || length > MAX_BYTES_IN_MARKER65533) {
          JNU_ThrowByName(env, "javax/imageio/IIOException",
               "Invalid icc profile: invalid data length");
          return NULL((void*)0);
      }
      total_length += (length - ICC_OVERHEAD_LEN14);
  }

  if (total_length <= 0) {
      JNU_ThrowByName(env, "javax/imageio/IIOException",
            "Invalid icc profile: found only empty markers");
      return NULL((void*)0);
  }

  /* Allocate a Java byte array for assembled data */

  data = (*env)->NewByteArray(env, total_length);
  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/OutOfMemoryError",
                      "Reading ICC profile");
      return NULL((void*)0);
  }

  icc_data = (JOCTET *)(*env)->GetPrimitiveArrayCritical(env,
                                                         data,
                                                         NULL((void*)0));
  if (icc_data == NULL((void*)0)) {
      JNU_ThrowByName(env, "javax/imageio/IIOException",
                      "Unable to pin icc profile data array");
      return NULL((void*)0);
  }

  /* and fill it in */
  dst_ptr = icc_data;
  for (seq_no = first; seq_no < last; seq_no++) {
      JOCTET FAR *src_ptr = icc_markers[seq_no]->data + ICC_OVERHEAD_LEN14;
      unsigned int length =
          icc_markers[seq_no]->data_length - ICC_OVERHEAD_LEN14;

      memcpy(dst_ptr, src_ptr, length);
      dst_ptr += length;
  }

  /* finally, unpin the array */
  (*env)->ReleasePrimitiveArrayCritical(env,
                                        data,
                                        icc_data,
                                        0);


  return data;
1425}

1427/********************* end of ICC profile support *************/

1429/********************* Reader JNI calls ***********************/

1431JNIEXPORT__attribute__((visibility("default"))) void JNICALL
1432Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_initReaderIDs
  (JNIEnv *env,
   jclass cls,
   jclass ImageInputStreamClass,
   jclass qTableClass,
   jclass huffClass) {

  CHECK_NULL(JPEGImageReader_readInputDataID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_readInputDataID = (*env)->GetMethodID
(env, cls, "readInputData", "([BII)I")) == ((void*)0)) { return
; } } while (0)
                                                cls,do { if ((JPEGImageReader_readInputDataID = (*env)->GetMethodID
(env, cls, "readInputData", "([BII)I")) == ((void*)0)) { return
; } } while (0)
                                                "readInputData",do { if ((JPEGImageReader_readInputDataID = (*env)->GetMethodID
(env, cls, "readInputData", "([BII)I")) == ((void*)0)) { return
; } } while (0)
                                                "([BII)I"))do { if ((JPEGImageReader_readInputDataID = (*env)->GetMethodID
(env, cls, "readInputData", "([BII)I")) == ((void*)0)) { return
; } } while (0);
  CHECK_NULL(JPEGImageReader_skipInputBytesID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_skipInputBytesID = (*env)->GetMethodID
(env, cls, "skipInputBytes", "(J)J")) == ((void*)0)) { return
; } } while (0)
                                                     cls,do { if ((JPEGImageReader_skipInputBytesID = (*env)->GetMethodID
(env, cls, "skipInputBytes", "(J)J")) == ((void*)0)) { return
; } } while (0)
                                                     "skipInputBytes",do { if ((JPEGImageReader_skipInputBytesID = (*env)->GetMethodID
(env, cls, "skipInputBytes", "(J)J")) == ((void*)0)) { return
; } } while (0)
                                                     "(J)J"))do { if ((JPEGImageReader_skipInputBytesID = (*env)->GetMethodID
(env, cls, "skipInputBytes", "(J)J")) == ((void*)0)) { return
; } } while (0);
  CHECK_NULL(JPEGImageReader_warningOccurredID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0)
                                                          cls,do { if ((JPEGImageReader_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0)
                                                          "warningOccurred",do { if ((JPEGImageReader_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0)
                                                          "(I)V"))do { if ((JPEGImageReader_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0);
  CHECK_NULL(JPEGImageReader_warningWithMessageID =do { if ((JPEGImageReader_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
      (*env)->GetMethodID(env,do { if ((JPEGImageReader_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
                          cls,do { if ((JPEGImageReader_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
                          "warningWithMessage",do { if ((JPEGImageReader_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
                          "(Ljava/lang/String;)V"))do { if ((JPEGImageReader_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0);
  CHECK_NULL(JPEGImageReader_setImageDataID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_setImageDataID = (*env)->GetMethodID
(env, cls, "setImageData", "(IIIII[B)V")) == ((void*)0)) { return
; } } while (0)
                                                       cls,do { if ((JPEGImageReader_setImageDataID = (*env)->GetMethodID
(env, cls, "setImageData", "(IIIII[B)V")) == ((void*)0)) { return
; } } while (0)
                                                       "setImageData",do { if ((JPEGImageReader_setImageDataID = (*env)->GetMethodID
(env, cls, "setImageData", "(IIIII[B)V")) == ((void*)0)) { return
; } } while (0)
                                                       "(IIIII[B)V"))do { if ((JPEGImageReader_setImageDataID = (*env)->GetMethodID
(env, cls, "setImageData", "(IIIII[B)V")) == ((void*)0)) { return
; } } while (0);
  CHECK_NULL(JPEGImageReader_acceptPixelsID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_acceptPixelsID = (*env)->GetMethodID
(env, cls, "acceptPixels", "(IZ)V")) == ((void*)0)) { return;
 } } while (0)
                                                       cls,do { if ((JPEGImageReader_acceptPixelsID = (*env)->GetMethodID
(env, cls, "acceptPixels", "(IZ)V")) == ((void*)0)) { return;
 } } while (0)
                                                       "acceptPixels",do { if ((JPEGImageReader_acceptPixelsID = (*env)->GetMethodID
(env, cls, "acceptPixels", "(IZ)V")) == ((void*)0)) { return;
 } } while (0)
                                                       "(IZ)V"))do { if ((JPEGImageReader_acceptPixelsID = (*env)->GetMethodID
(env, cls, "acceptPixels", "(IZ)V")) == ((void*)0)) { return;
 } } while (0);
  CHECK_NULL(JPEGImageReader_passStartedID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_passStartedID = (*env)->GetMethodID
(env, cls, "passStarted", "(I)V")) == ((void*)0)) { return; }
 } while (0)
                                                      cls,do { if ((JPEGImageReader_passStartedID = (*env)->GetMethodID
(env, cls, "passStarted", "(I)V")) == ((void*)0)) { return; }
 } while (0)
                                                      "passStarted",do { if ((JPEGImageReader_passStartedID = (*env)->GetMethodID
(env, cls, "passStarted", "(I)V")) == ((void*)0)) { return; }
 } while (0)
                                                      "(I)V"))do { if ((JPEGImageReader_passStartedID = (*env)->GetMethodID
(env, cls, "passStarted", "(I)V")) == ((void*)0)) { return; }
 } while (0);
  CHECK_NULL(JPEGImageReader_passCompleteID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_passCompleteID = (*env)->GetMethodID
(env, cls, "passComplete", "()V")) == ((void*)0)) { return; }
 } while (0)
                                                       cls,do { if ((JPEGImageReader_passCompleteID = (*env)->GetMethodID
(env, cls, "passComplete", "()V")) == ((void*)0)) { return; }
 } while (0)
                                                       "passComplete",do { if ((JPEGImageReader_passCompleteID = (*env)->GetMethodID
(env, cls, "passComplete", "()V")) == ((void*)0)) { return; }
 } while (0)
                                                       "()V"))do { if ((JPEGImageReader_passCompleteID = (*env)->GetMethodID
(env, cls, "passComplete", "()V")) == ((void*)0)) { return; }
 } while (0);
  CHECK_NULL(JPEGImageReader_pushBackID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_pushBackID = (*env)->GetMethodID
(env, cls, "pushBack", "(I)V")) == ((void*)0)) { return; } } while
 (0)
                                                   cls,do { if ((JPEGImageReader_pushBackID = (*env)->GetMethodID
(env, cls, "pushBack", "(I)V")) == ((void*)0)) { return; } } while
 (0)
                                                   "pushBack",do { if ((JPEGImageReader_pushBackID = (*env)->GetMethodID
(env, cls, "pushBack", "(I)V")) == ((void*)0)) { return; } } while
 (0)
                                                   "(I)V"))do { if ((JPEGImageReader_pushBackID = (*env)->GetMethodID
(env, cls, "pushBack", "(I)V")) == ((void*)0)) { return; } } while
 (0);
  CHECK_NULL(JPEGImageReader_skipPastImageID = (*env)->GetMethodID(env,do { if ((JPEGImageReader_skipPastImageID = (*env)->GetMethodID
(env, cls, "skipPastImage", "(I)V")) == ((void*)0)) { return;
 } } while (0)
                                                   cls,do { if ((JPEGImageReader_skipPastImageID = (*env)->GetMethodID
(env, cls, "skipPastImage", "(I)V")) == ((void*)0)) { return;
 } } while (0)
                                                   "skipPastImage",do { if ((JPEGImageReader_skipPastImageID = (*env)->GetMethodID
(env, cls, "skipPastImage", "(I)V")) == ((void*)0)) { return;
 } } while (0)
                                                   "(I)V"))do { if ((JPEGImageReader_skipPastImageID = (*env)->GetMethodID
(env, cls, "skipPastImage", "(I)V")) == ((void*)0)) { return;
 } } while (0);
  CHECK_NULL(JPEGQTable_tableID = (*env)->GetFieldID(env,do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0)
                                          qTableClass,do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0)
                                          "qTable",do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0)
                                          "[I"))do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0);

  CHECK_NULL(JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(env,do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0)
                                                  huffClass,do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0)
                                                  "lengths",do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0)
                                                  "[S"))do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0);

  CHECK_NULL(JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env,do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0)
                                                  huffClass,do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0)
                                                  "values",do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0)
                                                  "[S"))do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0);
1494}

1496JNIEXPORT__attribute__((visibility("default"))) jlong JNICALL
1497Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_initJPEGImageReader
  (JNIEnv *env,
   jobject this) {

  imageIODataPtr ret;
  struct sun_jpeg_error_mgr *jerr;

  /* This struct contains the JPEG decompression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   */
  struct jpeg_decompress_struct *cinfo =
      malloc(sizeof(struct jpeg_decompress_struct));
  if (cinfo == NULL((void*)0)) {
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Reader");
      return 0;
  }

  /* We use our private extension JPEG error handler.
   */
  jerr = malloc (sizeof(struct sun_jpeg_error_mgr));
  if (jerr == NULL((void*)0)) {
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Reader");
      free(cinfo);
      return 0;
  }

  /* We set up the normal JPEG error routines, then override error_exit. */
  cinfo->err = jpeg_std_errorjStdError(&(jerr->pub));
  jerr->pub.error_exit = sun_jpeg_error_exit;
  /* We need to setup our own print routines */
  jerr->pub.output_message = sun_jpeg_output_message;
  /* Now we can setjmp before every call to the library */

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error. */
      char buffer[JMSG_LENGTH_MAX200];
      (*cinfo->err->format_message) ((struct jpeg_common_struct *) cinfo,
                                    buffer);
      JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      return 0;
  }

  /* Perform library initialization */
  jpeg_create_decompress(cinfo)jCreaDecompress((cinfo), 62, (size_t) sizeof(struct jpeg_decompress_struct
));

  // Set up to keep any APP2 markers, as these might contain ICC profile
  // data
  jpeg_save_markersjSaveMarkers(cinfo, ICC_MARKER(0xE0 + 2), 0xFFFF);

  /*
   * Now set up our source.
   */
  cinfo->src =
      (struct jpeg_source_mgr *) malloc (sizeof(struct jpeg_source_mgr));
  if (cinfo->src == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/OutOfMemoryError",
                      "Initializing Reader");
      imageio_dispose((j_common_ptr)cinfo);
      return 0;
  }
  cinfo->src->bytes_in_buffer = 0;
  cinfo->src->next_input_byte = NULL((void*)0);
  cinfo->src->init_source = imageio_init_source;
  cinfo->src->fill_input_buffer = imageio_fill_input_buffer;
  cinfo->src->skip_input_data = imageio_skip_input_data;
  cinfo->src->resync_to_restart = jpeg_resync_to_restartjResyncRestart; // use default
  cinfo->src->term_source = imageio_term_source;

  /* set up the association to persist for future calls */
  ret = initImageioData(env, (j_common_ptr) cinfo, this);
  if (ret == NULL((void*)0)) {
      (*env)->ExceptionClear(env);
      JNU_ThrowByName(env, "java/lang/OutOfMemoryError",
                      "Initializing Reader");
      imageio_dispose((j_common_ptr)cinfo);
      return 0;
  }
  return ptr_to_jlong(ret)((jlong)(ret));
1581}

1583/*
* When we set a source from Java, we set up the stream in the streamBuf
* object.  If there was an old one, it is released first.
*/

1588JNIEXPORT__attribute__((visibility("default"))) void JNICALL
1589Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_setSource
  (JNIEnv *env,
   jobject this,
   jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_common_ptr cinfo;

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use reader after dispose()");
      return;
  }

  cinfo = data->jpegObj;

  imageio_set_stream(env, cinfo, data, this);

  imageio_init_source((j_decompress_ptr) cinfo);
1609}

1611#define JPEG_APP1(0xE0 + 1)  (JPEG_APP00xE0 + 1)  /* EXIF APP1 marker code  */

1613/*
* For EXIF images, the APP1 will appear immediately after the SOI,
* so it's safe to only look at the first marker in the list.
* (see http://www.exif.org/Exif2-2.PDF, section 4.7, page 58)
*/
1618#define IS_EXIF(c)(((c)->marker_list != ((void*)0)) && ((c)->marker_list
->marker == (0xE0 + 1))) \
  (((c)->marker_list != NULL((void*)0)) && ((c)->marker_list->marker == JPEG_APP1(0xE0 + 1)))

1621JNIEXPORT__attribute__((visibility("default"))) jboolean JNICALL
1622Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_readImageHeader
  (JNIEnv *env,
   jobject this,
   jlong ptr,
   jboolean clearFirst,
   jboolean reset) {

  int ret;
  int h_samp0, h_samp1, h_samp2;
  int v_samp0, v_samp1, v_samp2;
  int cid0, cid1, cid2;
  jboolean retval = JNI_FALSE0;
  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_decompress_ptr cinfo;
  struct jpeg_source_mgr *src;
  sun_jpeg_error_ptr jerr;
  jbyteArray profileData = NULL((void*)0);

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use reader after dispose()");
      return JNI_FALSE0;
  }

  cinfo = (j_decompress_ptr) data->jpegObj;
  src = cinfo->src;

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  jerr = (sun_jpeg_error_ptr) cinfo->err;

  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error
         while reading the header. */
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      if (!(*env)->ExceptionOccurred(env)) {
          char buffer[JMSG_LENGTH_MAX200];
          (*cinfo->err->format_message) ((struct jpeg_common_struct *) cinfo,
                                        buffer);
          JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      }
      return retval;
  }

1666#ifdef DEBUG_IIO_JPEG
  printf("In readImageHeader, data is %p cinfo is %p\n", data, cinfo)__printf_chk (2 - 1, "In readImageHeader, data is %p cinfo is %p\n"
, data, cinfo);
  printf("clearFirst is %d\n", clearFirst)__printf_chk (2 - 1, "clearFirst is %d\n", clearFirst);
1669#endif

  if (GET_ARRAYS(env, data, &src->next_input_byte) == NOT_OK0) {
      (*env)->ExceptionClear(env);
      JNU_ThrowByName(env,
                      "javax/imageio/IIOException",
                      "Array pin failed");
      return retval;
  }

  /*
   * Now clear the input buffer if the Java code has done a seek
   * on the stream since the last call, invalidating any buffer contents.
   */
  if (clearFirst) {
      clearStreamBuffer(&data->streamBuf);
      src->next_input_byte = NULL((void*)0);
      src->bytes_in_buffer = 0;
  }

  ret = jpeg_read_headerjReadHeader(cinfo, FALSE0);

  if (ret == JPEG_HEADER_TABLES_ONLY2) {
      retval = JNI_TRUE1;
      imageio_term_source(cinfo);  // Pushback remaining buffer contents
1694#ifdef DEBUG_IIO_JPEG
      printf("just read tables-only image; q table 0 at %p\n",__printf_chk (2 - 1, "just read tables-only image; q table 0 at %p\n"
, cinfo->quant_tbl_ptrs[0])
             cinfo->quant_tbl_ptrs[0])__printf_chk (2 - 1, "just read tables-only image; q table 0 at %p\n"
, cinfo->quant_tbl_ptrs[0]);
1697#endif
      RELEASE_ARRAYS(env, data, src->next_input_byte);
  } else {
      /*
       * Now adjust the jpeg_color_space variable, which was set in
       * default_decompress_parms, to reflect our differences from IJG
       */

      switch (cinfo->jpeg_color_space) {
      default :
        break;
      case JCS_YCbCr:

          /*
           * There are several possibilities:
           *  - we got image with embeded colorspace
           *     Use it. User knows what he is doing.
           *  - we got JFIF image
           *     Must be YCbCr (see http://www.w3.org/Graphics/JPEG/jfif3.pdf, page 2)
           *  - we got EXIF image
           *     Must be YCbCr (see http://www.exif.org/Exif2-2.PDF, section 4.7, page 63)
           *  - something else
           *     Apply heuristical rules to identify actual colorspace.
           */

          if (cinfo->saw_Adobe_marker) {
              if (cinfo->Adobe_transform != 1) {
                  /*
                   * IJG guesses this is YCbCr and emits a warning
                   * We would rather not guess.  Then the user knows
                   * To read this as a Raster if at all
                   */
                  cinfo->jpeg_color_space = JCS_UNKNOWN;
                  cinfo->out_color_space = JCS_UNKNOWN;
              }
          } else if (!cinfo->saw_JFIF_marker && !IS_EXIF(cinfo)(((cinfo)->marker_list != ((void*)0)) && ((cinfo)->
marker_list->marker == (0xE0 + 1)))) {
              /*
               * In the absence of certain markers, IJG has interpreted
               * component id's of [1,2,3] as meaning YCbCr.We follow that
               * interpretation, which is additionally described in the Image
               * I/O JPEG metadata spec.If that condition is not met here the
               * next step will be to examine the subsampling factors, if
               * there is any difference in subsampling factors we also assume
               * YCbCr, only if both horizontal and vertical subsampling
               * is same we assume JPEG color space as RGB.
               * This is also described in the Image I/O JPEG metadata spec.
               */
              h_samp0 = cinfo->comp_info[0].h_samp_factor;
              h_samp1 = cinfo->comp_info[1].h_samp_factor;
              h_samp2 = cinfo->comp_info[2].h_samp_factor;

              v_samp0 = cinfo->comp_info[0].v_samp_factor;
              v_samp1 = cinfo->comp_info[1].v_samp_factor;
              v_samp2 = cinfo->comp_info[2].v_samp_factor;

              cid0 = cinfo->comp_info[0].component_id;
              cid1 = cinfo->comp_info[1].component_id;
              cid2 = cinfo->comp_info[2].component_id;

              if ((!(cid0 == 1 && cid1 == 2 && cid2 == 3)) &&
                  ((h_samp1 == h_samp0) && (h_samp2 == h_samp0) &&
                  (v_samp1 == v_samp0) && (v_samp2 == v_samp0)))
              {
                  cinfo->jpeg_color_space = JCS_RGB;
                  /* output is already RGB, so it stays the same */
              }
          }
          break;
      case JCS_YCCK:
          if ((cinfo->saw_Adobe_marker) && (cinfo->Adobe_transform != 2)) {
              /*
               * IJG guesses this is YCCK and emits a warning
               * We would rather not guess.  Then the user knows
               * To read this as a Raster if at all
               */
              cinfo->jpeg_color_space = JCS_UNKNOWN;
              cinfo->out_color_space = JCS_UNKNOWN;
          }
          break;
      case JCS_CMYK:
          /*
           * IJG assumes all unidentified 4-channels are CMYK.
           * We assume that only if the second two channels are
           * not subsampled (either horizontally or vertically).
           * If they are, we assume YCCK.
           */
          h_samp0 = cinfo->comp_info[0].h_samp_factor;
          h_samp1 = cinfo->comp_info[1].h_samp_factor;
          h_samp2 = cinfo->comp_info[2].h_samp_factor;

          v_samp0 = cinfo->comp_info[0].v_samp_factor;
          v_samp1 = cinfo->comp_info[1].v_samp_factor;
          v_samp2 = cinfo->comp_info[2].v_samp_factor;

          if (((h_samp1 > h_samp0) && (h_samp2 > h_samp0)) ||
              ((v_samp1 > v_samp0) && (v_samp2 > v_samp0)))
          {
              cinfo->jpeg_color_space = JCS_YCCK;
              /* Leave the output space as CMYK */
          }
      }
      RELEASE_ARRAYS(env, data, src->next_input_byte);

      /* read icc profile data */
      profileData = read_icc_profile(env, cinfo);

      if ((*env)->ExceptionCheck(env)) {
          return retval;
      }

      (*env)->CallVoidMethod(env, this,
                             JPEGImageReader_setImageDataID,
                             cinfo->image_width,
                             cinfo->image_height,
                             cinfo->jpeg_color_space,
                             cinfo->out_color_space,
                             cinfo->num_components,
                             profileData);
      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
      }
      if (reset) {
          jpeg_abort_decompressjAbrtDecompress(cinfo);
      }
      RELEASE_ARRAYS(env, data, src->next_input_byte);
  }

  return retval;
1826}


1829JNIEXPORT__attribute__((visibility("default"))) void JNICALL
1830Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_setOutColorSpace
  (JNIEnv *env,
   jobject this,
   jlong ptr,
   jint code) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_decompress_ptr cinfo;

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use reader after dispose()");
      return;
  }

  cinfo = (j_decompress_ptr) data->jpegObj;

  cinfo->out_color_space = code;

1850}

1852JNIEXPORT__attribute__((visibility("default"))) jboolean JNICALL
1853Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_readImage
  (JNIEnv *env,
   jobject this,
   jint imageIndex,
   jlong ptr,
   jbyteArray buffer,
   jint numBands,
   jintArray srcBands,
   jintArray bandSizes,
   jint sourceXStart,
   jint sourceYStart,
   jint sourceWidth,
   jint sourceHeight,
   jint stepX,
   jint stepY,
   jobjectArray qtables,
   jobjectArray DCHuffmanTables,
   jobjectArray ACHuffmanTables,
   jint minProgressivePass,  // Counts from 0
   jint maxProgressivePass,
   jboolean wantUpdates) {


  struct jpeg_source_mgr *src;
  JSAMPROW scanLinePtr = NULL((void*)0);
  jint bands[MAX_BANDS4];
  int i;
  jint *body;
  int scanlineLimit;
  int pixelStride;
  unsigned char *in, *out, *pixelLimit;
  int targetLine;
  int skipLines, linesLeft;
  pixelBufferPtr pb;
  sun_jpeg_error_ptr jerr;
  boolean done;
  boolean progressive = FALSE0;
  boolean orderedBands = TRUE1;
  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_decompress_ptr cinfo;
  size_t numBytes;

  /* verify the inputs */

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use reader after dispose()");
      return JNI_FALSE0;
  }

  if ((buffer == NULL((void*)0)) || (srcBands == NULL((void*)0)))  {
      JNU_ThrowNullPointerException(env, 0);
      return JNI_FALSE0;
  }

  cinfo = (j_decompress_ptr) data->jpegObj;

  if ((numBands < 1) || (numBands > MAX_BANDS4) ||
      (sourceXStart < 0) || (sourceXStart >= (jint)cinfo->image_width) ||
      (sourceYStart < 0) || (sourceYStart >= (jint)cinfo->image_height) ||
      (sourceWidth < 1) || (sourceWidth > (jint)cinfo->image_width) ||
      (sourceHeight < 1) || (sourceHeight > (jint)cinfo->image_height) ||
      (stepX < 1) || (stepY < 1) ||
      (minProgressivePass < 0) ||
      (maxProgressivePass < minProgressivePass))
  {
      JNU_ThrowByName(env, "javax/imageio/IIOException",
                      "Invalid argument to native readImage");
      return JNI_FALSE0;
  }

  if (stepX > (jint)cinfo->image_width) {
      stepX = cinfo->image_width;
  }
  if (stepY > (jint)cinfo->image_height) {
      stepY = cinfo->image_height;
  }

  /*
   * First get the source bands array and copy it to our local array
   * so we don't have to worry about pinning and unpinning it again.
   */

  body = (*env)->GetIntArrayElements(env, srcBands, NULL((void*)0));
  if (body == NULL((void*)0)) {
      (*env)->ExceptionClear(env);
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Read");
      return JNI_FALSE0;
  }

  for (i = 0; i < numBands; i++) {
      bands[i] = body[i];
      if (orderedBands && (bands[i] != i)) {
          orderedBands = FALSE0;
      }
  }

  (*env)->ReleaseIntArrayElements(env, srcBands, body, JNI_ABORT2);

1955#ifdef DEBUG_IIO_JPEG
  printf("---- in reader.read ----\n")__printf_chk (2 - 1, "---- in reader.read ----\n");
  printf("numBands is %d\n", numBands)__printf_chk (2 - 1, "numBands is %d\n", numBands);
  printf("bands array: ")__printf_chk (2 - 1, "bands array: ");
  for (i = 0; i < numBands; i++) {
      printf("%d ", bands[i])__printf_chk (2 - 1, "%d ", bands[i]);
  }
  printf("\n")__printf_chk (2 - 1, "\n");
  printf("jq table 0 at %p\n",__printf_chk (2 - 1, "jq table 0 at %p\n", cinfo->quant_tbl_ptrs
[0])
             cinfo->quant_tbl_ptrs[0])__printf_chk (2 - 1, "jq table 0 at %p\n", cinfo->quant_tbl_ptrs
[0]);
1965#endif

  data = (imageIODataPtr) cinfo->client_data;
  src = cinfo->src;

  /* Set the buffer as our PixelBuffer */
  pb = &data->pixelBuf;

  if (setPixelBuffer(env, pb, buffer) == NOT_OK0) {
      return data->abortFlag;  // We already threw an out of memory exception
  }

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  jerr = (sun_jpeg_error_ptr) cinfo->err;

  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error
         while reading. */
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      if (!(*env)->ExceptionOccurred(env)) {
          char buffer[JMSG_LENGTH_MAX200];
          (*cinfo->err->format_message) ((struct jpeg_common_struct *) cinfo,
                                        buffer);
          JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      }
      if (scanLinePtr != NULL((void*)0)) {
          free(scanLinePtr);
          scanLinePtr = NULL((void*)0);
      }
      return data->abortFlag;
  }

  if (GET_ARRAYS(env, data, &src->next_input_byte) == NOT_OK0) {
      (*env)->ExceptionClear(env);
      JNU_ThrowByName(env,
                      "javax/imageio/IIOException",
                      "Array pin failed");
      return data->abortFlag;
  }

  // If there are no tables in our structure and table arguments aren't
  // NULL, use the table arguments.
  if ((qtables != NULL((void*)0)) && (cinfo->quant_tbl_ptrs[0] == NULL((void*)0))) {
      (void) setQTables(env, (j_common_ptr) cinfo, qtables, TRUE1);
  }

  if ((DCHuffmanTables != NULL((void*)0)) && (cinfo->dc_huff_tbl_ptrs[0] == NULL((void*)0))) {
      setHTables(env, (j_common_ptr) cinfo,
                 DCHuffmanTables,
                 ACHuffmanTables,
                 TRUE1);
  }

  progressive = jpeg_has_multiple_scansjHasMultScn(cinfo);
  if (progressive) {
      cinfo->buffered_image = TRUE1;
      cinfo->input_scan_number = minProgressivePass+1; // Java count from 0
2022#define MAX_JAVA_INT2147483647 2147483647 // XXX Is this defined in JNI somewhere?
      if (maxProgressivePass < MAX_JAVA_INT2147483647) {
          maxProgressivePass++; // For testing
      }
  }

  data->streamBuf.suspendable = FALSE0;

  jpeg_start_decompressjStrtDecompress(cinfo);

  if (numBands !=  cinfo->output_components) {
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      JNU_ThrowByName(env, "javax/imageio/IIOException",
                      "Invalid argument to native readImage");
      return data->abortFlag;
  }

  if (cinfo->output_components <= 0 ||
      cinfo->image_width > (0xffffffffu / (unsigned int)cinfo->output_components))
  {
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      JNU_ThrowByName(env, "javax/imageio/IIOException",
                      "Invalid number of output components");
      return data->abortFlag;
  }

  // Allocate a 1-scanline buffer
  scanLinePtr = (JSAMPROW)malloc(cinfo->image_width*cinfo->output_components);
  if (scanLinePtr == NULL((void*)0)) {
      RELEASE_ARRAYS(env, data, src->next_input_byte);
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Reading JPEG Stream");
      return data->abortFlag;
  }

  // loop over progressive passes
  done = FALSE0;
  while (!done) {
      if (progressive) {
          // initialize the next pass.  Note that this skips up to
          // the first interesting pass.
          jpeg_start_outputjStrtOutput(cinfo, cinfo->input_scan_number);
          if (wantUpdates) {
              RELEASE_ARRAYS(env, data, src->next_input_byte);
              (*env)->CallVoidMethod(env, this,
                                     JPEGImageReader_passStartedID,
                                     cinfo->input_scan_number-1);
              if ((*env)->ExceptionOccurred(env)
                  || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
                  cinfo->err->error_exit((j_common_ptr) cinfo);
              }
          }
      } else if (wantUpdates) {
          RELEASE_ARRAYS(env, data, src->next_input_byte);
          (*env)->CallVoidMethod(env, this,
                                 JPEGImageReader_passStartedID,
                                 0);
          if ((*env)->ExceptionOccurred(env)
              || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
              cinfo->err->error_exit((j_common_ptr) cinfo);
          }
      }

      // Skip until the first interesting line
      while ((data->abortFlag == JNI_FALSE0)
             && ((jint)cinfo->output_scanline < sourceYStart)) {
          jpeg_read_scanlinesjReadScanlines(cinfo, &scanLinePtr, 1);
      }

      scanlineLimit = sourceYStart+sourceHeight;
      pixelLimit = scanLinePtr
          +(sourceXStart+sourceWidth)*cinfo->output_components;

      pixelStride = stepX*cinfo->output_components;
      targetLine = 0;

      while ((data->abortFlag == JNI_FALSE0)
             && ((jint)cinfo->output_scanline < scanlineLimit)) {

          jpeg_read_scanlinesjReadScanlines(cinfo, &scanLinePtr, 1);

          // Now mangle it into our buffer
          out = data->pixelBuf.buf.bp;

          if (orderedBands && (pixelStride == numBands)) {
              // Optimization: The component bands are ordered sequentially,
              // so we can simply use memcpy() to copy the intermediate
              // scanline buffer into the raster.
              in = scanLinePtr + (sourceXStart * cinfo->output_components);
              if (pixelLimit > in) {
                  numBytes = pixelLimit - in;
                  if (numBytes > data->pixelBuf.byteBufferLength) {
                      numBytes = data->pixelBuf.byteBufferLength;
                  }
                  memcpy(out, in, numBytes);
              }
          } else {
              numBytes = numBands;
              for (in = scanLinePtr+sourceXStart*cinfo->output_components;
                   in < pixelLimit &&
                     numBytes <= data->pixelBuf.byteBufferLength;
                   in += pixelStride) {
                  for (i = 0; i < numBands; i++) {
                      *out++ = *(in+bands[i]);
                  }
                  numBytes += numBands;
              }
          }

          // And call it back to Java
          RELEASE_ARRAYS(env, data, src->next_input_byte);
          (*env)->CallVoidMethod(env,
                                 this,
                                 JPEGImageReader_acceptPixelsID,
                                 targetLine++,
                                 progressive);

          if ((*env)->ExceptionOccurred(env)
              || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
              cinfo->err->error_exit((j_common_ptr) cinfo);
          }

          // And skip over uninteresting lines to the next subsampled line
          // Ensure we don't go past the end of the image

          // Lines to skip based on subsampling
          skipLines = stepY - 1;
          // Lines left in the image
          linesLeft =  scanlineLimit - cinfo->output_scanline;
          // Take the minimum
          if (skipLines > linesLeft) {
              skipLines = linesLeft;
          }
          for(i = 0; i < skipLines; i++) {
              jpeg_read_scanlinesjReadScanlines(cinfo, &scanLinePtr, 1);
          }
      }
      if (progressive) {
          jpeg_finish_outputjFinOutput(cinfo); // Increments pass counter
          // Call Java to notify pass complete
          if (jpeg_input_completejInComplete(cinfo)
              || (cinfo->input_scan_number > maxProgressivePass)) {
              done = TRUE1;
          }
      } else {
          done = TRUE1;
      }
      if (wantUpdates) {
          RELEASE_ARRAYS(env, data, src->next_input_byte);
          (*env)->CallVoidMethod(env, this,
                                 JPEGImageReader_passCompleteID);
          if ((*env)->ExceptionOccurred(env)
              || !GET_ARRAYS(env, data, &(src->next_input_byte))) {
              cinfo->err->error_exit((j_common_ptr) cinfo);
          }
      }

  }
  /*
   * We are done, but we might not have read all the lines, or all
   * the passes, so use jpeg_abort instead of jpeg_finish_decompress.
   */
  if ((cinfo->output_scanline != cinfo->output_height) ||
      data->abortFlag == JNI_TRUE1)
   {
      jpeg_abort_decompressjAbrtDecompress(cinfo);
   } else if ((!jpeg_input_completejInComplete(cinfo)) &&
              (progressive &&
               (cinfo->input_scan_number > maxProgressivePass))) {
      /* We haven't reached EOI, but we need to skip to there */
      (*cinfo->src->term_source) (cinfo);
      /* We can use jpeg_abort to release memory and reset global_state */
      jpeg_abortjAbort((j_common_ptr) cinfo);
      (*env)->CallVoidMethod(env,
                             this,
                             JPEGImageReader_skipPastImageID,
                             imageIndex);
  } else {
      jpeg_finish_decompressjFinDecompress(cinfo);
  }

  free(scanLinePtr);

  RELEASE_ARRAYS(env, data, src->next_input_byte);

  return data->abortFlag;
2209}

2211JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2212Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_clearNativeReadAbortFlag
  (JNIEnv *env,
  jobject this,
  jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
          "java/lang/IllegalStateException",
          "Attempting to use reader after dispose()");
      return;
  }

  data->abortFlag = JNI_FALSE0;

2228}

2230JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2231Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_abortRead
  (JNIEnv *env,
   jobject this,
   jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use reader after dispose()");
      return;
  }

  imageio_abort(env, this, data);

2247}

2249JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2250Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_resetLibraryState
  (JNIEnv *env,
   jobject this,
   jlong ptr) {
  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_decompress_ptr cinfo;

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use reader after dispose()");
      return;
  }

  cinfo = (j_decompress_ptr) data->jpegObj;

  jpeg_abort_decompressjAbrtDecompress(cinfo);
2267}


2270JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2271Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_resetReader
  (JNIEnv *env,
   jobject this,
   jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_decompress_ptr cinfo;
  sun_jpeg_error_ptr jerr;

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use reader after dispose()");
      return;
  }

  cinfo = (j_decompress_ptr) data->jpegObj;

  jerr = (sun_jpeg_error_ptr) cinfo->err;

  imageio_reset(env, (j_common_ptr) cinfo, data);

  /*
   * The tables have not been reset, and there is no way to do so
   * in IJG without leaking memory.  The only situation in which
   * this will cause a problem is if an image-only stream is read
   * with this object without initializing the correct tables first.
   * This situation, which should cause an error, might work but
   * produce garbage instead.  If the huffman tables are wrong,
   * it will fail during the decode.  If the q tables are wrong, it
   * will look strange.  This is very unlikely, so don't worry about
   * it.  To be really robust, we would keep a flag for table state
   * and consult it to catch exceptional situations.
   */

  /* above does not clean up the source, so we have to */

  /*
    We need to explicitly initialize exception handler or we may
     longjump to random address from the term_source()
   */

  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {

      /*
        We may get IOException from pushBack() here.

        However it could be legal if original input stream was closed
        earlier (for example because network connection was closed).
        Unfortunately, image inputstream API has no way to check whether
        stream is already closed or IOException was thrown because of some
        other IO problem,
        And we can not avoid call to pushBack() on closed stream for the
        same reason.

        So, for now we will silently eat this exception.

        NB: this may be changed in future when ImageInputStream API will
        become more flexible.
      */

      if ((*env)->ExceptionOccurred(env)) {
          (*env)->ExceptionClear(env);
      }
  } else {
      cinfo->src->term_source(cinfo);
  }

  cinfo->src->bytes_in_buffer = 0;
  cinfo->src->next_input_byte = NULL((void*)0);
2341}

2343JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2344Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_disposeReader
  (JNIEnv *env,
   jclass reader,
   jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_common_ptr info = destroyImageioData(env, data);

  imageio_dispose(info);
2353}

2355/********************** end of Reader *************************/

2357/********************** Writer Support ************************/

2359/********************** Destination Manager *******************/

2361METHODDEF(void)static void
2362/*
* Initialize destination --- called by jpeg_start_compress
* before any data is actually written.  The data arrays
* must be pinned before this is called.
*/
2367imageio_init_destination (j_compress_ptr cinfo)
2368{
  struct jpeg_destination_mgr *dest = cinfo->dest;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  streamBufferPtr sb = &data->streamBuf;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);

  if (sb->buf == NULL((void*)0)) {
      // We forgot to pin the array
      (*env)->FatalError(env, "Output buffer not pinned!");
  }

  dest->next_output_byte = sb->buf;
  dest->free_in_buffer = sb->bufferLength;
2381}

2383/*
* Empty the output buffer --- called whenever buffer fills up.
*
* This routine writes the entire output buffer
* (ignoring the current state of next_output_byte & free_in_buffer),
* resets the pointer & count to the start of the buffer, and returns TRUE
* indicating that the buffer has been dumped.
*/

2392METHODDEF(boolean)static boolean
2393imageio_empty_output_buffer (j_compress_ptr cinfo)
2394{
  struct jpeg_destination_mgr *dest = cinfo->dest;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  streamBufferPtr sb = &data->streamBuf;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);
  jobject output = NULL((void*)0);

  RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));

  GET_IO_REF(output)do { if ((*env)->IsSameObject(env, sb->ioRef, ((void*)0
)) || ((output) = (*env)->NewLocalRef(env, sb->ioRef)) ==
 ((void*)0)) { cinfo->err->error_exit((j_common_ptr) cinfo
); } } while (0);

  (*env)->CallVoidMethod(env,
                         output,
                         JPEGImageWriter_writeOutputDataID,
                         sb->hstreamBuffer,
                         0,
                         sb->bufferLength);
  if ((*env)->ExceptionOccurred(env)
      || !GET_ARRAYS(env, data,
                     (const JOCTET **)(&dest->next_output_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
  }

  dest->next_output_byte = sb->buf;
  dest->free_in_buffer = sb->bufferLength;

  return TRUE1;
2421}

2423/*
* After all of the data has been encoded there may still be some
* more left over in some of the working buffers.  Now is the
* time to clear them out.
*/
2428METHODDEF(void)static void
2429imageio_term_destination (j_compress_ptr cinfo)
2430{
  struct jpeg_destination_mgr *dest = cinfo->dest;
  imageIODataPtr data = (imageIODataPtr) cinfo->client_data;
  streamBufferPtr sb = &data->streamBuf;
  JNIEnv *env = (JNIEnv *)JNU_GetEnv(the_jvm, JNI_VERSION_1_20x00010002);

  /* find out how much needs to be written */
  /* this conversion from size_t to jint is safe, because the lenght of the buffer is limited by jint */
  jint datacount = (jint)(sb->bufferLength - dest->free_in_buffer);

  if (datacount != 0) {
      jobject output = NULL((void*)0);

      RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));

      GET_IO_REF(output)do { if ((*env)->IsSameObject(env, sb->ioRef, ((void*)0
)) || ((output) = (*env)->NewLocalRef(env, sb->ioRef)) ==
 ((void*)0)) { cinfo->err->error_exit((j_common_ptr) cinfo
); } } while (0);

      (*env)->CallVoidMethod(env,
                             output,
                             JPEGImageWriter_writeOutputDataID,
                             sb->hstreamBuffer,
                             0,
                             datacount);

      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data,
                         (const JOCTET **)(&dest->next_output_byte))) {
          cinfo->err->error_exit((j_common_ptr) cinfo);
      }
  }

  dest->next_output_byte = NULL((void*)0);
  dest->free_in_buffer = 0;

2464}

2466/*
* Flush the destination buffer.  This is not called by the library,
* but by our code below.  This is the simplest implementation, though
* certainly not the most efficient.
*/
2471METHODDEF(void)static void
2472imageio_flush_destination(j_compress_ptr cinfo)
2473{
  imageio_term_destination(cinfo);
  imageio_init_destination(cinfo);
2476}

2478/********************** end of destination manager ************/

2480/********************** Writer JNI calls **********************/


2483JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2484Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_initWriterIDs
  (JNIEnv *env,
   jclass cls,
   jclass qTableClass,
   jclass huffClass) {

  CHECK_NULL(JPEGImageWriter_writeOutputDataID = (*env)->GetMethodID(env,do { if ((JPEGImageWriter_writeOutputDataID = (*env)->GetMethodID
(env, cls, "writeOutputData", "([BII)V")) == ((void*)0)) { return
; } } while (0)
                                                  cls,do { if ((JPEGImageWriter_writeOutputDataID = (*env)->GetMethodID
(env, cls, "writeOutputData", "([BII)V")) == ((void*)0)) { return
; } } while (0)
                                                  "writeOutputData",do { if ((JPEGImageWriter_writeOutputDataID = (*env)->GetMethodID
(env, cls, "writeOutputData", "([BII)V")) == ((void*)0)) { return
; } } while (0)
                                                  "([BII)V"))do { if ((JPEGImageWriter_writeOutputDataID = (*env)->GetMethodID
(env, cls, "writeOutputData", "([BII)V")) == ((void*)0)) { return
; } } while (0);
  CHECK_NULL(JPEGImageWriter_warningOccurredID = (*env)->GetMethodID(env,do { if ((JPEGImageWriter_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0)
                                                          cls,do { if ((JPEGImageWriter_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0)
                                                          "warningOccurred",do { if ((JPEGImageWriter_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0)
                                                          "(I)V"))do { if ((JPEGImageWriter_warningOccurredID = (*env)->GetMethodID
(env, cls, "warningOccurred", "(I)V")) == ((void*)0)) { return
; } } while (0);
  CHECK_NULL(JPEGImageWriter_warningWithMessageID =do { if ((JPEGImageWriter_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
                                      (*env)->GetMethodID(env,do { if ((JPEGImageWriter_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
                                                          cls,do { if ((JPEGImageWriter_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
                                                          "warningWithMessage",do { if ((JPEGImageWriter_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0)
                                                          "(Ljava/lang/String;)V"))do { if ((JPEGImageWriter_warningWithMessageID = (*env)->GetMethodID
(env, cls, "warningWithMessage", "(Ljava/lang/String;)V")) ==
 ((void*)0)) { return; } } while (0);
  CHECK_NULL(JPEGImageWriter_writeMetadataID = (*env)->GetMethodID(env,do { if ((JPEGImageWriter_writeMetadataID = (*env)->GetMethodID
(env, cls, "writeMetadata", "()V")) == ((void*)0)) { return; }
 } while (0)
                                                        cls,do { if ((JPEGImageWriter_writeMetadataID = (*env)->GetMethodID
(env, cls, "writeMetadata", "()V")) == ((void*)0)) { return; }
 } while (0)
                                                        "writeMetadata",do { if ((JPEGImageWriter_writeMetadataID = (*env)->GetMethodID
(env, cls, "writeMetadata", "()V")) == ((void*)0)) { return; }
 } while (0)
                                                        "()V"))do { if ((JPEGImageWriter_writeMetadataID = (*env)->GetMethodID
(env, cls, "writeMetadata", "()V")) == ((void*)0)) { return; }
 } while (0);
  CHECK_NULL(JPEGImageWriter_grabPixelsID = (*env)->GetMethodID(env,do { if ((JPEGImageWriter_grabPixelsID = (*env)->GetMethodID
(env, cls, "grabPixels", "(I)V")) == ((void*)0)) { return; } }
 while (0)
                                                     cls,do { if ((JPEGImageWriter_grabPixelsID = (*env)->GetMethodID
(env, cls, "grabPixels", "(I)V")) == ((void*)0)) { return; } }
 while (0)
                                                     "grabPixels",do { if ((JPEGImageWriter_grabPixelsID = (*env)->GetMethodID
(env, cls, "grabPixels", "(I)V")) == ((void*)0)) { return; } }
 while (0)
                                                     "(I)V"))do { if ((JPEGImageWriter_grabPixelsID = (*env)->GetMethodID
(env, cls, "grabPixels", "(I)V")) == ((void*)0)) { return; } }
 while (0);
  CHECK_NULL(JPEGQTable_tableID = (*env)->GetFieldID(env,do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0)
                                          qTableClass,do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0)
                                          "qTable",do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0)
                                          "[I"))do { if ((JPEGQTable_tableID = (*env)->GetFieldID(env, qTableClass
, "qTable", "[I")) == ((void*)0)) { return; } } while (0);
  CHECK_NULL(JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(env,do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0)
                                                  huffClass,do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0)
                                                  "lengths",do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0)
                                                  "[S"))do { if ((JPEGHuffmanTable_lengthsID = (*env)->GetFieldID(
env, huffClass, "lengths", "[S")) == ((void*)0)) { return; } }
 while (0);
  CHECK_NULL(JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env,do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0)
                                                  huffClass,do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0)
                                                  "values",do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0)
                                                  "[S"))do { if ((JPEGHuffmanTable_valuesID = (*env)->GetFieldID(env
, huffClass, "values", "[S")) == ((void*)0)) { return; } } while
 (0);
2523}

2525JNIEXPORT__attribute__((visibility("default"))) jlong JNICALL
2526Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_initJPEGImageWriter
  (JNIEnv *env,
   jobject this) {

  imageIODataPtr ret;
  struct sun_jpeg_error_mgr *jerr;
  struct jpeg_destination_mgr *dest;

  /* This struct contains the JPEG compression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   */
  struct jpeg_compress_struct *cinfo =
      malloc(sizeof(struct jpeg_compress_struct));
  if (cinfo == NULL((void*)0)) {
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Writer");
      return 0;
  }

  /* We use our private extension JPEG error handler.
   */
  jerr = malloc (sizeof(struct sun_jpeg_error_mgr));
  if (jerr == NULL((void*)0)) {
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Writer");
      free(cinfo);
      return 0;
  }

  /* We set up the normal JPEG error routines, then override error_exit. */
  cinfo->err = jpeg_std_errorjStdError(&(jerr->pub));
  jerr->pub.error_exit = sun_jpeg_error_exit;
  /* We need to setup our own print routines */
  jerr->pub.output_message = sun_jpeg_output_message;
  /* Now we can setjmp before every call to the library */

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error. */
      char buffer[JMSG_LENGTH_MAX200];
      (*cinfo->err->format_message) ((struct jpeg_common_struct *) cinfo,
                                    buffer);
      JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      return 0;
  }

  /* Perform library initialization */
  jpeg_create_compress(cinfo)jCreaCompress((cinfo), 62, (size_t) sizeof(struct jpeg_compress_struct
));

  /* Now set up the destination  */
  dest = malloc(sizeof(struct jpeg_destination_mgr));
  if (dest == NULL((void*)0)) {
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Writer");
      imageio_dispose((j_common_ptr)cinfo);
      return 0;
  }

  dest->init_destination = imageio_init_destination;
  dest->empty_output_buffer = imageio_empty_output_buffer;
  dest->term_destination = imageio_term_destination;
  dest->next_output_byte = NULL((void*)0);
  dest->free_in_buffer = 0;

  cinfo->dest = dest;

  /* set up the association to persist for future calls */
  ret = initImageioData(env, (j_common_ptr) cinfo, this);
  if (ret == NULL((void*)0)) {
      (*env)->ExceptionClear(env);
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Initializing Writer");
      imageio_dispose((j_common_ptr)cinfo);
      return 0;
  }
  return ptr_to_jlong(ret)((jlong)(ret));
2606}

2608JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2609Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_setDest
  (JNIEnv *env,
   jobject this,
   jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_compress_ptr cinfo;

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use writer after dispose()");
      return;
  }

  cinfo = (j_compress_ptr) data->jpegObj;

  imageio_set_stream(env, data->jpegObj, data, this);


  // Don't call the init method, as that depends on pinned arrays
  cinfo->dest->next_output_byte = NULL((void*)0);
  cinfo->dest->free_in_buffer = 0;
2632}

2634JNIEXPORT__attribute__((visibility("default"))) void JNICALL
2635Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_writeTables
  (JNIEnv *env,
   jobject this,
   jlong ptr,
   jobjectArray qtables,
   jobjectArray DCHuffmanTables,
   jobjectArray ACHuffmanTables) {

  struct jpeg_destination_mgr *dest;
  sun_jpeg_error_ptr jerr;
  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_compress_ptr cinfo;

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use writer after dispose()");
      return;
  }

  cinfo = (j_compress_ptr) data->jpegObj;
  dest = cinfo->dest;

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  jerr = (sun_jpeg_error_ptr) cinfo->err;

  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error
         while writing. */
      RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));
      if (!(*env)->ExceptionOccurred(env)) {
          char buffer[JMSG_LENGTH_MAX200];
          (*cinfo->err->format_message) ((j_common_ptr) cinfo,
                                        buffer);
          JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      }
      return;
  }

  if (GET_ARRAYS(env, data,
                 (const JOCTET **)(&dest->next_output_byte)) == NOT_OK0) {
      (*env)->ExceptionClear(env);
      JNU_ThrowByName(env,
                      "javax/imageio/IIOException",
                      "Array pin failed");
      return;
  }

  jpeg_suppress_tablesjSuppressTables(cinfo, TRUE1);  // Suppress writing of any current

  data->streamBuf.suspendable = FALSE0;
  if (qtables != NULL((void*)0)) {
2687#ifdef DEBUG_IIO_JPEG
      printf("in writeTables: qtables not NULL\n")__printf_chk (2 - 1, "in writeTables: qtables not NULL\n");
2689#endif
      setQTables(env, (j_common_ptr) cinfo, qtables, TRUE1);
  }

  if (DCHuffmanTables != NULL((void*)0)) {
      setHTables(env, (j_common_ptr) cinfo,
                 DCHuffmanTables, ACHuffmanTables, TRUE1);
  }

  jpeg_write_tablesjWrtTables(cinfo); // Flushes the buffer for you
  RELEASE_ARRAYS(env, data, NULL((void*)0));
2700}

2702static void freeArray(UINT8** arr, jint size) {
  int i;
  if (arr != NULL((void*)0)) {
      for (i = 0; i < size; i++) {
          if (arr[i] != NULL((void*)0)) {
              free(arr[i]);
          }
      }
      free(arr);
  }
2712}

2714JNIEXPORT__attribute__((visibility("default"))) jboolean JNICALL
2715Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_writeImage
  (JNIEnv *env,
   jobject this,
   jlong ptr,
   jbyteArray buffer,
   jint inCs, jint outCs,
   jint numBands,
   jintArray bandSizes,
   jint srcWidth,
   jint destWidth, jint destHeight,
   jint stepX, jint stepY,
   jobjectArray qtables,
   jboolean writeDQT,
   jobjectArray DCHuffmanTables,
   jobjectArray ACHuffmanTables,
   jboolean writeDHT,
   jboolean optimize,
   jboolean progressive,
   jint numScans,
   jintArray scanInfo,
   jintArray componentIds,
   jintArray HsamplingFactors,
   jintArray VsamplingFactors,
   jintArray QtableSelectors,
   jboolean haveMetadata,
   jint restartInterval) {

  struct jpeg_destination_mgr *dest;
  JSAMPROW scanLinePtr;
  int i, j;
  int pixelStride;
  unsigned char *in, *out, *pixelLimit, *scanLineLimit;
  unsigned int scanLineSize, pixelBufferSize;
  int targetLine;
  pixelBufferPtr pb;
  sun_jpeg_error_ptr jerr;
  jint *ids, *hfactors, *vfactors, *qsels;
  jsize qlen, hlen;
  int *scanptr;
  jint *scanData;
  jint *bandSize;
  int maxBandValue, halfMaxBandValue;
  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_compress_ptr cinfo;
  UINT8** scale = NULL((void*)0);
  boolean success = TRUE1;


  /* verify the inputs */

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use writer after dispose()");
      return JNI_FALSE0;
  }

  if ((buffer == NULL((void*)0)) ||
      (qtables == NULL((void*)0)) ||
      // H tables can be null if optimizing
      (componentIds == NULL((void*)0)) ||
      (HsamplingFactors == NULL((void*)0)) || (VsamplingFactors == NULL((void*)0)) ||
      (QtableSelectors == NULL((void*)0)) ||
      ((numScans != 0) && (scanInfo != NULL((void*)0)))) {

      JNU_ThrowNullPointerException(env, 0);
      return JNI_FALSE0;

  }

  scanLineSize = destWidth * numBands;
  if ((inCs < 0) || (inCs > JCS_YCCK) ||
      (outCs < 0) || (outCs > JCS_YCCK) ||
      (numBands < 1) || (numBands > MAX_BANDS4) ||
      (srcWidth < 0) ||
      (destWidth < 0) || (destWidth > srcWidth) ||
      (destHeight < 0) ||
      (stepX < 0) || (stepY < 0) ||
      ((INT_MAX2147483647 / numBands) < destWidth))  /* destWidth causes an integer overflow */
  {
      JNU_ThrowByName(env, "javax/imageio/IIOException",
                      "Invalid argument to native writeImage");
      return JNI_FALSE0;
  }

  if (stepX > srcWidth) {
      stepX = srcWidth;
  }

  bandSize = (*env)->GetIntArrayElements(env, bandSizes, NULL((void*)0));
  CHECK_NULL_RETURN(bandSize, JNI_FALSE)do { if ((bandSize) == ((void*)0)) { return (0); } } while (0
);

  for (i = 0; i < numBands; i++) {
      if (bandSize[i] <= 0 || bandSize[i] > JPEG_BAND_SIZE8) {
          (*env)->ReleaseIntArrayElements(env, bandSizes,
                                          bandSize, JNI_ABORT2);
          JNU_ThrowByName(env, "javax/imageio/IIOException", "Invalid Image");
          return JNI_FALSE0;
      }
  }

  for (i = 0; i < numBands; i++) {
      if (bandSize[i] != JPEG_BAND_SIZE8) {
          if (scale == NULL((void*)0)) {
              scale = (UINT8**) calloc(numBands, sizeof(UINT8*));

              if (scale == NULL((void*)0)) {
                  (*env)->ReleaseIntArrayElements(env, bandSizes,
                                                  bandSize, JNI_ABORT2);
                  JNU_ThrowByName( env, "java/lang/OutOfMemoryError",
                                   "Writing JPEG Stream");
                  return JNI_FALSE0;
              }
          }

          maxBandValue = (1 << bandSize[i]) - 1;

          scale[i] = (UINT8*) malloc((maxBandValue + 1) * sizeof(UINT8));

          if (scale[i] == NULL((void*)0)) {
              // Cleanup before throwing an out of memory exception
              for (j = 0; j < i; j++) {
                  free(scale[j]);
              }
              free(scale);
              (*env)->ReleaseIntArrayElements(env, bandSizes,
                                              bandSize, JNI_ABORT2);
              JNU_ThrowByName( env, "java/lang/OutOfMemoryError",
                               "Writing JPEG Stream");
              return JNI_FALSE0;
          }

          halfMaxBandValue = maxBandValue >> 1;

          for (j = 0; j <= maxBandValue; j++) {
              scale[i][j] = (UINT8)
                  ((j*MAX_JPEG_BAND_VALUE((1<<8)-1) + halfMaxBandValue)/maxBandValue);
          }
      }
  }

  (*env)->ReleaseIntArrayElements(env, bandSizes,
                                  bandSize, JNI_ABORT2);

  cinfo = (j_compress_ptr) data->jpegObj;
  dest = cinfo->dest;

  /* Set the buffer as our PixelBuffer */
  pb = &data->pixelBuf;

  if (setPixelBuffer(env, pb, buffer) == NOT_OK0) {
      freeArray(scale, numBands);
      return data->abortFlag;  // We already threw an out of memory exception
  }

  // Allocate a 1-scanline buffer
  scanLinePtr = (JSAMPROW)malloc(scanLineSize);
  if (scanLinePtr == NULL((void*)0)) {
      freeArray(scale, numBands);
      JNU_ThrowByName( env,
                       "java/lang/OutOfMemoryError",
                       "Writing JPEG Stream");
      return data->abortFlag;
  }
  scanLineLimit = scanLinePtr + scanLineSize;

  /* Establish the setjmp return context for sun_jpeg_error_exit to use. */
  jerr = (sun_jpeg_error_ptr) cinfo->err;

  if (setjmp(jerr->setjmp_buffer)_setjmp (jerr->setjmp_buffer)) {
      /* If we get here, the JPEG code has signaled an error
         while writing. */
      RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));
      if (!(*env)->ExceptionOccurred(env)) {
          char buffer[JMSG_LENGTH_MAX200];
          (*cinfo->err->format_message) ((j_common_ptr) cinfo,
                                        buffer);
          JNU_ThrowByName(env, "javax/imageio/IIOException", buffer);
      }

      freeArray(scale, numBands);
      free(scanLinePtr);
      return data->abortFlag;
  }

  // set up parameters
  cinfo->image_width = destWidth;
  cinfo->image_height = destHeight;
  cinfo->input_components = numBands;
  cinfo->in_color_space = inCs;

  jpeg_set_defaultsjSetDefaults(cinfo);

  jpeg_set_colorspacejSetColorspace(cinfo, outCs);

  cinfo->optimize_coding = optimize;

  cinfo->write_JFIF_header = FALSE0;
  cinfo->write_Adobe_marker = FALSE0;
  // copy componentIds
  ids = (*env)->GetIntArrayElements(env, componentIds, NULL((void*)0));
  hfactors = (*env)->GetIntArrayElements(env, HsamplingFactors, NULL((void*)0));
  vfactors = (*env)->GetIntArrayElements(env, VsamplingFactors, NULL((void*)0));
  qsels = (*env)->GetIntArrayElements(env, QtableSelectors, NULL((void*)0));

  if (ids && hfactors && vfactors && qsels) {
      for (i = 0; i < numBands; i++) {
          cinfo->comp_info[i].component_id = ids[i];
          cinfo->comp_info[i].h_samp_factor = hfactors[i];
          cinfo->comp_info[i].v_samp_factor = vfactors[i];
          cinfo->comp_info[i].quant_tbl_no = qsels[i];
      }
  } else {
      success = FALSE0;
  }

  if (ids) {
      (*env)->ReleaseIntArrayElements(env, componentIds, ids, JNI_ABORT2);
  }
  if (hfactors) {
      (*env)->ReleaseIntArrayElements(env, HsamplingFactors, hfactors, JNI_ABORT2);
  }
  if (vfactors) {
      (*env)->ReleaseIntArrayElements(env, VsamplingFactors, vfactors, JNI_ABORT2);
  }
  if (qsels) {
      (*env)->ReleaseIntArrayElements(env, QtableSelectors, qsels, JNI_ABORT2);
  }
  if (!success) {
      freeArray(scale, numBands);
      free(scanLinePtr);
      return data->abortFlag;
  }

  jpeg_suppress_tablesjSuppressTables(cinfo, TRUE1);  // Disable writing any current

  qlen = setQTables(env, (j_common_ptr) cinfo, qtables, writeDQT);

  if (!optimize) {
      // Set the h tables
      hlen = setHTables(env,
                        (j_common_ptr) cinfo,
                        DCHuffmanTables,
                        ACHuffmanTables,
                        writeDHT);
  }

  if (GET_ARRAYS(env, data,
                 (const JOCTET **)(&dest->next_output_byte)) == NOT_OK0) {
      (*env)->ExceptionClear(env);
      freeArray(scale, numBands);
      free(scanLinePtr);
      JNU_ThrowByName(env,
                      "javax/imageio/IIOException",
                      "Array pin failed");
      return data->abortFlag;
  }

  data->streamBuf.suspendable = FALSE0;

  if (progressive) {
      if (numScans == 0) { // then use default scans
          jpeg_simple_progressionjSimProgress(cinfo);
      } else {
          cinfo->num_scans = numScans;
          // Copy the scanInfo to a local array
          // The following is copied from jpeg_simple_progression:
/* Allocate space for script.
 * We need to put it in the permanent pool in case the application performs
 * multiple compressions without changing the settings.  To avoid a memory
 * leak if jpeg_simple_progression is called repeatedly for the same JPEG
 * object, we try to re-use previously allocated space, and we allocate
 * enough space to handle YCbCr even if initially asked for grayscale.
 */
          if (cinfo->script_space == NULL((void*)0)
              || cinfo->script_space_size < numScans) {
              cinfo->script_space_size = MAX(numScans, 10)((numScans) > (10) ? (numScans) : (10));
              cinfo->script_space = (jpeg_scan_info *)
                  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
                                              JPOOL_PERMANENT0,
                                              cinfo->script_space_size
                                              * sizeof(jpeg_scan_info));
          }
          cinfo->scan_info = cinfo->script_space;
          scanptr = (int *) cinfo->script_space;
          scanData = (*env)->GetIntArrayElements(env, scanInfo, NULL((void*)0));
          if (scanData == NULL((void*)0)) {
              RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));
              freeArray(scale, numBands);
              free(scanLinePtr);
              return data->abortFlag;
          }
          // number of jints per scan is 9
          // We avoid a memcpy to handle different size ints
          for (i = 0; i < numScans*9; i++) {
              scanptr[i] = scanData[i];
          }
          (*env)->ReleaseIntArrayElements(env, scanInfo,
                                          scanData, JNI_ABORT2);

      }
  }

  cinfo->restart_interval = restartInterval;

3020#ifdef DEBUG_IIO_JPEG
  printf("writer setup complete, starting compressor\n")__printf_chk (2 - 1, "writer setup complete, starting compressor\n"
);
3022#endif

  // start the compressor; tables must already be set
  jpeg_start_compressjStrtCompress(cinfo, FALSE0); // Leaves sent_table alone

  if (haveMetadata) {
      // Flush the buffer
      imageio_flush_destination(cinfo);
      // Call Java to write the metadata
      RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));
      (*env)->CallVoidMethod(env,
                             this,
                             JPEGImageWriter_writeMetadataID);
      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data,
                         (const JOCTET **)(&dest->next_output_byte))) {
              cinfo->err->error_exit((j_common_ptr) cinfo);
       }
  }

  targetLine = 0;
  pixelBufferSize = srcWidth * numBands;
  pixelStride = numBands * stepX;

  // for each line in destHeight
  while ((data->abortFlag == JNI_FALSE0)
         && (cinfo->next_scanline < cinfo->image_height)) {
      // get the line from Java
      RELEASE_ARRAYS(env, data, (const JOCTET *)(dest->next_output_byte));
      (*env)->CallVoidMethod(env,
                             this,
                             JPEGImageWriter_grabPixelsID,
                             targetLine);
      if ((*env)->ExceptionOccurred(env)
          || !GET_ARRAYS(env, data,
                         (const JOCTET **)(&dest->next_output_byte))) {
              cinfo->err->error_exit((j_common_ptr) cinfo);
       }

      // subsample it into our buffer

      in = data->pixelBuf.buf.bp;
      out = scanLinePtr;
      pixelLimit = in + ((pixelBufferSize > data->pixelBuf.byteBufferLength) ?
                         data->pixelBuf.byteBufferLength : pixelBufferSize);
      for (; (in < pixelLimit) && (out < scanLineLimit); in += pixelStride) {
          for (i = 0; i < numBands; i++) {
              if (scale !=NULL((void*)0) && scale[i] != NULL((void*)0)) {
                  *out++ = scale[i][*(in+i)];
3071#ifdef DEBUG_IIO_JPEG
                  if (in == data->pixelBuf.buf.bp){ // Just the first pixel
                      printf("in %d -> out %d, ", *(in+i), *(out-i-1))__printf_chk (2 - 1, "in %d -> out %d, ", *(in+i), *(out-i
-1));
                  }
3075#endif

3077#ifdef DEBUG_IIO_JPEG
                  if (in == data->pixelBuf.buf.bp){ // Just the first pixel
                      printf("\n")__printf_chk (2 - 1, "\n");
                  }
3081#endif
              } else {
                  *out++ = *(in+i);
              }
          }
      }
      // write it out
      jpeg_write_scanlinesjWrtScanlines(cinfo, (JSAMPARRAY)&scanLinePtr, 1);
      targetLine += stepY;
  }

  /*
   * We are done, but we might not have done all the lines,
   * so use jpeg_abort instead of jpeg_finish_compress.
   */
  if (cinfo->next_scanline == cinfo->image_height) {
      jpeg_finish_compressjFinCompress(cinfo);  // Flushes buffer with term_dest
  } else {
      jpeg_abortjAbort((j_common_ptr)cinfo);
  }

  freeArray(scale, numBands);
  free(scanLinePtr);
  RELEASE_ARRAYS(env, data, NULL((void*)0));
  return data->abortFlag;
3106}

3108JNIEXPORT__attribute__((visibility("default"))) void JNICALL
3109Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_abortWrite
  (JNIEnv *env,
   jobject this,
   jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use writer after dispose()");
      return;
  }

  imageio_abort(env, this, data);
3124}

3126JNIEXPORT__attribute__((visibility("default"))) void JNICALL
3127Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_resetWriter
  (JNIEnv *env,
   jobject this,
   jlong ptr) {
  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_compress_ptr cinfo;

  if (data == NULL((void*)0)) {
      JNU_ThrowByName(env,
                      "java/lang/IllegalStateException",
                      "Attempting to use writer after dispose()");
      return;
  }

  cinfo = (j_compress_ptr) data->jpegObj;

  imageio_reset(env, (j_common_ptr) cinfo, data);

  /*
   * The tables have not been reset, and there is no way to do so
   * in IJG without leaking memory.  The only situation in which
   * this will cause a problem is if an image-only stream is written
   * with this object without initializing the correct tables first,
   * which should not be possible.
   */

  cinfo->dest->next_output_byte = NULL((void*)0);
  cinfo->dest->free_in_buffer = 0;
3155}

3157JNIEXPORT__attribute__((visibility("default"))) void JNICALL
3158Java_com_sun_imageio_plugins_jpeg_JPEGImageWriter_disposeWriter
  (JNIEnv *env,
   jclass writer,
   jlong ptr) {

  imageIODataPtr data = (imageIODataPtr)jlong_to_ptr(ptr)((void*)(ptr));
  j_common_ptr info = destroyImageioData(env, data);

  imageio_dispose(info);
3167}