Update libjpeg_turbo to 1.4.90 from https://github.com/libjpeg-turbo/

java/org/libjpegturbo/turbojpeg/TJCompressor.java

Index: java/org/libjpegturbo/turbojpeg/TJCompressor.java
diff --git a/java/org/libjpegturbo/turbojpeg/TJCompressor.java b/java/org/libjpegturbo/turbojpeg/TJCompressor.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ff8e4d5ecd8b16e7f994ffeeab7124b64ef205e
--- /dev/null
+++ b/java/org/libjpegturbo/turbojpeg/TJCompressor.java
@@ -0,0 +1,658 @@
+/*
+ * Copyright (C)2011-2015 D. R. Commander.  All Rights Reserved.
+ * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.libjpegturbo.turbojpeg;
+
+import java.awt.image.*;
+import java.nio.*;
+import java.io.*;
+
+/**
+ * TurboJPEG compressor
+ */
+public class TJCompressor implements Closeable {
+
+  private static final String NO_ASSOC_ERROR =
+    "No source image is associated with this instance";
+
+  /**
+   * Create a TurboJPEG compressor instance.
+   */
+  public TJCompressor() throws TJException {
+    init();
+  }
+
+  /**
+   * Create a TurboJPEG compressor instance and associate the uncompressed
+   * source image stored in <code>srcImage</code> with the newly created
+   * instance.
+   *
+   * @param srcImage see {@link #setSourceImage} for description
+   *
+   * @param x see {@link #setSourceImage} for description
+   *
+   * @param y see {@link #setSourceImage} for description
+   *
+   * @param width see {@link #setSourceImage} for description
+   *
+   * @param pitch see {@link #setSourceImage} for description
+   *
+   * @param height see {@link #setSourceImage} for description
+   *
+   * @param pixelFormat pixel format of the source image (one of
+   * {@link TJ#PF_RGB TJ.PF_*})
+   */
+  public TJCompressor(byte[] srcImage, int x, int y, int width, int pitch,
+                      int height, int pixelFormat) throws TJException {
+    setSourceImage(srcImage, x, y, width, pitch, height, pixelFormat);
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #TJCompressor(byte[], int, int, int, int, int, int)} instead.
+   */
+  @Deprecated
+  public TJCompressor(byte[] srcImage, int width, int pitch, int height,
+                      int pixelFormat) throws TJException {
+    setSourceImage(srcImage, width, pitch, height, pixelFormat);
+  }
+
+  /**
+   * Create a TurboJPEG compressor instance and associate the uncompressed
+   * source image stored in <code>srcImage</code> with the newly created
+   * instance.
+   *
+   * @param srcImage see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param x see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param y see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param width see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   *
+   * @param height see
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} for description
+   */
+  public TJCompressor(BufferedImage srcImage, int x, int y, int width,
+                      int height) throws TJException {
+    setSourceImage(srcImage, x, y, width, height);
+  }
+
+  /**
+   * Associate an uncompressed RGB, grayscale, or CMYK source image with this
+   * compressor instance.
+   *
+   * @param srcImage image buffer containing RGB, grayscale, or CMYK pixels to
+   * be compressed or encoded.  This buffer is not modified.
+   *
+   * @param x x offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param y y offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param width width (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded
+   *
+   * @param pitch bytes per line of the source image.  Normally, this should be
+   * <code>width * TJ.pixelSize(pixelFormat)</code> if the source image is
+   * unpadded, but you can use this parameter to, for instance, specify that
+   * the scanlines in the source image are padded to a 4-byte boundary or to
+   * compress/encode a JPEG or YUV image from a region of a larger source
+   * image.  You can also be clever and use this parameter to skip lines, etc.
+   * Setting this parameter to 0 is the equivalent of setting it to
+   * <code>width * TJ.pixelSize(pixelFormat)</code>.
+   *
+   * @param height height (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded
+   *
+   * @param pixelFormat pixel format of the source image (one of
+   * {@link TJ#PF_RGB TJ.PF_*})
+   */
+  public void setSourceImage(byte[] srcImage, int x, int y, int width,
+                             int pitch, int height, int pixelFormat)
+                             throws TJException {
+    if (handle == 0) init();
+    if (srcImage == null || x < 0 || y < 0 || width < 1 || height < 1 ||
+        pitch < 0 || pixelFormat < 0 || pixelFormat >= TJ.NUMPF)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    srcBuf = srcImage;
+    srcWidth = width;
+    if (pitch == 0)
+      srcPitch = width * TJ.getPixelSize(pixelFormat);
+    else
+      srcPitch = pitch;
+    srcHeight = height;
+    srcPixelFormat = pixelFormat;
+    srcX = x;
+    srcY = y;
+    srcBufInt = null;
+    srcYUVImage = null;
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(byte[], int, int, int, int, int, int)} instead.
+   */
+  @Deprecated
+  public void setSourceImage(byte[] srcImage, int width, int pitch,
+                             int height, int pixelFormat) throws TJException {
+    setSourceImage(srcImage, 0, 0, width, pitch, height, pixelFormat);
+    srcX = srcY = -1;
+  }
+
+  /**
+   * Associate an uncompressed RGB or grayscale source image with this
+   * compressor instance.
+   *
+   * @param srcImage a <code>BufferedImage</code> instance containing RGB or
+   * grayscale pixels to be compressed or encoded.  This image is not modified.
+   *
+   * @param x x offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param y y offset (in pixels) of the region in the source image from which
+   * the JPEG or YUV image should be compressed/encoded
+   *
+   * @param width width (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded (0 = use the
+   * width of the source image)
+   *
+   * @param height height (in pixels) of the region in the source image from
+   * which the JPEG or YUV image should be compressed/encoded (0 = use the
+   * height of the source image)
+   */
+  public void setSourceImage(BufferedImage srcImage, int x, int y, int width,
+                             int height) throws TJException {
+    if (handle == 0) init();
+    if (srcImage == null || x < 0 || y < 0 || width < 0 || height < 0)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    srcX = x;
+    srcY = y;
+    srcWidth = (width == 0) ? srcImage.getWidth(): width;
+    srcHeight = (height == 0) ? srcImage.getHeight() : height;
+    if (x + width > srcImage.getWidth() || y + height > srcImage.getHeight())
+      throw new IllegalArgumentException("Compression region exceeds the bounds of the source image");
+
+    int pixelFormat;
+    boolean intPixels = false;
+    if (byteOrder == null)
+      byteOrder = ByteOrder.nativeOrder();
+    switch(srcImage.getType()) {
+      case BufferedImage.TYPE_3BYTE_BGR:
+        pixelFormat = TJ.PF_BGR;  break;
+      case BufferedImage.TYPE_4BYTE_ABGR:
+      case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+        pixelFormat = TJ.PF_XBGR;  break;
+      case BufferedImage.TYPE_BYTE_GRAY:
+        pixelFormat = TJ.PF_GRAY;  break;
+      case BufferedImage.TYPE_INT_BGR:
+        if (byteOrder == ByteOrder.BIG_ENDIAN)
+          pixelFormat = TJ.PF_XBGR;
+        else
+          pixelFormat = TJ.PF_RGBX;
+        intPixels = true;  break;
+      case BufferedImage.TYPE_INT_RGB:
+      case BufferedImage.TYPE_INT_ARGB:
+      case BufferedImage.TYPE_INT_ARGB_PRE:
+        if (byteOrder == ByteOrder.BIG_ENDIAN)
+          pixelFormat = TJ.PF_XRGB;
+        else
+          pixelFormat = TJ.PF_BGRX;
+        intPixels = true;  break;
+      default:
+        throw new IllegalArgumentException("Unsupported BufferedImage format");
+    }
+    srcPixelFormat = pixelFormat;
+
+    WritableRaster wr = srcImage.getRaster();
+    if (intPixels) {
+      SinglePixelPackedSampleModel sm =
+        (SinglePixelPackedSampleModel)srcImage.getSampleModel();
+      srcStride = sm.getScanlineStride();
+      DataBufferInt db = (DataBufferInt)wr.getDataBuffer();
+      srcBufInt = db.getData();
+      srcBuf = null;
+    } else {
+      ComponentSampleModel sm =
+        (ComponentSampleModel)srcImage.getSampleModel();
+      int pixelSize = sm.getPixelStride();
+      if (pixelSize != TJ.getPixelSize(pixelFormat))
+        throw new IllegalArgumentException("Inconsistency between pixel format and pixel size in BufferedImage");
+      srcPitch = sm.getScanlineStride();
+      DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
+      srcBuf = db.getData();
+      srcBufInt = null;
+    }
+    srcYUVImage = null;
+  }
+
+  /**
+   * Associate an uncompressed YUV planar source image with this compressor
+   * instance.
+   *
+   * @param srcImage YUV planar image to be compressed.  This image is not
+   * modified.
+   */
+  public void setSourceImage(YUVImage srcImage) throws TJException {
+    if (handle == 0) init();
+    if (srcImage == null)
+      throw new IllegalArgumentException("Invalid argument in setSourceImage()");
+    srcYUVImage = srcImage;
+    srcBuf = null;
+    srcBufInt = null;
+  }
+
+  /**
+   * Set the level of chrominance subsampling for subsequent compress/encode
+   * operations.  When pixels are converted from RGB to YCbCr (see
+   * {@link TJ#CS_YCbCr}) or from CMYK to YCCK (see {@link TJ#CS_YCCK}) as part
+   * of the JPEG compression process, some of the Cb and Cr (chrominance)
+   * components can be discarded or averaged together to produce a smaller
+   * image with little perceptible loss of image clarity (the human eye is more
+   * sensitive to small changes in brightness than to small changes in color.)
+   * This is called "chrominance subsampling".
+   * <p>
+   * NOTE: This method has no effect when compressing a JPEG image from a YUV
+   * planar source.  In that case, the level of chrominance subsampling in
+   * the JPEG image is determined by the source.  Further, this method has no
+   * effect when encoding to a pre-allocated {@link YUVImage} instance.  In
+   * that case, the level of chrominance subsampling is determined by the
+   * destination.
+   *
+   * @param newSubsamp the level of chrominance subsampling to use in
+   * subsequent compress/encode oeprations (one of
+   * {@link TJ#SAMP_444 TJ.SAMP_*})
+   */
+  public void setSubsamp(int newSubsamp) {
+    if (newSubsamp < 0 || newSubsamp >= TJ.NUMSAMP)
+      throw new IllegalArgumentException("Invalid argument in setSubsamp()");
+    subsamp = newSubsamp;
+  }
+
+  /**
+   * Set the JPEG image quality level for subsequent compress operations.
+   *
+   * @param quality the new JPEG image quality level (1 to 100, 1 = worst,
+   * 100 = best)
+   */
+  public void setJPEGQuality(int quality) {
+    if (quality < 1 || quality > 100)
+      throw new IllegalArgumentException("Invalid argument in setJPEGQuality()");
+    jpegQuality = quality;
+  }
+
+  /**
+   * Compress the uncompressed source image associated with this compressor
+   * instance and output a JPEG image to the given destination buffer.
+   *
+   * @param dstBuf buffer that will receive the JPEG image.  Use
+   * {@link TJ#bufSize} to determine the maximum size for this buffer based on
+   * the source image's width and height and the desired level of chrominance
+   * subsampling.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void compress(byte[] dstBuf, int flags) throws TJException {
+    if (dstBuf == null || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in compress()");
+    if (srcBuf == null && srcBufInt == null && srcYUVImage == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (jpegQuality < 0)
+      throw new IllegalStateException("JPEG Quality not set");
+    if (subsamp < 0 && srcYUVImage == null)
+      throw new IllegalStateException("Subsampling level not set");
+
+    if (srcYUVImage != null)
+      compressedSize = compressFromYUV(srcYUVImage.getPlanes(),
+                                       srcYUVImage.getOffsets(),
+                                       srcYUVImage.getWidth(),
+                                       srcYUVImage.getStrides(),
+                                       srcYUVImage.getHeight(),
+                                       srcYUVImage.getSubsamp(),
+                                       dstBuf, jpegQuality, flags);
+    else if (srcBuf != null) {
+      if (srcX >= 0 && srcY >= 0)
+        compressedSize = compress(srcBuf, srcX, srcY, srcWidth, srcPitch,
+                                  srcHeight, srcPixelFormat, dstBuf, subsamp,
+                                  jpegQuality, flags);
+      else
+        compressedSize = compress(srcBuf, srcWidth, srcPitch, srcHeight,
+                                  srcPixelFormat, dstBuf, subsamp, jpegQuality,
+                                  flags);
+    } else if (srcBufInt != null) {
+      if (srcX >= 0 && srcY >= 0)
+        compressedSize = compress(srcBufInt, srcX, srcY, srcWidth, srcStride,
+                                  srcHeight, srcPixelFormat, dstBuf, subsamp,
+                                  jpegQuality, flags);
+      else
+        compressedSize = compress(srcBufInt, srcWidth, srcStride, srcHeight,
+                                  srcPixelFormat, dstBuf, subsamp, jpegQuality,
+                                  flags);
+    }
+  }
+
+  /**
+   * Compress the uncompressed source image associated with this compressor
+   * instance and return a buffer containing a JPEG image.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a buffer containing a JPEG image.  The length of this buffer will
+   * not be equal to the size of the JPEG image.  Use {@link
+   * #getCompressedSize} to obtain the size of the JPEG image.
+   */
+  public byte[] compress(int flags) throws TJException {
+    checkSourceImage();
+    byte[] buf = new byte[TJ.bufSize(srcWidth, srcHeight, subsamp)];
+    compress(buf, flags);
+    return buf;
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #compress(byte[], int)} instead.
+   */
+  @Deprecated
+  public void compress(BufferedImage srcImage, byte[] dstBuf, int flags)
+                       throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    compress(dstBuf, flags);
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #compress(int)} instead.
+   */
+  @Deprecated
+  public byte[] compress(BufferedImage srcImage, int flags)
+                         throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    return compress(flags);
+  }
+
+  /**
+   * Encode the uncompressed source image associated with this compressor
+   * instance into a YUV planar image and store it in the given
+   * <code>YUVImage</code> instance.   This method uses the accelerated color
+   * conversion routines in TurboJPEG's underlying codec but does not execute
+   * any of the other steps in the JPEG compression process.  Encoding
+   * CMYK source images to YUV is not supported.
+   *
+   * @param dstImage {@link YUVImage} instance that will receive the YUV planar
+   * image
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   */
+  public void encodeYUV(YUVImage dstImage, int flags) throws TJException {
+    if (dstImage == null || flags < 0)
+      throw new IllegalArgumentException("Invalid argument in encodeYUV()");
+    if (srcBuf == null && srcBufInt == null)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+    if (srcYUVImage != null)
+      throw new IllegalStateException("Source image is not correct type");
+    checkSubsampling();
+    if (srcWidth != dstImage.getWidth() || srcHeight != dstImage.getHeight())
+      throw new IllegalStateException("Destination image is the wrong size");
+
+    if (srcBufInt != null) {
+      encodeYUV(srcBufInt, srcX, srcY, srcWidth, srcStride, srcHeight,
+                srcPixelFormat, dstImage.getPlanes(), dstImage.getOffsets(),
+                dstImage.getStrides(), dstImage.getSubsamp(), flags);
+    } else {
+      encodeYUV(srcBuf, srcX, srcY, srcWidth, srcPitch, srcHeight,
+                srcPixelFormat, dstImage.getPlanes(), dstImage.getOffsets(),
+                dstImage.getStrides(), dstImage.getSubsamp(), flags);
+    }
+    compressedSize = 0;
+  }
+
+  /**
+   * @deprecated Use {@link #encodeYUV(YUVImage, int)} instead.
+   */
+  @Deprecated
+  public void encodeYUV(byte[] dstBuf, int flags) throws TJException {
+    if(dstBuf == null)
+      throw new IllegalArgumentException("Invalid argument in encodeYUV()");
+    checkSourceImage();
+    checkSubsampling();
+    YUVImage yuvImage = new YUVImage(dstBuf, srcWidth, 4, srcHeight, subsamp);
+    encodeYUV(yuvImage, flags);
+  }
+
+  /**
+   * Encode the uncompressed source image associated with this compressor
+   * instance into a unified YUV planar image buffer and return a
+   * <code>YUVImage</code> instance containing the encoded image.  This method
+   * uses the accelerated color conversion routines in TurboJPEG's underlying
+   * codec but does not execute any of the other steps in the JPEG compression
+   * process.  Encoding CMYK source images to YUV is not supported.
+   *
+   * @param pad the width of each line in each plane of the YUV image will be
+   * padded to the nearest multiple of this number of bytes (must be a power of
+   * 2.)
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a YUV planar image.
+   */
+  public YUVImage encodeYUV(int pad, int flags) throws TJException {
+    checkSourceImage();
+    checkSubsampling();
+    if(pad < 1 || ((pad & (pad - 1)) != 0))
+      throw new IllegalStateException("Invalid argument in encodeYUV()");
+    YUVImage yuvImage = new YUVImage(srcWidth, pad, srcHeight, subsamp);
+    encodeYUV(yuvImage, flags);
+    return yuvImage;
+  }
+
+  /**
+   * Encode the uncompressed source image associated with this compressor
+   * instance into separate Y, U (Cb), and V (Cr) image planes and return a
+   * <code>YUVImage</code> instance containing the encoded image planes.  This
+   * method uses the accelerated color conversion routines in TurboJPEG's
+   * underlying codec but does not execute any of the other steps in the JPEG
+   * compression process.  Encoding CMYK source images to YUV is not supported.
+   *
+   * @param strides an array of integers, each specifying the number of bytes
+   * per line in the corresponding plane of the output image.  Setting the
+   * stride for any plane to 0 is the same as setting it to the component width
+   * of the plane.  If <code>strides</code> is null, then the strides for all
+   * planes will be set to their respective component widths.  You can adjust
+   * the strides in order to add an arbitrary amount of line padding to each
+   * plane.
+   *
+   * @param flags the bitwise OR of one or more of
+   * {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
+   *
+   * @return a YUV planar image.
+   */
+  public YUVImage encodeYUV(int[] strides, int flags) throws TJException {
+    checkSourceImage();
+    checkSubsampling();
+    YUVImage yuvImage = new YUVImage(srcWidth, strides, srcHeight, subsamp);
+    encodeYUV(yuvImage, flags);
+    return yuvImage;
+  }
+
+  /**
+   * @deprecated Use {@link #encodeYUV(int, int)} instead.
+   */
+  @Deprecated
+  public byte[] encodeYUV(int flags) throws TJException {
+    checkSourceImage();
+    checkSubsampling();
+    YUVImage yuvImage = new YUVImage(srcWidth, 4, srcHeight, subsamp);
+    encodeYUV(yuvImage, flags);
+    return yuvImage.getBuf();
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #encodeYUV(byte[], int)} instead.
+   */
+  @Deprecated
+  public void encodeYUV(BufferedImage srcImage, byte[] dstBuf, int flags)
+                        throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    encodeYUV(dstBuf, flags);
+  }
+
+  /**
+   * @deprecated Use
+   * {@link #setSourceImage(BufferedImage, int, int, int, int)} and
+   * {@link #encodeYUV(int, int)} instead.
+   */
+  @Deprecated
+  public byte[] encodeYUV(BufferedImage srcImage, int flags)
+                          throws TJException {
+    setSourceImage(srcImage, 0, 0, 0, 0);
+    return encodeYUV(flags);
+  }
+
+  /**
+   * Returns the size of the image (in bytes) generated by the most recent
+   * compress operation.
+   *
+   * @return the size of the image (in bytes) generated by the most recent
+   * compress operation.
+   */
+  public int getCompressedSize() {
+    return compressedSize;
+  }
+
+  /**
+   * Free the native structures associated with this compressor instance.
+   */
+  @Override
+  public void close() throws TJException {
+    if (handle != 0)
+      destroy();
+  }
+
+  @Override
+  protected void finalize() throws Throwable {
+    try {
+      close();
+    } catch(TJException e) {
+    } finally {
+      super.finalize();
+    }
+  };
+
+  private native void init() throws TJException;
+
+  private native void destroy() throws TJException;
+
+  // JPEG size in bytes is returned
+  @Deprecated
+  private native int compress(byte[] srcBuf, int width, int pitch,
+    int height, int pixelFormat, byte[] dstBuf, int jpegSubsamp, int jpegQual,
+    int flags) throws TJException;
+
+  private native int compress(byte[] srcBuf, int x, int y, int width,
+    int pitch, int height, int pixelFormat, byte[] dstBuf, int jpegSubsamp,
+    int jpegQual, int flags) throws TJException;
+
+  @Deprecated
+  private native int compress(int[] srcBuf, int width, int stride,
+    int height, int pixelFormat, byte[] dstBuf, int jpegSubsamp, int jpegQual,
+    int flags) throws TJException;
+
+  private native int compress(int[] srcBuf, int x, int y, int width,
+    int stride, int height, int pixelFormat, byte[] dstBuf, int jpegSubsamp,
+    int jpegQual, int flags) throws TJException;
+
+  private native int compressFromYUV(byte[][] srcPlanes, int[] srcOffsets,
+    int width, int[] srcStrides, int height, int subsamp, byte[] dstBuf,
+    int jpegQual, int flags)
+    throws TJException;
+
+  @Deprecated
+  private native void encodeYUV(byte[] srcBuf, int width, int pitch,
+    int height, int pixelFormat, byte[] dstBuf, int subsamp, int flags)
+    throws TJException;
+
+  private native void encodeYUV(byte[] srcBuf, int x, int y, int width,
+    int pitch, int height, int pixelFormat, byte[][] dstPlanes,
+    int[] dstOffsets, int[] dstStrides, int subsamp, int flags)
+    throws TJException;
+
+  @Deprecated
+  private native void encodeYUV(int[] srcBuf, int width, int stride,
+    int height, int pixelFormat, byte[] dstBuf, int subsamp, int flags)
+    throws TJException;
+
+  private native void encodeYUV(int[] srcBuf, int x, int y, int width,
+    int srcStride, int height, int pixelFormat, byte[][] dstPlanes,
+    int[] dstOffsets, int[] dstStrides, int subsamp, int flags)
+    throws TJException;
+
+  static {
+    TJLoader.load();
+  }
+
+  private void checkSourceImage() {
+    if (srcWidth < 1 || srcHeight < 1)
+      throw new IllegalStateException(NO_ASSOC_ERROR);
+  }
+
+  private void checkSubsampling() {
+    if (subsamp < 0)
+      throw new IllegalStateException("Subsampling level not set");
+  }
+
+  private long handle = 0;
+  private byte[] srcBuf = null;
+  private int[] srcBufInt = null;
+  private int srcWidth = 0;
+  private int srcHeight = 0;
+  private int srcX = -1;
+  private int srcY = -1;
+  private int srcPitch = 0;
+  private int srcStride = 0;
+  private int srcPixelFormat = -1;
+  private YUVImage srcYUVImage = null;
+  private int subsamp = -1;
+  private int jpegQuality = -1;
+  private int compressedSize = 0;
+  private int yuvPad = 4;
+  private ByteOrder byteOrder = null;
+}