ryan/mozjpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fc01f4673b71c0b833c59c21e8c4478a9c4bcf21
mozjpeg/java/TJBench.java
DRC fc01f4673b TurboJPEG 3 API overhaul 
(ChangeLog update forthcoming)

- Prefix all function names with "tj3" and remove version suffixes from
  function names.  (Future API overhauls will increment the prefix to
  "tj4", etc., thus retaining backward API/ABI compatibility without
  versioning each individual function.)

- Replace stateless boolean flags (including TJ*FLAG_ARITHMETIC and
  TJ*FLAG_LOSSLESS, which were never released) with stateful integer
  parameters, the value of which persists between function calls.
  * Use parameters for the JPEG quality and subsampling as well, in
    order to eliminate the awkwardness of specifying function arguments
    that weren't relevant for lossless compression.
  * tj3DecompressHeader() now stores all relevant information about the
    JPEG image, including the width, height, subsampling type, entropy
    coding type, etc. in parameters rather than returning that
    information in its arguments.
  * TJ*FLAG_LIMITSCANS has been reimplemented as an integer parameter
    (TJ*PARAM_SCANLIMIT) that allows the number of scans to be
    specified.

- Use the const keyword for all pointer arguments to unmodified
  buffers, as well as for both dimensions of 2D pointers.  Addresses
  #395.

- Use size_t rather than unsigned long to represent buffer sizes, since
  unsigned long is a 32-bit type on Windows.  Addresses #24.

- Return 0 from all buffer size functions if an error occurs, rather
  than awkwardly trying to return -1 in an unsigned data type.

- Implement 12-bit and 16-bit data precision using dedicated
  compression, decompression, and image I/O functions/methods.
  * Suffix the names of all data-precision-specific functions with 8,
    12, or 16.
  * Because the YUV functions are intended to be used for video, they
    are currently only implemented with 8-bit data precision, but they
    can be expanded to 12-bit data precision in the future, if
    necessary.
  * Extend TJUnitTest and TJBench to test 12-bit and 16-bit data
    precision, using a new -precision option.
  * Add appropriate regression tests for all of the above to the 'test'
    target.
  * Extend tjbenchtest to test 12-bit and 16-bit data precision, and
    add separate 'tjtest12' and 'tjtest16' targets.
  * BufferedImage I/O in the Java API is currently limited to 8-bit
    data precision, since the BufferedImage class does not
    straightforwardly support higher data precisions.
  * Extend the PPM reader to convert 12-bit and 16-bit PBMPLUS files
    to grayscale or CMYK pixels, as it already does for 8-bit files.

- Properly accommodate lossless JPEG using dedicated parameters
  (TJ*PARAM_LOSSLESS, TJ*PARAM_LOSSLESSPSV, and TJ*PARAM_LOSSLESSPT),
  rather than using a flag and awkwardly repurposing the JPEG quality.
  Update TJBench to properly reflect whether a JPEG image is lossless.

- Re-organize the TJBench usage screen.

- Update the Java docs using Java 11, to improve the formatting and
  eliminate HTML frames.

- Use the accurate integer DCT algorithm by default for both
  compression and decompression, since the "fast" algorithm is a legacy
  feature, it does not pass the ISO compliance tests, and it is not
  actually faster on modern x86 CPUs.
  * Remove the -accuratedct option from TJBench and TJExample.

- Re-implement the 'tjtest' target using a CMake script that enables
  the appropriate tests, depending on the data precision and whether or
  not the Java API is part of the build.

- Consolidate the C and Java versions of tjbenchtest into one script.

- Consolidate the C and Java versions of tjexampletest into one script.

- Combine all initialization functions into a single function
  (tj3Init()) that accepts an integer parameter specifying the
  subsystems to initialize.

- Enable decompression scaling explicitly, using a new function/method
  (tj3SetScalingFactor()/TJDecompressor.setScalingFactor()), rather
  than implicitly using awkward "desired width"/"desired height"
  parameters.

- Introduce a new macro/constant (TJUNSCALED/TJ.UNSCALED) that maps to
  a scaling factor of 1/1.

- Implement partial image decompression, using a new function/method
  (tj3SetCroppingRegion()/TJDecompressor.setCroppingRegion()) and
  TJBench option (-crop).  Extend tjbenchtest to test the new feature.
  Addresses #1.

- Allow the JPEG colorspace to be specified explicitly when
  compressing, using a new parameter (TJ*PARAM_COLORSPACE).  This
  allows JPEG images with the RGB and CMYK colorspaces to be created.

- Remove the error/difference image feature from TJBench.  Identical
  images to the ones that TJBench created can be generated using
  ImageMagick with
  'magick composite <original_image> <output_image> -compose difference <diff_image>'

- Handle JPEG images with unknown subsampling types.  TJ*PARAM_SUBSAMP
  is set to TJ*SAMP_UNKNOWN (== -1) for such images, but they can still
  be decompressed fully into packed-pixel images or losslessly
  transformed (with the exception of lossless cropping.)  They cannot
  be partially decompressed or decompressed into planar YUV images.
  Note also that TJBench, due to its lack of support for imperfect
  transforms, requires that the subsampling type be known when
  rotating, flipping, or transversely transposing an image.  Addresses
  #436

- The Java version of TJBench now has identical functionality to the C
  version.  This was accomplished by (somewhat hackishly) calling the
  TurboJPEG C image I/O functions through JNI and copying the pixels
  between the C heap and the Java heap.

- Add parameters (TJ*PARAM_RESTARTROWS and TJ*PARAM_RESTARTBLOCKS) and
  a TJBench option (-restart) to allow the restart marker interval to
  be specified when compressing.  Eliminate the undocumented TJ_RESTART
  environment variable.

- Add a parameter (TJ*PARAM_OPTIMIZE), a transform option
  (TJ*OPT_OPTIMIZE), and a TJBench option (-optimize) to allow
  optimized baseline Huffman coding to be specified when compressing.
  Eliminate the undocumented TJ_OPTIMIZE environment variable.

- Add parameters (TJ*PARAM_XDENSITY, TJ*PARAM_DENSITY, and
  TJ*DENSITYUNITS) to allow the pixel density to be specified when
  compressing or saving a Windows BMP image and to be queried when
  decompressing or loading a Windows BMP image.  Addresses #77.

- Refactor the fuzz targets to use the new API.
  * Extend decompression coverage to 12-bit and 16-bit data precision.
  * Replace the awkward cjpeg12 and cjpeg16 targets with proper
    TurboJPEG-based compress12, compress12-lossless, and
    compress16-lossless targets

- Fix innocuous UBSan warnings uncovered by the new fuzzers.

- Implement previous versions of the TurboJPEG API by wrapping the new
  functions (tested by running the 2.1.x versions of TJBench, via
  tjbenchtest, and TJUnitTest against the new implementation.)
  * Remove all JNI functions for deprecated Java methods and implement
    the deprecated methods using pure Java wrappers.  It should be
    understood that backward API compatibility in Java applies only to
    the Java classes and that one cannot mix and match a JAR file from
    one version of libjpeg-turbo with a JNI library from another
    version.

- tj3Destroy() now silently accepts a NULL handle.

- tj3Alloc() and tj3Free() now return/accept void pointers, as malloc()
  and free() do.

- The image I/O functions now accept a TurboJPEG instance handle, which
  is used to transmit/receive parameters and to receive error
  information.

Closes #517
2023-01-25 19:09:34 -06:00

1209 lines
48 KiB
Java
Raw Blame History

/*
* Copyright (C)2009-2014, 2016-2019, 2021-2023 D. R. Commander.
* 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.
*/
import java.io.*;
import java.awt.*;
import java.awt.image.*;
import javax.imageio.*;
import java.nio.*;
import java.util.*;
import org.libjpegturbo.turbojpeg.*;
final class TJBench {
private TJBench() {}
private static boolean stopOnWarning, bottomUp, fastUpsample, fastDCT,
optimize, progressive, limitScans, arithmetic, lossless;
private static int precision = 8, quiet = 0, pf = TJ.PF_BGR, yuvAlign = 1,
restartIntervalBlocks, restartIntervalRows = 0;
private static boolean compOnly, decompOnly, doTile, doYUV, write = true,
bmp = false;
static final String[] PIXFORMATSTR = {
"RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "GRAY", "", "", "", "",
"CMYK"
};
static final String[] SUBNAME_LONG = {
"4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0", "4:1:1"
};
static final String[] SUBNAME = {
"444", "422", "420", "GRAY", "440", "411"
};
static final String[] CSNAME = {
"RGB", "YCbCr", "GRAY", "CMYK", "YCCK"
};
private static TJScalingFactor sf = TJ.UNSCALED;
private static java.awt.Rectangle cr = TJ.UNCROPPED;
private static int xformOp = TJTransform.OP_NONE, xformOpt = 0;
private static double benchTime = 5.0, warmup = 1.0;
private static class DummyDCTFilter implements TJCustomFilter {
public void customFilter(ShortBuffer coeffBuffer, Rectangle bufferRegion,
Rectangle planeRegion, int componentID,
int transformID, TJTransform transform) {
for (int i = 0; i < bufferRegion.width * bufferRegion.height; i++)
coeffBuffer.put(i, (short)(-coeffBuffer.get(i)));
}
}
private static DummyDCTFilter customFilter;
@SuppressWarnings("checkstyle:HiddenField")
private static boolean isCropped(java.awt.Rectangle cr) {
return (cr.x != 0 || cr.y != 0 || cr.width != 0 || cr.height != 0);
}
private static int getCroppedWidth(int width) {
if (isCropped(cr))
return (cr.width != 0 ? cr.width : sf.getScaled(width) - cr.x);
else
return sf.getScaled(width);
}
private static int getCroppedHeight(int height) {
if (isCropped(cr))
return (cr.height != 0 ? cr.height : sf.getScaled(height) - cr.y);
else
return sf.getScaled(height);
}
static double getTime() {
return (double)System.nanoTime() / 1.0e9;
}
private static String tjErrorMsg;
private static int tjErrorCode = -1;
static void handleTJException(TJException e) throws TJException {
String errorMsg = e.getMessage();
int errorCode = e.getErrorCode();
if (!stopOnWarning && errorCode == TJ.ERR_WARNING) {
if (tjErrorMsg == null || !tjErrorMsg.equals(errorMsg) ||
tjErrorCode != errorCode) {
tjErrorMsg = errorMsg;
tjErrorCode = errorCode;
System.out.println("WARNING: " + errorMsg);
}
} else
throw e;
}
static String formatName(int subsamp, int cs) {
if (quiet != 0) {
if (lossless)
return String.format("%-2d/LOSSLESS ", precision);
else if (subsamp == TJ.SAMP_UNKNOWN)
return String.format("%-2d/%-5s ", precision, CSNAME[cs]);
else
return String.format("%-2d/%-5s/%-5s", precision, CSNAME[cs],
SUBNAME_LONG[subsamp]);
} else {
if (lossless)
return "Lossless";
else if (subsamp == TJ.SAMP_UNKNOWN)
return CSNAME[cs];
else
return CSNAME[cs] + " " + SUBNAME_LONG[subsamp];
}
}
static String sigFig(double val, int figs) {
String format;
int digitsAfterDecimal = figs - (int)Math.ceil(Math.log10(Math.abs(val)));
if (digitsAfterDecimal < 1)
format = new String("%.0f");
else
format = new String("%." + digitsAfterDecimal + "f");
return String.format(format, val);
}
/* Decompression test */
static void decomp(byte[][] jpegBufs, int[] jpegSizes, Object dstBuf, int w,
int h, int subsamp, int jpegQual, String fileName,
int tilew, int tileh) throws Exception {
String qualStr = new String(""), sizeStr, tempStr;
TJDecompressor tjd;
double elapsed, elapsedDecode;
int ps = TJ.getPixelSize(pf), i, iter = 0;
int scaledw, scaledh, pitch;
YUVImage yuvImage = null;
if (lossless)
sf = TJ.UNSCALED;
scaledw = sf.getScaled(w);
scaledh = sf.getScaled(h);
if (jpegQual > 0)
qualStr = new String((lossless ? "_PSV" : "_Q") + jpegQual);
tjd = new TJDecompressor();
tjd.set(TJ.PARAM_STOPONWARNING, stopOnWarning ? 1 : 0);
tjd.set(TJ.PARAM_BOTTOMUP, bottomUp ? 1 : 0);
tjd.set(TJ.PARAM_FASTUPSAMPLE, fastUpsample ? 1 : 0);
tjd.set(TJ.PARAM_FASTDCT, fastDCT ? 1 : 0);
tjd.set(TJ.PARAM_SCANLIMIT, limitScans ? 500 : 0);
if (isCropped(cr)) {
try {
tjd.setSourceImage(jpegBufs[0], jpegSizes[0]);
} catch (TJException e) { handleTJException(e); }
}
tjd.setScalingFactor(sf);
tjd.setCroppingRegion(cr);
if (isCropped(cr)) {
scaledw = cr.width != 0 ? cr.width : scaledw - cr.x;
scaledh = cr.height != 0 ? cr.height : scaledh - cr.y;
}
pitch = scaledw * ps;
if (dstBuf == null) {
if ((long)pitch * (long)scaledh > (long)Integer.MAX_VALUE)
throw new Exception("Image is too large");
if (precision == 8)
dstBuf = new byte[pitch * scaledh];
else
dstBuf = new short[pitch * scaledh];
}
/* Set the destination buffer to gray so we know whether the decompressor
attempted to write to it */
if (precision == 8)
Arrays.fill((byte[])dstBuf, (byte)127);
else if (precision == 12)
Arrays.fill((short[])dstBuf, (short)2047);
else
Arrays.fill((short[])dstBuf, (short)32767);
if (doYUV) {
int width = doTile ? tilew : scaledw;
int height = doTile ? tileh : scaledh;
yuvImage = new YUVImage(width, yuvAlign, height, subsamp);
Arrays.fill(yuvImage.getBuf(), (byte)127);
}
/* Benchmark */
iter = -1;
elapsed = elapsedDecode = 0.0;
while (true) {
int tile = 0;
double start = getTime();
for (int y = 0; y < h; y += tileh) {
for (int x = 0; x < w; x += tilew, tile++) {
int width = doTile ? Math.min(tilew, w - x) : scaledw;
int height = doTile ? Math.min(tileh, h - y) : scaledh;
try {
tjd.setSourceImage(jpegBufs[tile], jpegSizes[tile]);
} catch (TJException e) { handleTJException(e); }
if (doYUV) {
yuvImage.setBuf(yuvImage.getBuf(), width, yuvAlign, height,
subsamp);
try {
tjd.decompressToYUV(yuvImage);
} catch (TJException e) { handleTJException(e); }
double startDecode = getTime();
tjd.setSourceImage(yuvImage);
try {
tjd.decompress8((byte[])dstBuf, x, y, pitch, pf);
} catch (TJException e) { handleTJException(e); }
if (iter >= 0)
elapsedDecode += getTime() - startDecode;
} else {
try {
if (precision == 8)
tjd.decompress8((byte[])dstBuf, x, y, pitch, pf);
else if (precision == 12)
tjd.decompress12((short[])dstBuf, x, y, pitch, pf);
else
tjd.decompress16((short[])dstBuf, x, y, pitch, pf);
} catch (TJException e) { handleTJException(e); }
}
}
}
elapsed += getTime() - start;
if (iter >= 0) {
iter++;
if (elapsed >= benchTime)
break;
} else if (elapsed >= warmup) {
iter = 0;
elapsed = elapsedDecode = 0.0;
}
}
if (doYUV)
elapsed -= elapsedDecode;
for (i = 0; i < jpegBufs.length; i++)
jpegBufs[i] = null;
jpegBufs = null; jpegSizes = null;
System.gc();
if (quiet != 0) {
System.out.format("%-6s%s",
sigFig((double)(w * h) / 1000000. *
(double)iter / elapsed, 4),
quiet == 2 ? "\n" : " ");
if (doYUV)
System.out.format("%s\n",
sigFig((double)(w * h) / 1000000. *
(double)iter / elapsedDecode, 4));
else if (quiet != 2)
System.out.print("\n");
} else {
System.out.format("%s --> Frame rate: %f fps\n",
(doYUV ? "Decomp to YUV" : "Decompress "),
(double)iter / elapsed);
System.out.format(" Throughput: %f Megapixels/sec\n",
(double)(w * h) / 1000000. * (double)iter / elapsed);
if (doYUV) {
System.out.format("YUV Decode --> Frame rate: %f fps\n",
(double)iter / elapsedDecode);
System.out.format(" Throughput: %f Megapixels/sec\n",
(double)(w * h) / 1000000. *
(double)iter / elapsedDecode);
}
}
if (!write) return;
if (sf.getNum() != 1 || sf.getDenom() != 1)
sizeStr = new String(sf.getNum() + "_" + sf.getDenom());
else if (tilew != w || tileh != h)
sizeStr = new String(tilew + "x" + tileh);
else
sizeStr = new String("full");
if (decompOnly)
tempStr = new String(fileName + "_" + sizeStr + (bmp ? ".bmp" : ".ppm"));
else
tempStr = new String(fileName + "_" +
(lossless ? "LOSSLS" : SUBNAME[subsamp]) + qualStr +
"_" + sizeStr + (bmp ? ".bmp" : ".ppm"));
tjd.saveImage(precision, tempStr, dstBuf, scaledw, 0, scaledh, pf);
}
static void fullTest(TJCompressor tjc, Object srcBuf, int w, int h,
int subsamp, int jpegQual, String fileName)
throws Exception {
Object tmpBuf;
byte[][] jpegBufs;
int[] jpegSizes;
double start, elapsed, elapsedEncode;
int totalJpegSize = 0, tilew, tileh, i, iter;
int ps = TJ.getPixelSize(pf);
int ntilesw = 1, ntilesh = 1, pitch = w * ps;
String pfStr = PIXFORMATSTR[pf];
YUVImage yuvImage = null;
if ((long)pitch * (long)h > (long)Integer.MAX_VALUE)
throw new Exception("Image is too large");
if (precision == 8)
tmpBuf = new byte[pitch * h];
else
tmpBuf = new short[pitch * h];
if (quiet == 0)
System.out.format(">>>>> %s (%s) <--> %d-bit JPEG (%s %s%d) <<<<<\n",
pfStr, bottomUp ? "Bottom-up" : "Top-down", precision,
lossless ? "Lossless" : SUBNAME_LONG[subsamp],
lossless ? "PSV" : "Q", jpegQual);
tjc.set(TJ.PARAM_SUBSAMP, subsamp);
tjc.set(TJ.PARAM_FASTDCT, fastDCT ? 1 : 0);
tjc.set(TJ.PARAM_OPTIMIZE, optimize ? 1 : 0);
tjc.set(TJ.PARAM_PROGRESSIVE, progressive ? 1 : 0);
tjc.set(TJ.PARAM_ARITHMETIC, arithmetic ? 1 : 0);
tjc.set(TJ.PARAM_LOSSLESS, lossless ? 1 : 0);
if (lossless)
tjc.set(TJ.PARAM_LOSSLESSPSV, jpegQual);
else
tjc.set(TJ.PARAM_QUALITY, jpegQual);
tjc.set(TJ.PARAM_RESTARTBLOCKS, restartIntervalBlocks);
tjc.set(TJ.PARAM_RESTARTROWS, restartIntervalRows);
for (tilew = doTile ? 8 : w, tileh = doTile ? 8 : h; ;
tilew *= 2, tileh *= 2) {
if (tilew > w)
tilew = w;
if (tileh > h)
tileh = h;
ntilesw = (w + tilew - 1) / tilew;
ntilesh = (h + tileh - 1) / tileh;
jpegBufs =
new byte[ntilesw * ntilesh][TJ.bufSize(tilew, tileh, subsamp)];
jpegSizes = new int[ntilesw * ntilesh];
/* Compression test */
if (quiet == 1)
System.out.format("%-4s(%s) %-2d/%-6s %-3d ", pfStr,
bottomUp ? "BU" : "TD", precision,
lossless ? "LOSSLS" : SUBNAME_LONG[subsamp],
jpegQual);
if (precision == 8) {
for (i = 0; i < h; i++)
System.arraycopy((byte[])srcBuf, w * ps * i, (byte[])tmpBuf,
pitch * i, w * ps);
} else {
for (i = 0; i < h; i++)
System.arraycopy((short[])srcBuf, w * ps * i, (short[])tmpBuf,
pitch * i, w * ps);
}
if (doYUV) {
yuvImage = new YUVImage(tilew, yuvAlign, tileh, subsamp);
Arrays.fill(yuvImage.getBuf(), (byte)127);
}
/* Benchmark */
iter = -1;
elapsed = elapsedEncode = 0.0;
while (true) {
int tile = 0;
totalJpegSize = 0;
start = getTime();
for (int y = 0; y < h; y += tileh) {
for (int x = 0; x < w; x += tilew, tile++) {
int width = Math.min(tilew, w - x);
int height = Math.min(tileh, h - y);
if (precision == 8)
tjc.setSourceImage((byte[])srcBuf, x, y, width, pitch, height,
pf);
else if (precision == 12)
tjc.setSourceImage12((short[])srcBuf, x, y, width, pitch, height,
pf);
else
tjc.setSourceImage16((short[])srcBuf, x, y, width, pitch, height,
pf);
if (doYUV) {
double startEncode = getTime();
yuvImage.setBuf(yuvImage.getBuf(), width, yuvAlign, height,
subsamp);
tjc.encodeYUV(yuvImage);
if (iter >= 0)
elapsedEncode += getTime() - startEncode;
tjc.setSourceImage(yuvImage);
}
tjc.compress(jpegBufs[tile]);
jpegSizes[tile] = tjc.getCompressedSize();
totalJpegSize += jpegSizes[tile];
}
}
elapsed += getTime() - start;
if (iter >= 0) {
iter++;
if (elapsed >= benchTime)
break;
} else if (elapsed >= warmup) {
iter = 0;
elapsed = elapsedEncode = 0.0;
}
}
if (doYUV)
elapsed -= elapsedEncode;
if (quiet == 1)
System.out.format("%-5d %-5d ", tilew, tileh);
if (quiet != 0) {
if (doYUV)
System.out.format("%-6s%s",
sigFig((double)(w * h) / 1000000. *
(double)iter / elapsedEncode, 4),
quiet == 2 ? "\n" : " ");
System.out.format("%-6s%s",
sigFig((double)(w * h) / 1000000. *
(double)iter / elapsed, 4),
quiet == 2 ? "\n" : " ");
System.out.format("%-6s%s",
sigFig((double)(w * h * ps) / (double)totalJpegSize,
4),
quiet == 2 ? "\n" : " ");
} else {
System.out.format("\n%s size: %d x %d\n", doTile ? "Tile" : "Image",
tilew, tileh);
if (doYUV) {
System.out.format("Encode YUV --> Frame rate: %f fps\n",
(double)iter / elapsedEncode);
System.out.format(" Output image size: %d bytes\n",
yuvImage.getSize());
System.out.format(" Compression ratio: %f:1\n",
(double)(w * h * ps) / (double)yuvImage.getSize());
System.out.format(" Throughput: %f Megapixels/sec\n",
(double)(w * h) / 1000000. *
(double)iter / elapsedEncode);
System.out.format(" Output bit stream: %f Megabits/sec\n",
(double)yuvImage.getSize() * 8. / 1000000. *
(double)iter / elapsedEncode);
}
System.out.format("%s --> Frame rate: %f fps\n",
doYUV ? "Comp from YUV" : "Compress ",
(double)iter / elapsed);
System.out.format(" Output image size: %d bytes\n",
totalJpegSize);
System.out.format(" Compression ratio: %f:1\n",
(double)(w * h * ps) / (double)totalJpegSize);
System.out.format(" Throughput: %f Megapixels/sec\n",
(double)(w * h) / 1000000. * (double)iter / elapsed);
System.out.format(" Output bit stream: %f Megabits/sec\n",
(double)totalJpegSize * 8. / 1000000. *
(double)iter / elapsed);
}
if (tilew == w && tileh == h && write) {
String tempStr = fileName + "_" +
(lossless ? "LOSSLS" : SUBNAME[subsamp]) + "_" +
(lossless ? "PSV" : "Q") + jpegQual + ".jpg";
FileOutputStream fos = new FileOutputStream(tempStr);
fos.write(jpegBufs[0], 0, jpegSizes[0]);
fos.close();
if (quiet == 0)
System.out.println("Reference image written to " + tempStr);
}
/* Decompression test */
if (!compOnly)
decomp(jpegBufs, jpegSizes, tmpBuf, w, h, subsamp, jpegQual, fileName,
tilew, tileh);
else if (quiet == 1)
System.out.println("N/A");
if (tilew == w && tileh == h) break;
}
}
static void decompTest(String fileName) throws Exception {
TJTransformer tjt;
byte[][] jpegBufs = null;
byte[] srcBuf;
int[] jpegSizes = null;
int totalJpegSize;
double start, elapsed;
int ps = TJ.getPixelSize(pf), tile, x, y, iter;
// Original image
int w = 0, h = 0, ntilesw = 1, ntilesh = 1, subsamp = -1, cs = -1;
// Transformed image
int tw, th, ttilew, ttileh, tntilesw, tntilesh, tsubsamp;
FileInputStream fis = new FileInputStream(fileName);
if (fis.getChannel().size() > (long)Integer.MAX_VALUE)
throw new Exception("Image is too large");
int srcSize = (int)fis.getChannel().size();
srcBuf = new byte[srcSize];
fis.read(srcBuf, 0, srcSize);
fis.close();
int index = fileName.lastIndexOf('.');
if (index >= 0)
fileName = new String(fileName.substring(0, index));
tjt = new TJTransformer();
tjt.set(TJ.PARAM_STOPONWARNING, stopOnWarning ? 1 : 0);
tjt.set(TJ.PARAM_BOTTOMUP, bottomUp ? 1 : 0);
tjt.set(TJ.PARAM_FASTUPSAMPLE, fastUpsample ? 1 : 0);
tjt.set(TJ.PARAM_FASTDCT, fastDCT ? 1 : 0);
tjt.set(TJ.PARAM_SCANLIMIT, limitScans ? 500 : 0);
try {
tjt.setSourceImage(srcBuf, srcSize);
} catch (TJException e) { handleTJException(e); }
w = tjt.getWidth();
h = tjt.getHeight();
subsamp = tjt.get(TJ.PARAM_SUBSAMP);
precision = tjt.get(TJ.PARAM_PRECISION);
cs = tjt.get(TJ.PARAM_COLORSPACE);
if (tjt.get(TJ.PARAM_PROGRESSIVE) == 1)
System.out.println("JPEG image uses progressive entropy coding\n");
if (tjt.get(TJ.PARAM_ARITHMETIC) == 1)
System.out.println("JPEG image uses arithmetic entropy coding\n");
tjt.set(TJ.PARAM_PROGRESSIVE, progressive ? 1 : 0);
tjt.set(TJ.PARAM_ARITHMETIC, arithmetic ? 1 : 0);
if (cs == TJ.CS_YCCK || cs == TJ.CS_CMYK) {
pf = TJ.PF_CMYK; ps = TJ.getPixelSize(pf);
}
if (tjt.get(TJ.PARAM_LOSSLESS) != 0)
sf = TJ.UNSCALED;
tjt.setScalingFactor(sf);
tjt.setCroppingRegion(cr);
if (quiet == 1) {
System.out.println("All performance values in Mpixels/sec\n");
System.out.format("Pixel JPEG %s %s Xform Comp Decomp ",
(doTile ? "Tile " : "Image"),
(doTile ? "Tile " : "Image"));
if (doYUV)
System.out.print("Decode");
System.out.print("\n");
System.out.print("Format Format Width Height Perf Ratio Perf ");
if (doYUV)
System.out.print("Perf");
System.out.println("\n");
} else if (quiet == 0)
System.out.format(">>>>> %d-bit JPEG (%s) --> %s (%s) <<<<<\n",
precision, formatName(subsamp, cs), PIXFORMATSTR[pf],
bottomUp ? "Bottom-up" : "Top-down");
for (int tilew = doTile ? 16 : w, tileh = doTile ? 16 : h; ;
tilew *= 2, tileh *= 2) {
if (tilew > w)
tilew = w;
if (tileh > h)
tileh = h;
ntilesw = (w + tilew - 1) / tilew;
ntilesh = (h + tileh - 1) / tileh;
tw = w; th = h; ttilew = tilew; ttileh = tileh;
if (quiet == 0) {
System.out.format("\n%s size: %d x %d", (doTile ? "Tile" : "Image"),
ttilew, ttileh);
if (sf.getNum() != 1 || sf.getDenom() != 1 || isCropped(cr))
System.out.format(" --> %d x %d", getCroppedWidth(tw),
getCroppedHeight(th));
System.out.println("");
} else if (quiet == 1) {
System.out.format("%-4s(%s) %-14s ", PIXFORMATSTR[pf],
bottomUp ? "BU" : "TD", formatName(subsamp, cs));
System.out.format("%-5d %-5d ", getCroppedWidth(tilew),
getCroppedHeight(tileh));
}
tsubsamp = subsamp;
if (doTile || xformOp != TJTransform.OP_NONE || xformOpt != 0 ||
customFilter != null) {
if (xformOp == TJTransform.OP_TRANSPOSE ||
xformOp == TJTransform.OP_TRANSVERSE ||
xformOp == TJTransform.OP_ROT90 ||
xformOp == TJTransform.OP_ROT270) {
tw = h; th = w; ttilew = tileh; ttileh = tilew;
}
if (xformOp != TJTransform.OP_NONE &&
xformOp != TJTransform.OP_TRANSPOSE && subsamp == TJ.SAMP_UNKNOWN)
throw new Exception("Could not determine subsampling level of JPEG image");
if ((xformOpt & TJTransform.OPT_GRAY) != 0)
tsubsamp = TJ.SAMP_GRAY;
if (xformOp == TJTransform.OP_HFLIP ||
xformOp == TJTransform.OP_ROT180)
tw = tw - (tw % TJ.getMCUWidth(tsubsamp));
if (xformOp == TJTransform.OP_VFLIP ||
xformOp == TJTransform.OP_ROT180)
th = th - (th % TJ.getMCUHeight(tsubsamp));
if (xformOp == TJTransform.OP_TRANSVERSE ||
xformOp == TJTransform.OP_ROT90)
tw = tw - (tw % TJ.getMCUHeight(tsubsamp));
if (xformOp == TJTransform.OP_TRANSVERSE ||
xformOp == TJTransform.OP_ROT270)
th = th - (th % TJ.getMCUWidth(tsubsamp));
tntilesw = (tw + ttilew - 1) / ttilew;
tntilesh = (th + ttileh - 1) / ttileh;
if (xformOp == TJTransform.OP_TRANSPOSE ||
xformOp == TJTransform.OP_TRANSVERSE ||
xformOp == TJTransform.OP_ROT90 ||
xformOp == TJTransform.OP_ROT270) {
if (tsubsamp == TJ.SAMP_422)
tsubsamp = TJ.SAMP_440;
else if (tsubsamp == TJ.SAMP_440)
tsubsamp = TJ.SAMP_422;
}
TJTransform[] t = new TJTransform[tntilesw * tntilesh];
jpegBufs =
new byte[tntilesw * tntilesh][TJ.bufSize(ttilew, ttileh, subsamp)];
for (y = 0, tile = 0; y < th; y += ttileh) {
for (x = 0; x < tw; x += ttilew, tile++) {
t[tile] = new TJTransform();
t[tile].width = Math.min(ttilew, tw - x);
t[tile].height = Math.min(ttileh, th - y);
t[tile].x = x;
t[tile].y = y;
t[tile].op = xformOp;
t[tile].options = xformOpt | TJTransform.OPT_TRIM;
t[tile].cf = customFilter;
if ((t[tile].options & TJTransform.OPT_NOOUTPUT) != 0 &&
jpegBufs[tile] != null)
jpegBufs[tile] = null;
}
}
iter = -1;
elapsed = 0.;
while (true) {
start = getTime();
try {
tjt.transform(jpegBufs, t);
} catch (TJException e) { handleTJException(e); }
jpegSizes = tjt.getTransformedSizes();
elapsed += getTime() - start;
if (iter >= 0) {
iter++;
if (elapsed >= benchTime)
break;
} else if (elapsed >= warmup) {
iter = 0;
elapsed = 0.0;
}
}
t = null;
for (tile = 0, totalJpegSize = 0; tile < tntilesw * tntilesh; tile++)
totalJpegSize += jpegSizes[tile];
if (quiet != 0) {
System.out.format("%-6s%s%-6s%s",
sigFig((double)(w * h) / 1000000. / elapsed, 4),
quiet == 2 ? "\n" : " ",
sigFig((double)(w * h * ps) /
(double)totalJpegSize, 4),
quiet == 2 ? "\n" : " ");
} else {
System.out.format("Transform --> Frame rate: %f fps\n",
1.0 / elapsed);
System.out.format(" Output image size: %d bytes\n",
totalJpegSize);
System.out.format(" Compression ratio: %f:1\n",
(double)(w * h * ps) / (double)totalJpegSize);
System.out.format(" Throughput: %f Megapixels/sec\n",
(double)(w * h) / 1000000. / elapsed);
System.out.format(" Output bit stream: %f Megabits/sec\n",
(double)totalJpegSize * 8. / 1000000. / elapsed);
}
} else {
if (quiet == 1)
System.out.print("N/A N/A ");
jpegBufs = new byte[1][TJ.bufSize(ttilew, ttileh, subsamp)];
jpegSizes = new int[1];
jpegBufs[0] = srcBuf;
jpegSizes[0] = srcSize;
}
if (w == tilew)
ttilew = tw;
if (h == tileh)
ttileh = th;
if ((xformOpt & TJTransform.OPT_NOOUTPUT) == 0)
decomp(jpegBufs, jpegSizes, null, tw, th, tsubsamp, 0, fileName,
ttilew, ttileh);
else if (quiet == 1)
System.out.println("N/A");
jpegBufs = null;
jpegSizes = null;
if (tilew == w && tileh == h) break;
}
}
static void usage() throws Exception {
int i;
TJScalingFactor[] scalingFactors = TJ.getScalingFactors();
int nsf = scalingFactors.length;
String className = new TJBench().getClass().getName();
System.out.println("\nUSAGE: java " + className);
System.out.println(" <Inputimage (BMP|PPM)> <Quality or PSV> [options]\n");
System.out.println(" java " + className);
System.out.println(" <Inputimage (JPG)> [options]");
System.out.println("\nGENERAL OPTIONS");
System.out.println("---------------");
System.out.println("-benchtime T = Run each benchmark for at least T seconds [default = 5.0]");
System.out.println("-bmp = Use Windows Bitmap format for output images [default = PPM]");
System.out.println(" ** 8-bit data precision only **");
System.out.println("-bottomup = Use bottom-up row order for packed-pixel source/destination buffers");
System.out.println("-componly = Stop after running compression tests. Do not test decompression.");
System.out.println("-lossless = Generate lossless JPEG images when compressing (implies");
System.out.println(" -subsamp 444). PSV is the predictor selection value (1-7).");
System.out.println("-nowrite = Do not write reference or output images (improves consistency of");
System.out.println(" benchmark results)");
System.out.println("-rgb, -bgr, -rgbx, -bgrx, -xbgr, -xrgb =");
System.out.println(" Use the specified pixel format for packed-pixel source/destination buffers");
System.out.println(" [default = BGR]");
System.out.println("-cmyk = Indirectly test YCCK JPEG compression/decompression");
System.out.println(" (use the CMYK pixel format for packed-pixel source/destination buffers)");
System.out.println("-precision N = Use N-bit data precision when compressing [N is 8, 12, or 16;");
System.out.println(" default = 8; if N is 16, then -lossless must also be specified]");
System.out.println("-quiet = Output results in tabular rather than verbose format");
System.out.println("-restart N = When compressing, add a restart marker every N MCU rows (lossy) or");
System.out.println(" N sample rows (lossless) [default = 0 (no restart markers)]. Append 'B'");
System.out.println(" to specify the restart marker interval in MCU blocks (lossy) or samples");
System.out.println(" (lossless).");
System.out.println("-stoponwarning = Immediately discontinue the current");
System.out.println(" compression/decompression/transform operation if a warning (non-fatal");
System.out.println(" error) occurs");
System.out.println("-tile = Compress/transform the input image into separate JPEG tiles of varying");
System.out.println(" sizes (useful for measuring JPEG overhead)");
System.out.println("-warmup T = Run each benchmark for T seconds [default = 1.0] prior to starting");
System.out.println(" the timer, in order to prime the caches and thus improve the consistency");
System.out.println(" of the benchmark results");
System.out.println("\nLOSSY JPEG OPTIONS");
System.out.println("------------------");
System.out.println("-arithmetic = Use arithmetic entropy coding in JPEG images generated by");
System.out.println(" compression and transform operations (can be combined with -progressive)");
System.out.println(" ** 8-bit data precision only **");
System.out.println("-crop WxH+X+Y = Decompress only the specified region of the JPEG image, where W");
System.out.println(" and H are the width and height of the region (0 = maximum possible width");
System.out.println(" or height) and X and Y are the left and upper boundary of the region, all");
System.out.println(" specified relative to the scaled image dimensions. X must be divible by");
System.out.println(" the scaled MCU width.");
System.out.println("-fastdct = Use the fastest DCT/IDCT algorithm available");
System.out.println("-fastupsample = Use the fastest chrominance upsampling algorithm available");
System.out.println("-optimize = Use optimized baseline entropy coding in JPEG images generated by");
System.out.println(" compession and transform operations");
System.out.println("-progressive = Use progressive entropy coding in JPEG images generated by");
System.out.println(" compression and transform operations (implies -optimize; can be combined");
System.out.println(" with -arithmetic)");
System.out.println("-limitscans = Refuse to decompress or transform progressive JPEG images that");
System.out.println(" have an unreasonably large number of scans");
System.out.println("-scale M/N = When decompressing, scale the width/height of the JPEG image by a");
System.out.print(" factor of M/N (M/N = ");
for (i = 0; i < nsf; i++) {
System.out.format("%d/%d", scalingFactors[i].getNum(),
scalingFactors[i].getDenom());
if (nsf == 2 && i != nsf - 1)
System.out.print(" or ");
else if (nsf > 2) {
if (i != nsf - 1)
System.out.print(", ");
if (i == nsf - 2)
System.out.print("or ");
}
if (i % 8 == 0 && i != 0)
System.out.print("\n ");
}
System.out.println(")");
System.out.println("-subsamp S = When compressing, use the specified level of chrominance");
System.out.println(" subsampling (S = 444, 422, 440, 420, 411, or GRAY) [default = test");
System.out.println(" Grayscale, 4:2:0, 4:2:2, and 4:4:4 in sequence]");
System.out.println("-hflip, -vflip, -transpose, -transverse, -rot90, -rot180, -rot270 =");
System.out.println(" Perform the specified lossless transform operation on the input image");
System.out.println(" prior to decompression (these operations are mutually exclusive)");
System.out.println("-grayscale = Transform the input image into a grayscale JPEG image prior to");
System.out.println(" decompression (can be combined with the other transform operations above)");
System.out.println("-copynone = Do not copy any extra markers (including EXIF and ICC profile data)");
System.out.println(" when transforming the input image");
System.out.println("-yuv = Compress from/decompress to intermediate planar YUV images");
System.out.println(" ** 8-bit data precision only **");
System.out.println("-yuvpad N = The number of bytes by which each row in each plane of an");
System.out.println(" intermediate YUV image is evenly divisible (N must be a power of 2)");
System.out.println(" [default = 1]");
System.out.println("\nNOTE: If the quality/PSV is specified as a range (e.g. 90-100 or 1-4), a");
System.out.println("separate test will be performed for all values in the range.\n");
System.exit(1);
}
public static void main(String[] argv) {
Object srcBuf = null;
int w = 0, h = 0, minQual = -1, maxQual = -1;
int minArg = 1, retval = 0;
int subsamp = -1;
TJCompressor tjc = null;
try {
if (argv.length < minArg)
usage();
String tempStr = argv[0].toLowerCase();
if (tempStr.endsWith(".jpg") || tempStr.endsWith(".jpeg"))
decompOnly = true;
if (tempStr.endsWith(".bmp"))
bmp = true;
System.out.println("");
if (!decompOnly) {
minArg = 2;
if (argv.length < minArg)
usage();
String[] quals = argv[1].split("-", 2);
try {
minQual = Integer.parseInt(quals[0]);
} catch (NumberFormatException e) {}
if (quals.length > 1) {
try {
maxQual = Integer.parseInt(quals[1]);
} catch (NumberFormatException e) {}
}
if (maxQual < minQual)
maxQual = minQual;
}
if (argv.length > minArg) {
for (int i = minArg; i < argv.length; i++) {
if (argv[i].equalsIgnoreCase("-tile")) {
doTile = true; xformOpt |= TJTransform.OPT_CROP;
} else if (argv[i].equalsIgnoreCase("-precision") &&
i < argv.length - 1) {
int temp = 0;
try {
temp = Integer.parseInt(argv[++i]);
} catch (NumberFormatException e) {}
if (temp == 8 || temp == 12 || temp == 16)
precision = temp;
else
usage();
} else if (argv[i].equalsIgnoreCase("-fastupsample")) {
System.out.println("Using fastest upsampling algorithm\n");
fastUpsample = true;
} else if (argv[i].equalsIgnoreCase("-fastdct")) {
System.out.println("Using fastest DCT/IDCT algorithm\n");
fastDCT = true;
} else if (argv[i].equalsIgnoreCase("-optimize")) {
System.out.println("Using optimized baseline entropy coding\n");
optimize = true;
xformOpt |= TJTransform.OPT_OPTIMIZE;
} else if (argv[i].equalsIgnoreCase("-progressive")) {
System.out.println("Using progressive entropy coding\n");
progressive = true;
xformOpt |= TJTransform.OPT_PROGRESSIVE;
} else if (argv[i].equalsIgnoreCase("-arithmetic")) {
System.out.println("Using arithmetic entropy coding\n");
arithmetic = true;
xformOpt |= TJTransform.OPT_ARITHMETIC;
} else if (argv[i].equalsIgnoreCase("-lossless")) {
lossless = true;
subsamp = TJ.SAMP_444;
} else if (argv[i].equalsIgnoreCase("-rgb"))
pf = TJ.PF_RGB;
else if (argv[i].equalsIgnoreCase("-rgbx"))
pf = TJ.PF_RGBX;
else if (argv[i].equalsIgnoreCase("-bgr"))
pf = TJ.PF_BGR;
else if (argv[i].equalsIgnoreCase("-bgrx"))
pf = TJ.PF_BGRX;
else if (argv[i].equalsIgnoreCase("-xbgr"))
pf = TJ.PF_XBGR;
else if (argv[i].equalsIgnoreCase("-xrgb"))
pf = TJ.PF_XRGB;
else if (argv[i].equalsIgnoreCase("-cmyk"))
pf = TJ.PF_CMYK;
else if (argv[i].equalsIgnoreCase("-bottomup"))
bottomUp = true;
else if (argv[i].equalsIgnoreCase("-quiet"))
quiet = 1;
else if (argv[i].equalsIgnoreCase("-qq"))
quiet = 2;
else if (argv[i].equalsIgnoreCase("-scale") && i < argv.length - 1) {
int temp1 = 0, temp2 = 0;
boolean match = false, scanned = true;
Scanner scanner = new Scanner(argv[++i]).useDelimiter("/");
try {
temp1 = scanner.nextInt();
temp2 = scanner.nextInt();
} catch (Exception e) {}
if (temp2 <= 0) temp2 = 1;
if (temp1 > 0) {
TJScalingFactor[] scalingFactors = TJ.getScalingFactors();
for (int j = 0; j < scalingFactors.length; j++) {
if ((double)temp1 / (double)temp2 ==
(double)scalingFactors[j].getNum() /
(double)scalingFactors[j].getDenom()) {
sf = scalingFactors[j];
match = true; break;
}
}
if (!match) usage();
} else
usage();
} else if (argv[i].equalsIgnoreCase("-crop") &&
i < argv.length - 1) {
int temp1 = -1, temp2 = -1, temp3 = -1, temp4 = -1;
Scanner scanner = new Scanner(argv[++i]).useDelimiter("x|\\+");
try {
temp1 = scanner.nextInt();
temp2 = scanner.nextInt();
temp3 = scanner.nextInt();
temp4 = scanner.nextInt();
} catch (Exception e) {}
if (temp1 < 0 || temp2 < 0 || temp3 < 0 || temp4 < 0)
usage();
cr.width = temp1; cr.height = temp2; cr.x = temp3; cr.y = temp4;
} else if (argv[i].equalsIgnoreCase("-hflip"))
xformOp = TJTransform.OP_HFLIP;
else if (argv[i].equalsIgnoreCase("-vflip"))
xformOp = TJTransform.OP_VFLIP;
else if (argv[i].equalsIgnoreCase("-transpose"))
xformOp = TJTransform.OP_TRANSPOSE;
else if (argv[i].equalsIgnoreCase("-transverse"))
xformOp = TJTransform.OP_TRANSVERSE;
else if (argv[i].equalsIgnoreCase("-rot90"))
xformOp = TJTransform.OP_ROT90;
else if (argv[i].equalsIgnoreCase("-rot180"))
xformOp = TJTransform.OP_ROT180;
else if (argv[i].equalsIgnoreCase("-rot270"))
xformOp = TJTransform.OP_ROT270;
else if (argv[i].equalsIgnoreCase("-grayscale"))
xformOpt |= TJTransform.OPT_GRAY;
else if (argv[i].equalsIgnoreCase("-custom"))
customFilter = new DummyDCTFilter();
else if (argv[i].equalsIgnoreCase("-nooutput"))
xformOpt |= TJTransform.OPT_NOOUTPUT;
else if (argv[i].equalsIgnoreCase("-copynone"))
xformOpt |= TJTransform.OPT_COPYNONE;
else if (argv[i].equalsIgnoreCase("-benchtime") &&
i < argv.length - 1) {
double temp = -1;
try {
temp = Double.parseDouble(argv[++i]);
} catch (NumberFormatException e) {}
if (temp > 0.0)
benchTime = temp;
else
usage();
} else if (argv[i].equalsIgnoreCase("-warmup") &&
i < argv.length - 1) {
double temp = -1;
try {
temp = Double.parseDouble(argv[++i]);
} catch (NumberFormatException e) {}
if (temp >= 0.0) {
warmup = temp;
System.out.format("Warmup time = %.1f seconds\n\n", warmup);
} else
usage();
} else if (argv[i].equalsIgnoreCase("-bmp"))
bmp = true;
else if (argv[i].equalsIgnoreCase("-yuv")) {
System.out.println("Testing planar YUV encoding/decoding\n");
doYUV = true;
} else if (argv[i].equalsIgnoreCase("-yuvpad") &&
i < argv.length - 1) {
int temp = 0;
try {
temp = Integer.parseInt(argv[++i]);
} catch (NumberFormatException e) {}
if (temp >= 1 && (temp & (temp - 1)) == 0)
yuvAlign = temp;
else
usage();
} else if (argv[i].equalsIgnoreCase("-subsamp") &&
i < argv.length - 1) {
i++;
if (argv[i].toUpperCase().startsWith("G"))
subsamp = TJ.SAMP_GRAY;
else if (argv[i].equals("444"))
subsamp = TJ.SAMP_444;
else if (argv[i].equals("422"))
subsamp = TJ.SAMP_422;
else if (argv[i].equals("440"))
subsamp = TJ.SAMP_440;
else if (argv[i].equals("420"))
subsamp = TJ.SAMP_420;
else if (argv[i].equals("411"))
subsamp = TJ.SAMP_411;
else
usage();
} else if (argv[i].equalsIgnoreCase("-componly"))
compOnly = true;
else if (argv[i].equalsIgnoreCase("-nowrite"))
write = false;
else if (argv[i].equalsIgnoreCase("-limitscans"))
limitScans = true;
else if (argv[i].equalsIgnoreCase("-restart") &&
i < argv.length - 1) {
int temp = -1;
String arg = argv[++i];
Scanner scanner = new Scanner(arg).useDelimiter("b|B");
try {
temp = scanner.nextInt();
} catch (Exception e) {}
if (temp < 0 || temp > 65535 || scanner.hasNext())
usage();
if (arg.endsWith("B") || arg.endsWith("b"))
restartIntervalBlocks = temp;
else
restartIntervalRows = temp;
} else if (argv[i].equalsIgnoreCase("-stoponwarning"))
stopOnWarning = true;
else usage();
}
}
if (precision == 16 && !lossless)
throw new Exception("-lossless must be specified along with -precision 16");
if (precision != 8 && arithmetic)
throw new Exception("-arithmetic requires 8-bit data precision");
if (precision != 8 && doYUV)
throw new Exception("-yuv requires 8-bit data precision");
if (lossless && doYUV)
throw new Exception("ERROR: -lossless and -yuv are incompatible");
if ((sf.getNum() != 1 || sf.getDenom() != 1) && doTile) {
System.out.println("Disabling tiled compression/decompression tests, because those tests do not");
System.out.println("work when scaled decompression is enabled.\n");
doTile = false;
xformOpt &= (~TJTransform.OPT_CROP);
}
if (isCropped(cr)) {
if (!decompOnly)
throw new Exception("ERROR: Partial image decompression can only be enabled for JPEG input images");
if (doTile) {
System.out.println("Disabling tiled compression/decompression tests, because those tests do not");
System.out.println("work when partial image decompression is enabled.\n");
doTile = false;
xformOpt &= (~TJTransform.OPT_CROP);
}
if (doYUV)
throw new Exception("ERROR: -crop and -yuv are incompatible");
}
if (!decompOnly) {
int[] width = new int[1], height = new int[1],
pixelFormat = new int[1];
tjc = new TJCompressor();
tjc.set(TJ.PARAM_STOPONWARNING, stopOnWarning ? 1 : 0);
tjc.set(TJ.PARAM_BOTTOMUP, bottomUp ? 1 : 0);
pixelFormat[0] = pf;
srcBuf = tjc.loadImage(precision, argv[0], width, 1, height,
pixelFormat);
w = width[0]; h = height[0]; pf = pixelFormat[0];
int index = -1;
if ((index = argv[0].lastIndexOf('.')) >= 0)
argv[0] = argv[0].substring(0, index);
}
if (quiet == 1 && !decompOnly) {
System.out.println("All performance values in Mpixels/sec\n");
System.out.format("Pixel JPEG JPEG %s %s ",
(doTile ? "Tile " : "Image"),
(doTile ? "Tile " : "Image"));
if (doYUV)
System.out.print("Encode ");
System.out.print("Comp Comp Decomp ");
if (doYUV)
System.out.print("Decode");
System.out.print("\n");
System.out.format("Format Format %s Width Height ",
lossless ? "PSV " : "Qual");
if (doYUV)
System.out.print("Perf ");
System.out.print("Perf Ratio Perf ");
if (doYUV)
System.out.print("Perf");
System.out.println("\n");
}
if (decompOnly) {
decompTest(argv[0]);
System.out.println("");
System.exit(retval);
}
System.gc();
if (lossless) {
if (minQual < 1 || minQual > 7 || maxQual < 1 || maxQual > 7)
throw new Exception("PSV must be between 1 and 7.");
} else {
if (minQual < 1 || minQual > 100 || maxQual < 1 || maxQual > 100)
throw new Exception("Quality must be between 1 and 100.");
}
if (subsamp >= 0 && subsamp < TJ.NUMSAMP) {
for (int i = maxQual; i >= minQual; i--)
fullTest(tjc, srcBuf, w, h, subsamp, i, argv[0]);
System.out.println("");
} else {
if (pf != TJ.PF_CMYK) {
for (int i = maxQual; i >= minQual; i--)
fullTest(tjc, srcBuf, w, h, TJ.SAMP_GRAY, i, argv[0]);
System.out.println("");
System.gc();
}
for (int i = maxQual; i >= minQual; i--)
fullTest(tjc, srcBuf, w, h, TJ.SAMP_420, i, argv[0]);
System.out.println("");
System.gc();
for (int i = maxQual; i >= minQual; i--)
fullTest(tjc, srcBuf, w, h, TJ.SAMP_422, i, argv[0]);
System.out.println("");
System.gc();
for (int i = maxQual; i >= minQual; i--)
fullTest(tjc, srcBuf, w, h, TJ.SAMP_444, i, argv[0]);
System.out.println("");
}
} catch (Exception e) {
if (e instanceof TJException) {
TJException tje = (TJException)e;
System.out.println((tje.getErrorCode() == TJ.ERR_WARNING ?
"WARNING: " : "ERROR: ") + tje.getMessage());
} else
System.out.println("ERROR: " + e.getMessage());
e.printStackTrace();
retval = -1;
}
System.exit(retval);
}
}
Reference in New Issue View Git Blame Copy Permalink