mirror of
https://github.com/etlegacy/etlegacy-libs.git
synced 2025-02-24 20:21:11 +00:00
909 lines
39 KiB
Java
909 lines
39 KiB
Java
/*
|
|
* 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 decompressor
|
|
*/
|
|
public class TJDecompressor implements Closeable {
|
|
|
|
private static final String NO_ASSOC_ERROR =
|
|
"No JPEG image is associated with this instance";
|
|
|
|
/**
|
|
* Create a TurboJPEG decompresssor instance.
|
|
*/
|
|
public TJDecompressor() throws TJException {
|
|
init();
|
|
}
|
|
|
|
/**
|
|
* Create a TurboJPEG decompressor instance and associate the JPEG source
|
|
* image stored in <code>jpegImage</code> with the newly created instance.
|
|
*
|
|
* @param jpegImage JPEG image buffer (size of the JPEG image is assumed to
|
|
* be the length of the array.) This buffer is not modified.
|
|
*/
|
|
public TJDecompressor(byte[] jpegImage) throws TJException {
|
|
init();
|
|
setSourceImage(jpegImage, jpegImage.length);
|
|
}
|
|
|
|
/**
|
|
* Create a TurboJPEG decompressor instance and associate the JPEG source
|
|
* image of length <code>imageSize</code> bytes stored in
|
|
* <code>jpegImage</code> with the newly created instance.
|
|
*
|
|
* @param jpegImage JPEG image buffer. This buffer is not modified.
|
|
*
|
|
* @param imageSize size of the JPEG image (in bytes)
|
|
*/
|
|
public TJDecompressor(byte[] jpegImage, int imageSize) throws TJException {
|
|
init();
|
|
setSourceImage(jpegImage, imageSize);
|
|
}
|
|
|
|
/**
|
|
* Create a TurboJPEG decompressor instance and associate the YUV planar
|
|
* source image stored in <code>yuvImage</code> with the newly created
|
|
* instance.
|
|
*
|
|
* @param yuvImage {@link YUVImage} instance containing a YUV planar
|
|
* image to be decoded. This image is not modified.
|
|
*/
|
|
public TJDecompressor(YUVImage yuvImage) throws TJException {
|
|
init();
|
|
setSourceImage(yuvImage);
|
|
}
|
|
|
|
/**
|
|
* Associate the JPEG image of length <code>imageSize</code> bytes stored in
|
|
* <code>jpegImage</code> with this decompressor instance. This image will
|
|
* be used as the source image for subsequent decompress operations.
|
|
*
|
|
* @param jpegImage JPEG image buffer. This buffer is not modified.
|
|
*
|
|
* @param imageSize size of the JPEG image (in bytes)
|
|
*/
|
|
public void setSourceImage(byte[] jpegImage, int imageSize)
|
|
throws TJException {
|
|
if (jpegImage == null || imageSize < 1)
|
|
throw new IllegalArgumentException("Invalid argument in setSourceImage()");
|
|
jpegBuf = jpegImage;
|
|
jpegBufSize = imageSize;
|
|
decompressHeader(jpegBuf, jpegBufSize);
|
|
yuvImage = null;
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use {@link #setSourceImage(byte[], int)} instead.
|
|
*/
|
|
@Deprecated
|
|
public void setJPEGImage(byte[] jpegImage, int imageSize)
|
|
throws TJException {
|
|
setSourceImage(jpegImage, imageSize);
|
|
}
|
|
|
|
/**
|
|
* Associate the specified YUV planar source image with this decompressor
|
|
* instance. Subsequent decompress operations will decode this image into an
|
|
* RGB or grayscale destination image.
|
|
*
|
|
* @param srcImage {@link YUVImage} instance containing a YUV planar image to
|
|
* be decoded. This image is not modified.
|
|
*/
|
|
public void setSourceImage(YUVImage srcImage) {
|
|
if (srcImage == null)
|
|
throw new IllegalArgumentException("Invalid argument in setSourceImage()");
|
|
yuvImage = srcImage;
|
|
jpegBuf = null;
|
|
jpegBufSize = 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the width of the source image (JPEG or YUV) associated with this
|
|
* decompressor instance.
|
|
*
|
|
* @return the width of the source image (JPEG or YUV) associated with this
|
|
* decompressor instance.
|
|
*/
|
|
public int getWidth() {
|
|
if (yuvImage != null)
|
|
return yuvImage.getWidth();
|
|
if (jpegWidth < 1)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
return jpegWidth;
|
|
}
|
|
|
|
/**
|
|
* Returns the height of the source image (JPEG or YUV) associated with this
|
|
* decompressor instance.
|
|
*
|
|
* @return the height of the source image (JPEG or YUV) associated with this
|
|
* decompressor instance.
|
|
*/
|
|
public int getHeight() {
|
|
if (yuvImage != null)
|
|
return yuvImage.getHeight();
|
|
if (jpegHeight < 1)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
return jpegHeight;
|
|
}
|
|
|
|
/**
|
|
* Returns the level of chrominance subsampling used in the source image
|
|
* (JPEG or YUV) associated with this decompressor instance. See
|
|
* {@link TJ#SAMP_444 TJ.SAMP_*}.
|
|
*
|
|
* @return the level of chrominance subsampling used in the source image
|
|
* (JPEG or YUV) associated with this decompressor instance.
|
|
*/
|
|
public int getSubsamp() {
|
|
if (yuvImage != null)
|
|
return yuvImage.getSubsamp();
|
|
if (jpegSubsamp < 0)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (jpegSubsamp >= TJ.NUMSAMP)
|
|
throw new IllegalStateException("JPEG header information is invalid");
|
|
return jpegSubsamp;
|
|
}
|
|
|
|
/**
|
|
* Returns the colorspace used in the source image (JPEG or YUV) associated
|
|
* with this decompressor instance. See {@link TJ#CS_RGB TJ.CS_*}. If the
|
|
* source image is YUV, then this always returns {@link TJ#CS_YCbCr}.
|
|
*
|
|
* @return the colorspace used in the source image (JPEG or YUV) associated
|
|
* with this decompressor instance.
|
|
*/
|
|
public int getColorspace() {
|
|
if (yuvImage != null)
|
|
return TJ.CS_YCbCr;
|
|
if (jpegColorspace < 0)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (jpegColorspace >= TJ.NUMCS)
|
|
throw new IllegalStateException("JPEG header information is invalid");
|
|
return jpegColorspace;
|
|
}
|
|
|
|
/**
|
|
* Returns the JPEG image buffer associated with this decompressor instance.
|
|
*
|
|
* @return the JPEG image buffer associated with this decompressor instance.
|
|
*/
|
|
public byte[] getJPEGBuf() {
|
|
if (jpegBuf == null)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
return jpegBuf;
|
|
}
|
|
|
|
/**
|
|
* Returns the size of the JPEG image (in bytes) associated with this
|
|
* decompressor instance.
|
|
*
|
|
* @return the size of the JPEG image (in bytes) associated with this
|
|
* decompressor instance.
|
|
*/
|
|
public int getJPEGSize() {
|
|
if (jpegBufSize < 1)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
return jpegBufSize;
|
|
}
|
|
|
|
/**
|
|
* Returns the width of the largest scaled-down image that the TurboJPEG
|
|
* decompressor can generate without exceeding the desired image width and
|
|
* height.
|
|
*
|
|
* @param desiredWidth desired width (in pixels) of the decompressed image.
|
|
* Setting this to 0 is the same as setting it to the width of the JPEG image
|
|
* (in other words, the width will not be considered when determining the
|
|
* scaled image size.)
|
|
*
|
|
* @param desiredHeight desired height (in pixels) of the decompressed image.
|
|
* Setting this to 0 is the same as setting it to the height of the JPEG
|
|
* image (in other words, the height will not be considered when determining
|
|
* the scaled image size.)
|
|
*
|
|
* @return the width of the largest scaled-down image that the TurboJPEG
|
|
* decompressor can generate without exceeding the desired image width and
|
|
* height.
|
|
*/
|
|
public int getScaledWidth(int desiredWidth, int desiredHeight) {
|
|
if (jpegWidth < 1 || jpegHeight < 1)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (desiredWidth < 0 || desiredHeight < 0)
|
|
throw new IllegalArgumentException("Invalid argument in getScaledWidth()");
|
|
TJScalingFactor[] sf = TJ.getScalingFactors();
|
|
if (desiredWidth == 0)
|
|
desiredWidth = jpegWidth;
|
|
if (desiredHeight == 0)
|
|
desiredHeight = jpegHeight;
|
|
int scaledWidth = jpegWidth, scaledHeight = jpegHeight;
|
|
for (int i = 0; i < sf.length; i++) {
|
|
scaledWidth = sf[i].getScaled(jpegWidth);
|
|
scaledHeight = sf[i].getScaled(jpegHeight);
|
|
if (scaledWidth <= desiredWidth && scaledHeight <= desiredHeight)
|
|
break;
|
|
}
|
|
if (scaledWidth > desiredWidth || scaledHeight > desiredHeight)
|
|
throw new IllegalArgumentException("Could not scale down to desired image dimensions");
|
|
return scaledWidth;
|
|
}
|
|
|
|
/**
|
|
* Returns the height of the largest scaled-down image that the TurboJPEG
|
|
* decompressor can generate without exceeding the desired image width and
|
|
* height.
|
|
*
|
|
* @param desiredWidth desired width (in pixels) of the decompressed image.
|
|
* Setting this to 0 is the same as setting it to the width of the JPEG image
|
|
* (in other words, the width will not be considered when determining the
|
|
* scaled image size.)
|
|
*
|
|
* @param desiredHeight desired height (in pixels) of the decompressed image.
|
|
* Setting this to 0 is the same as setting it to the height of the JPEG
|
|
* image (in other words, the height will not be considered when determining
|
|
* the scaled image size.)
|
|
*
|
|
* @return the height of the largest scaled-down image that the TurboJPEG
|
|
* decompressor can generate without exceeding the desired image width and
|
|
* height.
|
|
*/
|
|
public int getScaledHeight(int desiredWidth, int desiredHeight) {
|
|
if (jpegWidth < 1 || jpegHeight < 1)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (desiredWidth < 0 || desiredHeight < 0)
|
|
throw new IllegalArgumentException("Invalid argument in getScaledHeight()");
|
|
TJScalingFactor[] sf = TJ.getScalingFactors();
|
|
if (desiredWidth == 0)
|
|
desiredWidth = jpegWidth;
|
|
if (desiredHeight == 0)
|
|
desiredHeight = jpegHeight;
|
|
int scaledWidth = jpegWidth, scaledHeight = jpegHeight;
|
|
for (int i = 0; i < sf.length; i++) {
|
|
scaledWidth = sf[i].getScaled(jpegWidth);
|
|
scaledHeight = sf[i].getScaled(jpegHeight);
|
|
if (scaledWidth <= desiredWidth && scaledHeight <= desiredHeight)
|
|
break;
|
|
}
|
|
if (scaledWidth > desiredWidth || scaledHeight > desiredHeight)
|
|
throw new IllegalArgumentException("Could not scale down to desired image dimensions");
|
|
return scaledHeight;
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image or decode the YUV source image associated
|
|
* with this decompressor instance and output a grayscale, RGB, or CMYK image
|
|
* to the given destination buffer.
|
|
*
|
|
* @param dstBuf buffer that will receive the decompressed/decoded image.
|
|
* If the source image is a JPEG image, then this buffer should normally be
|
|
* <code>pitch * scaledHeight</code> bytes in size, where
|
|
* <code>scaledHeight</code> can be determined by calling <code>
|
|
* scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegHeight)
|
|
* </code> with one of the scaling factors returned from {@link
|
|
* TJ#getScalingFactors} or by calling {@link #getScaledHeight}. If the
|
|
* source image is a YUV image, then this buffer should normally be
|
|
* <code>pitch * height</code> bytes in size, where <code>height</code> is
|
|
* the height of the YUV image. However, the buffer may also be larger than
|
|
* the dimensions of the source image, in which case the <code>x</code>,
|
|
* <code>y</code>, and <code>pitch</code> parameters can be used to specify
|
|
* the region into which the source image should be decompressed/decoded.
|
|
*
|
|
* @param x x offset (in pixels) of the region in the destination image into
|
|
* which the source image should be decompressed/decoded
|
|
*
|
|
* @param y y offset (in pixels) of the region in the destination image into
|
|
* which the source image should be decompressed/decoded
|
|
*
|
|
* @param desiredWidth If the source image is a JPEG image, then this
|
|
* specifies the desired width (in pixels) of the decompressed image (or
|
|
* image region.) If the desired destination image dimensions are different
|
|
* than the source image dimensions, then TurboJPEG will use scaling in the
|
|
* JPEG decompressor to generate the largest possible image that will fit
|
|
* within the desired dimensions. Setting this to 0 is the same as setting
|
|
* it to the width of the JPEG image (in other words, the width will not be
|
|
* considered when determining the scaled image size.) This parameter is
|
|
* ignored if the source image is a YUV image.
|
|
*
|
|
* @param pitch bytes per line of the destination image. Normally, this
|
|
* should be set to <code>scaledWidth * TJ.pixelSize(pixelFormat)</code> if
|
|
* the destination image is unpadded, but you can use this to, for instance,
|
|
* pad each line of the destination image to a 4-byte boundary or to
|
|
* decompress/decode the source image into a region of a larger image. NOTE:
|
|
* if the source image is a JPEG image, then <code>scaledWidth</code> can be
|
|
* determined by calling <code>
|
|
* scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegWidth)
|
|
* </code> or by calling {@link #getScaledWidth}. If the source image is a
|
|
* YUV image, then <code>scaledWidth</code> is the width of the YUV image.
|
|
* Setting this parameter to 0 is the equivalent of setting it to
|
|
* <code>scaledWidth * TJ.pixelSize(pixelFormat)</code>.
|
|
*
|
|
* @param desiredHeight If the source image is a JPEG image, then this
|
|
* specifies the desired height (in pixels) of the decompressed image (or
|
|
* image region.) If the desired destination image dimensions are different
|
|
* than the source image dimensions, then TurboJPEG will use scaling in the
|
|
* JPEG decompressor to generate the largest possible image that will fit
|
|
* within the desired dimensions. Setting this to 0 is the same as setting
|
|
* it to the height of the JPEG image (in other words, the height will not be
|
|
* considered when determining the scaled image size.) This parameter is
|
|
* ignored if the source image is a YUV image.
|
|
*
|
|
* @param pixelFormat pixel format of the decompressed/decoded image (one of
|
|
* {@link TJ#PF_RGB TJ.PF_*})
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*/
|
|
public void decompress(byte[] dstBuf, int x, int y, int desiredWidth,
|
|
int pitch, int desiredHeight, int pixelFormat,
|
|
int flags) throws TJException {
|
|
if (jpegBuf == null && yuvImage == null)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (dstBuf == null || x < 0 || y < 0 || pitch < 0 ||
|
|
(yuvImage != null && (desiredWidth < 0 || desiredHeight < 0)) ||
|
|
pixelFormat < 0 || pixelFormat >= TJ.NUMPF || flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompress()");
|
|
if (yuvImage != null)
|
|
decodeYUV(yuvImage.getPlanes(), yuvImage.getOffsets(),
|
|
yuvImage.getStrides(), yuvImage.getSubsamp(), dstBuf, x, y,
|
|
yuvImage.getWidth(), pitch, yuvImage.getHeight(), pixelFormat,
|
|
flags);
|
|
else {
|
|
if (x > 0 || y > 0)
|
|
decompress(jpegBuf, jpegBufSize, dstBuf, x, y, desiredWidth, pitch,
|
|
desiredHeight, pixelFormat, flags);
|
|
else
|
|
decompress(jpegBuf, jpegBufSize, dstBuf, desiredWidth, pitch,
|
|
desiredHeight, pixelFormat, flags);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use
|
|
* {@link #decompress(byte[], int, int, int, int, int, int, int)} instead.
|
|
*/
|
|
@Deprecated
|
|
public void decompress(byte[] dstBuf, int desiredWidth, int pitch,
|
|
int desiredHeight, int pixelFormat, int flags)
|
|
throws TJException {
|
|
decompress(dstBuf, 0, 0, desiredWidth, pitch, desiredHeight, pixelFormat,
|
|
flags);
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image associated with this decompressor
|
|
* instance and return a buffer containing the decompressed image.
|
|
*
|
|
* @param desiredWidth see
|
|
* {@link #decompress(byte[], int, int, int, int, int, int, int)}
|
|
* for description
|
|
*
|
|
* @param pitch see
|
|
* {@link #decompress(byte[], int, int, int, int, int, int, int)}
|
|
* for description
|
|
*
|
|
* @param desiredHeight see
|
|
* {@link #decompress(byte[], int, int, int, int, int, int, int)}
|
|
* for description
|
|
*
|
|
* @param pixelFormat pixel format of the decompressed image (one of
|
|
* {@link TJ#PF_RGB TJ.PF_*})
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*
|
|
* @return a buffer containing the decompressed image.
|
|
*/
|
|
public byte[] decompress(int desiredWidth, int pitch, int desiredHeight,
|
|
int pixelFormat, int flags) throws TJException {
|
|
if (pitch < 0 ||
|
|
(yuvImage == null && (desiredWidth < 0 || desiredHeight < 0)) ||
|
|
pixelFormat < 0 || pixelFormat >= TJ.NUMPF || flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompress()");
|
|
int pixelSize = TJ.getPixelSize(pixelFormat);
|
|
int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
|
|
int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
|
|
if (pitch == 0)
|
|
pitch = scaledWidth * pixelSize;
|
|
byte[] buf = new byte[pitch * scaledHeight];
|
|
decompress(buf, desiredWidth, pitch, desiredHeight, pixelFormat, flags);
|
|
return buf;
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image associated with this decompressor
|
|
* instance into a YUV planar image and store it in the given
|
|
* <code>YUVImage</code> instance. This method performs JPEG decompression
|
|
* but leaves out the color conversion step, so a planar YUV image is
|
|
* generated instead of an RGB or grayscale image. This method cannot be
|
|
* used to decompress JPEG source images with the CMYK or YCCK colorspace.
|
|
*
|
|
* @param dstImage {@link YUVImage} instance that will receive the YUV planar
|
|
* image. The level of subsampling specified in this <code>YUVImage</code>
|
|
* instance must match that of the JPEG image, and the width and height
|
|
* specified in the <code>YUVImage</code> instance must match one of the
|
|
* scaled image sizes that TurboJPEG is capable of generating from the JPEG
|
|
* source image.
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*/
|
|
public void decompressToYUV(YUVImage dstImage, int flags)
|
|
throws TJException {
|
|
if (jpegBuf == null)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (dstImage == null || flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompressToYUV()");
|
|
int scaledWidth = getScaledWidth(dstImage.getWidth(),
|
|
dstImage.getHeight());
|
|
int scaledHeight = getScaledHeight(dstImage.getWidth(),
|
|
dstImage.getHeight());
|
|
if (scaledWidth != dstImage.getWidth() ||
|
|
scaledHeight != dstImage.getHeight())
|
|
throw new IllegalArgumentException("YUVImage dimensions do not match one of the scaled image sizes that TurboJPEG is capable of generating.");
|
|
if (jpegSubsamp != dstImage.getSubsamp())
|
|
throw new IllegalArgumentException("YUVImage subsampling level does not match that of the JPEG image");
|
|
|
|
decompressToYUV(jpegBuf, jpegBufSize, dstImage.getPlanes(),
|
|
dstImage.getOffsets(), dstImage.getWidth(),
|
|
dstImage.getStrides(), dstImage.getHeight(), flags);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use {@link #decompressToYUV(YUVImage, int)} instead.
|
|
*/
|
|
@Deprecated
|
|
public void decompressToYUV(byte[] dstBuf, int flags) throws TJException {
|
|
YUVImage dstImage = new YUVImage(dstBuf, jpegWidth, 4, jpegHeight,
|
|
jpegSubsamp);
|
|
decompressToYUV(dstImage, flags);
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image associated with this decompressor
|
|
* instance into a set of Y, U (Cb), and V (Cr) image planes and return a
|
|
* <code>YUVImage</code> instance containing the decompressed image planes.
|
|
* This method performs JPEG decompression but leaves out the color
|
|
* conversion step, so a planar YUV image is generated instead of an RGB or
|
|
* grayscale image. This method cannot be used to decompress JPEG source
|
|
* images with the CMYK or YCCK colorspace.
|
|
*
|
|
* @param desiredWidth desired width (in pixels) of the YUV image. If the
|
|
* desired image dimensions are different than the dimensions of the JPEG
|
|
* image being decompressed, then TurboJPEG will use scaling in the JPEG
|
|
* decompressor to generate the largest possible image that will fit within
|
|
* the desired dimensions. Setting this to 0 is the same as setting it to
|
|
* the width of the JPEG image (in other words, the width will not be
|
|
* considered when determining the scaled image size.)
|
|
*
|
|
* @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 scaled
|
|
* component width of the plane. If <tt>strides</tt> is NULL, then the
|
|
* strides for all planes will be set to their respective scaled component
|
|
* widths. You can adjust the strides in order to add an arbitrary amount of
|
|
* line padding to each plane.
|
|
*
|
|
* @param desiredHeight desired height (in pixels) of the YUV image. If the
|
|
* desired image dimensions are different than the dimensions of the JPEG
|
|
* image being decompressed, then TurboJPEG will use scaling in the JPEG
|
|
* decompressor to generate the largest possible image that will fit within
|
|
* the desired dimensions. Setting this to 0 is the same as setting it to
|
|
* the height of the JPEG image (in other words, the height will not be
|
|
* considered when determining the scaled image size.)
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*
|
|
* @return a YUV planar image.
|
|
*/
|
|
public YUVImage decompressToYUV(int desiredWidth, int[] strides,
|
|
int desiredHeight,
|
|
int flags) throws TJException {
|
|
if (flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompressToYUV()");
|
|
if (jpegWidth < 1 || jpegHeight < 1 || jpegSubsamp < 0)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (jpegSubsamp >= TJ.NUMSAMP)
|
|
throw new IllegalStateException("JPEG header information is invalid");
|
|
if (yuvImage != null)
|
|
throw new IllegalStateException("Source image is the wrong type");
|
|
|
|
int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
|
|
int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
|
|
YUVImage yuvImage = new YUVImage(scaledWidth, null, scaledHeight,
|
|
jpegSubsamp);
|
|
decompressToYUV(yuvImage, flags);
|
|
return yuvImage;
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image associated with this decompressor
|
|
* instance into a unified YUV planar image buffer and return a
|
|
* <code>YUVImage</code> instance containing the decompressed image. This
|
|
* method performs JPEG decompression but leaves out the color conversion
|
|
* step, so a planar YUV image is generated instead of an RGB or grayscale
|
|
* image. This method cannot be used to decompress JPEG source images with
|
|
* the CMYK or YCCK colorspace.
|
|
*
|
|
* @param desiredWidth desired width (in pixels) of the YUV image. If the
|
|
* desired image dimensions are different than the dimensions of the JPEG
|
|
* image being decompressed, then TurboJPEG will use scaling in the JPEG
|
|
* decompressor to generate the largest possible image that will fit within
|
|
* the desired dimensions. Setting this to 0 is the same as setting it to
|
|
* the width of the JPEG image (in other words, the width will not be
|
|
* considered when determining the scaled image size.)
|
|
*
|
|
* @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 desiredHeight desired height (in pixels) of the YUV image. If the
|
|
* desired image dimensions are different than the dimensions of the JPEG
|
|
* image being decompressed, then TurboJPEG will use scaling in the JPEG
|
|
* decompressor to generate the largest possible image that will fit within
|
|
* the desired dimensions. Setting this to 0 is the same as setting it to
|
|
* the height of the JPEG image (in other words, the height will not be
|
|
* considered when determining the scaled image size.)
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*
|
|
* @return a YUV planar image.
|
|
*/
|
|
public YUVImage decompressToYUV(int desiredWidth, int pad, int desiredHeight,
|
|
int flags) throws TJException {
|
|
if (flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompressToYUV()");
|
|
if (jpegWidth < 1 || jpegHeight < 1 || jpegSubsamp < 0)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (jpegSubsamp >= TJ.NUMSAMP)
|
|
throw new IllegalStateException("JPEG header information is invalid");
|
|
if (yuvImage != null)
|
|
throw new IllegalStateException("Source image is the wrong type");
|
|
|
|
int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
|
|
int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
|
|
YUVImage yuvImage = new YUVImage(scaledWidth, pad, scaledHeight,
|
|
jpegSubsamp);
|
|
decompressToYUV(yuvImage, flags);
|
|
return yuvImage;
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use {@link #decompressToYUV(int, int, int, int)} instead.
|
|
*/
|
|
@Deprecated
|
|
public byte[] decompressToYUV(int flags) throws TJException {
|
|
YUVImage dstImage = new YUVImage(jpegWidth, 4, jpegHeight, jpegSubsamp);
|
|
decompressToYUV(dstImage, flags);
|
|
return dstImage.getBuf();
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image or decode the YUV source image associated
|
|
* with this decompressor instance and output a grayscale, RGB, or CMYK image
|
|
* to the given destination buffer.
|
|
*
|
|
* @param dstBuf buffer that will receive the decompressed/decoded image.
|
|
* If the source image is a JPEG image, then this buffer should normally be
|
|
* <code>stride * scaledHeight</code> pixels in size, where
|
|
* <code>scaledHeight</code> can be determined by calling <code>
|
|
* scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegHeight)
|
|
* </code> with one of the scaling factors returned from {@link
|
|
* TJ#getScalingFactors} or by calling {@link #getScaledHeight}. If the
|
|
* source image is a YUV image, then this buffer should normally be
|
|
* <code>stride * height</code> pixels in size, where <code>height</code> is
|
|
* the height of the YUV image. However, the buffer may also be larger than
|
|
* the dimensions of the JPEG image, in which case the <code>x</code>,
|
|
* <code>y</code>, and <code>stride</code> parameters can be used to specify
|
|
* the region into which the source image should be decompressed.
|
|
*
|
|
* @param x x offset (in pixels) of the region in the destination image into
|
|
* which the source image should be decompressed/decoded
|
|
*
|
|
* @param y y offset (in pixels) of the region in the destination image into
|
|
* which the source image should be decompressed/decoded
|
|
*
|
|
* @param desiredWidth If the source image is a JPEG image, then this
|
|
* specifies the desired width (in pixels) of the decompressed image (or
|
|
* image region.) If the desired destination image dimensions are different
|
|
* than the source image dimensions, then TurboJPEG will use scaling in the
|
|
* JPEG decompressor to generate the largest possible image that will fit
|
|
* within the desired dimensions. Setting this to 0 is the same as setting
|
|
* it to the width of the JPEG image (in other words, the width will not be
|
|
* considered when determining the scaled image size.) This parameter is
|
|
* ignored if the source image is a YUV image.
|
|
*
|
|
* @param stride pixels per line of the destination image. Normally, this
|
|
* should be set to <code>scaledWidth</code>, but you can use this to, for
|
|
* instance, decompress the JPEG image into a region of a larger image.
|
|
* NOTE: if the source image is a JPEG image, then <code>scaledWidth</code>
|
|
* can be determined by calling <code>
|
|
* scalingFactor.{@link TJScalingFactor#getScaled getScaled}(jpegWidth)
|
|
* </code> or by calling {@link #getScaledWidth}. If the source image is a
|
|
* YUV image, then <code>scaledWidth</code> is the width of the YUV image.
|
|
* Setting this parameter to 0 is the equivalent of setting it to
|
|
* <code>scaledWidth</code>.
|
|
*
|
|
* @param desiredHeight If the source image is a JPEG image, then this
|
|
* specifies the desired height (in pixels) of the decompressed image (or
|
|
* image region.) If the desired destination image dimensions are different
|
|
* than the source image dimensions, then TurboJPEG will use scaling in the
|
|
* JPEG decompressor to generate the largest possible image that will fit
|
|
* within the desired dimensions. Setting this to 0 is the same as setting
|
|
* it to the height of the JPEG image (in other words, the height will not be
|
|
* considered when determining the scaled image size.) This parameter is
|
|
* ignored if the source image is a YUV image.
|
|
*
|
|
* @param pixelFormat pixel format of the decompressed image (one of
|
|
* {@link TJ#PF_RGB TJ.PF_*})
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*/
|
|
public void decompress(int[] dstBuf, int x, int y, int desiredWidth,
|
|
int stride, int desiredHeight, int pixelFormat,
|
|
int flags) throws TJException {
|
|
if (jpegBuf == null && yuvImage == null)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
if (dstBuf == null || x < 0 || y < 0 || stride < 0 ||
|
|
(yuvImage != null && (desiredWidth < 0 || desiredHeight < 0)) ||
|
|
pixelFormat < 0 || pixelFormat >= TJ.NUMPF || flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompress()");
|
|
if (yuvImage != null)
|
|
decodeYUV(yuvImage.getPlanes(), yuvImage.getOffsets(),
|
|
yuvImage.getStrides(), yuvImage.getSubsamp(), dstBuf, x, y,
|
|
yuvImage.getWidth(), stride, yuvImage.getHeight(), pixelFormat,
|
|
flags);
|
|
else
|
|
decompress(jpegBuf, jpegBufSize, dstBuf, x, y, desiredWidth, stride,
|
|
desiredHeight, pixelFormat, flags);
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image or decode the YUV source image associated
|
|
* with this decompressor instance and output a decompressed/decoded image to
|
|
* the given <code>BufferedImage</code> instance.
|
|
*
|
|
* @param dstImage a <code>BufferedImage</code> instance that will receive
|
|
* the decompressed/decoded image. If the source image is a JPEG image, then
|
|
* the width and height of the <code>BufferedImage</code> instance must match
|
|
* one of the scaled image sizes that TurboJPEG is capable of generating from
|
|
* the JPEG image. If the source image is a YUV image, then the width and
|
|
* height of the <code>BufferedImage</code> instance must match the width and
|
|
* height of the YUV image.
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*/
|
|
public void decompress(BufferedImage dstImage, int flags)
|
|
throws TJException {
|
|
if (dstImage == null || flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompress()");
|
|
int desiredWidth = dstImage.getWidth();
|
|
int desiredHeight = dstImage.getHeight();
|
|
int scaledWidth, scaledHeight;
|
|
|
|
if (yuvImage != null) {
|
|
if (desiredWidth != yuvImage.getWidth() ||
|
|
desiredHeight != yuvImage.getHeight())
|
|
throw new IllegalArgumentException("BufferedImage dimensions do not match the dimensions of the source image.");
|
|
scaledWidth = yuvImage.getWidth();
|
|
scaledHeight = yuvImage.getHeight();
|
|
} else {
|
|
scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
|
|
scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
|
|
if (scaledWidth != desiredWidth || scaledHeight != desiredHeight)
|
|
throw new IllegalArgumentException("BufferedImage dimensions do not match one of the scaled image sizes that TurboJPEG is capable of generating.");
|
|
}
|
|
int pixelFormat; boolean intPixels = false;
|
|
if (byteOrder == null)
|
|
byteOrder = ByteOrder.nativeOrder();
|
|
switch(dstImage.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:
|
|
if (byteOrder == ByteOrder.BIG_ENDIAN)
|
|
pixelFormat = TJ.PF_XRGB;
|
|
else
|
|
pixelFormat = TJ.PF_BGRX;
|
|
intPixels = true; break;
|
|
case BufferedImage.TYPE_INT_ARGB:
|
|
case BufferedImage.TYPE_INT_ARGB_PRE:
|
|
if (byteOrder == ByteOrder.BIG_ENDIAN)
|
|
pixelFormat = TJ.PF_ARGB;
|
|
else
|
|
pixelFormat = TJ.PF_BGRA;
|
|
intPixels = true; break;
|
|
default:
|
|
throw new IllegalArgumentException("Unsupported BufferedImage format");
|
|
}
|
|
WritableRaster wr = dstImage.getRaster();
|
|
if (intPixels) {
|
|
SinglePixelPackedSampleModel sm =
|
|
(SinglePixelPackedSampleModel)dstImage.getSampleModel();
|
|
int stride = sm.getScanlineStride();
|
|
DataBufferInt db = (DataBufferInt)wr.getDataBuffer();
|
|
int[] buf = db.getData();
|
|
if (yuvImage != null)
|
|
decodeYUV(yuvImage.getPlanes(), yuvImage.getOffsets(),
|
|
yuvImage.getStrides(), yuvImage.getSubsamp(), buf, 0, 0,
|
|
yuvImage.getWidth(), stride, yuvImage.getHeight(),
|
|
pixelFormat, flags);
|
|
else {
|
|
if (jpegBuf == null)
|
|
throw new IllegalStateException(NO_ASSOC_ERROR);
|
|
decompress(jpegBuf, jpegBufSize, buf, 0, 0, scaledWidth, stride,
|
|
scaledHeight, pixelFormat, flags);
|
|
}
|
|
} else {
|
|
ComponentSampleModel sm =
|
|
(ComponentSampleModel)dstImage.getSampleModel();
|
|
int pixelSize = sm.getPixelStride();
|
|
if (pixelSize != TJ.getPixelSize(pixelFormat))
|
|
throw new IllegalArgumentException("Inconsistency between pixel format and pixel size in BufferedImage");
|
|
int pitch = sm.getScanlineStride();
|
|
DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
|
|
byte[] buf = db.getData();
|
|
decompress(buf, 0, 0, scaledWidth, pitch, scaledHeight, pixelFormat,
|
|
flags);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Decompress the JPEG source image or decode the YUV source image associated
|
|
* with this decompressor instance and return a <code>BufferedImage</code>
|
|
* instance containing the decompressed/decoded image.
|
|
*
|
|
* @param desiredWidth see
|
|
* {@link #decompress(byte[], int, int, int, int, int, int, int)} for
|
|
* description
|
|
*
|
|
* @param desiredHeight see
|
|
* {@link #decompress(byte[], int, int, int, int, int, int, int)} for
|
|
* description
|
|
*
|
|
* @param bufferedImageType the image type of the <code>BufferedImage</code>
|
|
* instance that will be created (for instance,
|
|
* <code>BufferedImage.TYPE_INT_RGB</code>)
|
|
*
|
|
* @param flags the bitwise OR of one or more of
|
|
* {@link TJ#FLAG_BOTTOMUP TJ.FLAG_*}
|
|
*
|
|
* @return a <code>BufferedImage</code> instance containing the
|
|
* decompressed/decoded image.
|
|
*/
|
|
public BufferedImage decompress(int desiredWidth, int desiredHeight,
|
|
int bufferedImageType, int flags)
|
|
throws TJException {
|
|
if ((yuvImage == null && (desiredWidth < 0 || desiredHeight < 0)) ||
|
|
flags < 0)
|
|
throw new IllegalArgumentException("Invalid argument in decompress()");
|
|
int scaledWidth = getScaledWidth(desiredWidth, desiredHeight);
|
|
int scaledHeight = getScaledHeight(desiredWidth, desiredHeight);
|
|
BufferedImage img = new BufferedImage(scaledWidth, scaledHeight,
|
|
bufferedImageType);
|
|
decompress(img, flags);
|
|
return img;
|
|
}
|
|
|
|
/**
|
|
* Free the native structures associated with this decompressor 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;
|
|
|
|
private native void decompressHeader(byte[] srcBuf, int size)
|
|
throws TJException;
|
|
|
|
@Deprecated
|
|
private native void decompress(byte[] srcBuf, int size, byte[] dstBuf,
|
|
int desiredWidth, int pitch, int desiredHeight, int pixelFormat, int flags)
|
|
throws TJException;
|
|
|
|
private native void decompress(byte[] srcBuf, int size, byte[] dstBuf, int x,
|
|
int y, int desiredWidth, int pitch, int desiredHeight, int pixelFormat,
|
|
int flags) throws TJException;
|
|
|
|
@Deprecated
|
|
private native void decompress(byte[] srcBuf, int size, int[] dstBuf,
|
|
int desiredWidth, int stride, int desiredHeight, int pixelFormat,
|
|
int flags) throws TJException;
|
|
|
|
private native void decompress(byte[] srcBuf, int size, int[] dstBuf, int x,
|
|
int y, int desiredWidth, int stride, int desiredHeight, int pixelFormat,
|
|
int flags) throws TJException;
|
|
|
|
@Deprecated
|
|
private native void decompressToYUV(byte[] srcBuf, int size, byte[] dstBuf,
|
|
int flags) throws TJException;
|
|
|
|
private native void decompressToYUV(byte[] srcBuf, int size,
|
|
byte[][] dstPlanes, int[] dstOffsets, int desiredWidth, int[] dstStrides,
|
|
int desiredheight, int flags) throws TJException;
|
|
|
|
private native void decodeYUV(byte[][] srcPlanes, int[] srcOffsets,
|
|
int[] srcStrides, int subsamp, byte[] dstBuf, int x, int y, int width,
|
|
int pitch, int height, int pixelFormat, int flags) throws TJException;
|
|
|
|
private native void decodeYUV(byte[][] srcPlanes, int[] srcOffsets,
|
|
int[] srcStrides, int subsamp, int[] dstBuf, int x, int y, int width,
|
|
int stride, int height, int pixelFormat, int flags) throws TJException;
|
|
|
|
static {
|
|
TJLoader.load();
|
|
}
|
|
|
|
protected long handle = 0;
|
|
protected byte[] jpegBuf = null;
|
|
protected int jpegBufSize = 0;
|
|
protected YUVImage yuvImage = null;
|
|
protected int jpegWidth = 0;
|
|
protected int jpegHeight = 0;
|
|
protected int jpegSubsamp = -1;
|
|
protected int jpegColorspace = -1;
|
|
private ByteOrder byteOrder = null;
|
|
}
|