content: /*
   * 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;
  
  /**
   * TurboJPEG compressor
   */
  public class TJCompressor implements Closeable {
  
  	private static final String NO_ASSOC_ERROR = "No source image is associated with this instance";
  
  	static {
  		TJLoader.load();
  	}
  
  	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;
  
  	/**
  	 * 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;
  
  	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");
  		}
  	}
  }
  