TJCompressor.java

Show log
Commit

Hash : 94c64ead
Author :
Date : 2024-06-17T20:27:57

Various doc tweaks

- "bits per component" = "bits per sample"

  Describing the data precision of a JPEG image using "bits per
  component" is technically correct, but "bits per sample" is the
  terminology that the JPEG-1 spec uses.  Also, "bits per component" is
  more commonly used to describe the precision of packed-pixel formats
  (as opposed to "bits per pixel") rather than planar formats, in which
  all components are grouped together.

- Unmention legacy display technologies.  Colormapped and monochrome
  displays aren't a thing anymore, and even when they were still a
  thing, it was possible to display full-color images to them.  In 1991,
  when JPEG decompression time was measured in minutes per megapixel, it
  made sense to keep a decompressed copy of JPEG images on disk, in a
  format that could be displayed without further color conversion (since
  color conversion was slow and memory-intensive.)  In 2024, JPEG
  decompression time is measured in milliseconds per megapixel, and
  color conversion is even faster.  Thus, JPEG images can be
  decompressed, displayed, and color-converted (if necessary) "on the
  fly" at speeds too fast for human vision to perceive.  (In fact, your
  TV performs much more complicated decompression algorithms at least 60
  times per second.)

- Document that color quantization (and associated features), GIF
  input/output, Targa input/output, and OS/2 BMP input/output are legacy
  features.  Legacy status doesn't necessarily mean that the features
  are deprecated.  Rather, it is meant to discourage users from using
  features that may be of little or no benefit on modern machines (such
  as low-quality modes that had significant performance advantages in
  the early 1990s but no longer do) and that are maintained on a
  break/fix basis only.

- General wordsmithing, grammar/punctuation policing, and formatting
  tweaks

- Clarify which data precisions each cjpeg input format and each djpeg
  output format supports.

- cjpeg.1: Remove unnecessary and impolitic statement about the -targa
  switch.

- Adjust or remove performance claims to reflect the fact that:
  * On modern machines, the djpeg "-fast" switch has a negligible effect
    on performance.
  * There is a measurable difference between the performance of Floyd-
    Steinberg dithering and no dithering, but it is not likely
    perceptible to most users.
  * There is a measurable difference between the performance of 1-pass
    and 2-pass color quantization, but it is not likely perceptible to
    most users.
  * There is a measurable difference between the performance of
    full-color and grayscale output when decompressing a full-color JPEG
    image, but it is not likely perceptible to most users.
  * IDCT scaling does not necessarily improve performance.  (It
    generally does if the scaling factor is <= 1/2 and generally doesn't
    if the scaling factor is > 1/2, at least on my machine.  The
    performance claim made in jpeg-6b was probably invalidated when we
    merged the additional scaling factors from jpeg-7.)

- Clarify which djpeg switches/output formats cannot be used when
  decompressing lossless JPEG images.

- Remove djpeg hints, since those involve quality vs. speed tradeoffs
  that are no longer relevant for modern machines.

- Remove documentation regarding using color quantization with 16-bit
  data precision.  (Color quantization requires lossy mode.)

- Java: Fix typos in TJDecompressor.decompress12() and
  TJDecompressor.decompress16() documentation.

- jpegtran.1: Fix truncated paragraph

  In a man page, a single quote at the start of a line is interpreted as
  a macro.

  Closes #775

- libjpeg.txt:
  * Mention J16SAMPLE data type (oversight.)
  * Remove statement about extending jdcolor.c.  (libjpeg-turbo is not
    quite as DIY as libjpeg once was.)
  * Remove paragraph about tweaking the various typedefs in jmorecfg.h.
    It is no longer relevant for modern machines.
  * Remove caveat regarding systems with ints less than 16 bits wide.
    (ANSI/ISO C requires an int to be at least 16 bits wide, and
    libjpeg-turbo has never supported non-ANSI compilers.)

- usage.txt:
  * Add copyright header.
  * Document cjpeg -icc, -memdst, -report, -strict, and -version
    switches.
  * Document djpeg -icc, -maxscans, -memsrc, -report, -skip, -crop,
    -strict, and -version switches.
  * Document jpegtran -icc, -maxscans, -report, -strict, and -version
    switches.

Download

java/org/libjpegturbo/turbojpeg/TJCompressor.java

/*
 * Copyright (C)2011-2015, 2018, 2020, 2022-2023 D. R. Commander.
 *                                               All Rights Reserved.
 * Copyright (C)2015 Viktor Szathmáry.  All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the libjpeg-turbo Project nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

package org.libjpegturbo.turbojpeg;

import java.awt.image.*;
import java.nio.*;
import java.io.*;

/**
 * TurboJPEG compressor
 */
public class TJCompressor implements Closeable {

  /**
   * Create a TurboJPEG compressor instance.
   */
  public TJCompressor() throws TJException {
    init();
  }

  /**
   * Create a TurboJPEG compressor instance and associate the 8-bit-per-sample
   * packed-pixel 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);
  }

  /**
   * Create a TurboJPEG compressor instance and associate the 8-bit-per-sample
   * packed-pixel 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 8-bit-per-sample packed-pixel RGB, grayscale, or CMYK source
   * image with this compressor instance.
   *
   * @param srcImage buffer containing a packed-pixel RGB, grayscale, or CMYK
   * source image 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 row in the source image.  Normally this should be
   * <code>width * {@link TJ#getPixelSize TJ.getPixelSize}(pixelFormat)</code>,
   * if the source image is unpadded.  (Setting this parameter to 0 is the
   * equivalent of setting it to <code>width *
   * {@link TJ#getPixelSize TJ.getPixelSize}(pixelFormat)</code>.)  However,
   * you can also use this parameter to specify the row alignment/padding of
   * the source image, to skip rows, or to compress/encode a JPEG or YUV image
   * from a specific region of a larger 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
   *
   * @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()");
    srcBuf8 = srcImage;
    srcWidth = width;
    if (pitch == 0)
      srcPitch = width * TJ.getPixelSize(pixelFormat);
    else
      srcPitch = pitch;
    srcHeight = height;
    srcPixelFormat = pixelFormat;
    srcX = x;
    srcY = y;
    srcBuf12 = null;
    srcBuf16 = null;
    srcBufInt = null;
    srcYUVImage = null;
  }

  /**
   * Associate a 12-bit-per-sample packed-pixel RGB, grayscale, or CMYK source
   * image with this compressor instance.  Note that 12-bit-per-sample
   * packed-pixel source images can only be compressed into 12-bit-per-sample
   * JPEG images.
   *
   * @param srcImage buffer containing a packed-pixel RGB, grayscale, or CMYK
   * source image to be compressed.  This buffer is not modified.
   *
   * @param x x offset (in pixels) of the region in the source image from which
   * the JPEG image should be compressed
   *
   * @param y y offset (in pixels) of the region in the source image from which
   * the JPEG image should be compressed
   *
   * @param width width (in pixels) of the region in the source image from
   * which the JPEG image should be compressed
   *
   * @param pitch samples per row in the source image.  Normally this should be
   * <code>width * {@link TJ#getPixelSize TJ.getPixelSize}(pixelFormat)</code>,
   * if the source image is unpadded.  (Setting this parameter to 0 is the
   * equivalent of setting it to <code>width *
   * {@link TJ#getPixelSize TJ.getPixelSize}(pixelFormat)</code>.)  However,
   * you can also use this parameter to specify the row alignment/padding of
   * the source image, to skip rows, or to compress a JPEG image from a
   * specific region of a larger source image.
   *
   * @param height height (in pixels) of the region in the source image from
   * which the JPEG image should be compressed
   *
   * @param pixelFormat pixel format of the source image (one of
   * {@link TJ#PF_RGB TJ.PF_*})
   */
  public void setSourceImage12(short[] 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()");
    srcBuf12 = srcImage;
    srcWidth = width;
    if (pitch == 0)
      srcPitch = width * TJ.getPixelSize(pixelFormat);
    else
      srcPitch = pitch;
    srcHeight = height;
    srcPixelFormat = pixelFormat;
    srcX = x;
    srcY = y;
    srcBuf8 = null;
    srcBuf16 = null;
    srcBufInt = null;
    srcYUVImage = null;
  }

  /**
   * Associate a 16-bit-per-sample packed-pixel RGB, grayscale, or CMYK source
   * image with this compressor instance.  Note that 16-bit-per-sample
   * packed-pixel source images can only be compressed into 16-bit-per-sample
   * lossless JPEG images.
   *
   * @param srcImage buffer containing a packed-pixel RGB, grayscale, or CMYK
   * source image to be compressed.  This buffer is not modified.
   *
   * @param x x offset (in pixels) of the region in the source image from which
   * the JPEG image should be compressed
   *
   * @param y y offset (in pixels) of the region in the source image from which
   * the JPEG image should be compressed
   *
   * @param width width (in pixels) of the region in the source image from
   * which the JPEG image should be compressed
   *
   * @param pitch samples per row in the source image.  Normally this should be
   * <code>width * {@link TJ#getPixelSize TJ.getPixelSize}(pixelFormat)</code>,
   * if the source image is unpadded.  (Setting this parameter to 0 is the
   * equivalent of setting it to <code>width *
   * {@link TJ#getPixelSize TJ.getPixelSize}(pixelFormat)</code>.)  However,
   * you can also use this parameter to specify the row alignment/padding of
   * the source image, to skip rows, or to compress a JPEG image from a
   * specific region of a larger source image.
   *
   * @param height height (in pixels) of the region in the source image from
   * which the JPEG image should be compressed
   *
   * @param pixelFormat pixel format of the source image (one of
   * {@link TJ#PF_RGB TJ.PF_*})
   */
  public void setSourceImage16(short[] 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()");
    srcBuf16 = srcImage;
    srcWidth = width;
    if (pitch == 0)
      srcPitch = width * TJ.getPixelSize(pixelFormat);
    else
      srcPitch = pitch;
    srcHeight = height;
    srcPixelFormat = pixelFormat;
    srcX = x;
    srcY = y;
    srcBuf8 = null;
    srcBuf12 = null;
    srcBufInt = null;
    srcYUVImage = null;
  }

  /**
   * Associate an 8-bit-per-sample packed-pixel RGB or grayscale source image
   * with this compressor instance.
   *
   * @param srcImage a <code>BufferedImage</code> instance containing a
   * packed-pixel RGB or grayscale source image 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();
      srcBuf8 = 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();
      srcBuf8 = db.getData();
      srcBufInt = null;
    }
    srcYUVImage = null;
  }

  /**
   * Associate an 8-bit-per-sample planar YUV source image with this compressor
   * instance.  This method sets {@link TJ#PARAM_SUBSAMP} to the chrominance
   * subsampling level of the source image.
   *
   * @param srcImage planar YUV source 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;
    set(TJ.PARAM_SUBSAMP, srcImage.getSubsamp());
    srcBuf8 = null;
    srcBufInt = null;
  }

  /**
   * Set the value of a compression parameter.
   *
   * @param param one of {@link TJ#PARAM_STOPONWARNING TJ.PARAM_*}
   *
   * @param value value of the compression parameter (refer to
   * {@link TJ#PARAM_STOPONWARNING parameter documentation})
   */
  public native void set(int param, int value);

  /**
   * Get the value of a compression parameter.
   *
   * @param param one of {@link TJ#PARAM_STOPONWARNING TJ.PARAM_*}
   *
   * @return the value of the specified compression parameter, or -1 if the
   * value is unknown.
   */
  public native int get(int param);

  /**
   * @deprecated Use
   * <code>{@link #set set}({@link TJ#PARAM_SUBSAMP}, ...)</code> instead.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  @Deprecated
  public void setSubsamp(int subsamp) {
    if (subsamp < 0 || subsamp >= TJ.NUMSAMP)
      throw new IllegalArgumentException("Invalid argument in setSubsamp()");
    set(TJ.PARAM_SUBSAMP, subsamp);
  }

  /**
   * @deprecated Use
   * <code>{@link #set set}({@link TJ#PARAM_QUALITY}, ...)</code> instead.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  @Deprecated
  public void setJPEGQuality(int quality) {
    if (quality < 1 || quality > 100)
      throw new IllegalArgumentException("Invalid argument in setJPEGQuality()");
    set(TJ.PARAM_QUALITY, quality);
  }

  /**
   * Compress the packed-pixel or planar YUV 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 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 (see {@link TJ#PARAM_SUBSAMP}.)
   */
  public void compress(byte[] dstBuf) throws TJException {
    if (dstBuf == null)
      throw new IllegalArgumentException("Invalid argument in compress()");

    if (srcYUVImage != null) {
      checkSubsampling();
      if (get(TJ.PARAM_SUBSAMP) != srcYUVImage.getSubsamp())
        throw new IllegalStateException("TJ.PARAM_SUBSAMP must match subsampling level of YUV image");
      compressedSize = compressFromYUV8(srcYUVImage.getPlanes(),
                                        srcYUVImage.getOffsets(),
                                        srcYUVImage.getWidth(),
                                        srcYUVImage.getStrides(),
                                        srcYUVImage.getHeight(), dstBuf);
    } else if (srcBuf8 != null)
      compressedSize = compress8(srcBuf8, srcX, srcY, srcWidth, srcPitch,
                                 srcHeight, srcPixelFormat, dstBuf);
    else if (srcBuf12 != null)
      compressedSize = compress12(srcBuf12, srcX, srcY, srcWidth, srcPitch,
                                  srcHeight, srcPixelFormat, dstBuf);
    else if (srcBuf16 != null)
      compressedSize = compress16(srcBuf16, srcX, srcY, srcWidth, srcPitch,
                                  srcHeight, srcPixelFormat, dstBuf);
    else if (srcBufInt != null)
      compressedSize = compress8(srcBufInt, srcX, srcY, srcWidth, srcStride,
                                 srcHeight, srcPixelFormat, dstBuf);
    else
      throw new IllegalStateException("No source image is associated with this instance");
  }

  /**
   * @deprecated Use {@link #set set()} and {@link #compress(byte[])} instead.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  @Deprecated
  public void compress(byte[] dstBuf, int flags) throws TJException {
    if (flags < 0)
      throw new IllegalArgumentException("Invalid argument in compress()");
    processFlags(flags);
    compress(dstBuf);
  }

  /**
   * Compress the packed-pixel or planar YUV source image associated with this
   * compressor instance and return a buffer containing a JPEG image.
   *
   * @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() throws TJException {
    byte[] buf;
    if (srcYUVImage != null) {
      buf = new byte[TJ.bufSize(srcYUVImage.getWidth(),
                                srcYUVImage.getHeight(),
                                srcYUVImage.getSubsamp())];
    } else {
      checkSubsampling();
      int subsamp = get(TJ.PARAM_SUBSAMP);
      buf = new byte[TJ.bufSize(srcWidth, srcHeight, subsamp)];
    }
    compress(buf);
    return buf;
  }

  /**
   * @deprecated Use {@link #set set()} and {@link #compress()} instead.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  @Deprecated
  public byte[] compress(int flags) throws TJException {
    processFlags(flags);
    return compress();
  }

  /**
   * Encode the 8-bit-per-sample packed-pixel source image associated with this
   * compressor instance into an 8-bit-per-sample planar YUV image and store it
   * in the given {@link YUVImage} instance.  This method performs color
   * conversion (which is accelerated in the libjpeg-turbo implementation) but
   * does not execute any of the other steps in the JPEG compression process.
   * Encoding CMYK source images into YUV images is not supported.  This method
   * sets {@link TJ#PARAM_SUBSAMP} to the chrominance subsampling level of the
   * destination image.
   *
   * @param dstImage {@link YUVImage} instance that will receive the planar YUV
   * image
   */
  public void encodeYUV(YUVImage dstImage) throws TJException {
    if (dstImage == null)
      throw new IllegalArgumentException("Invalid argument in encodeYUV()");
    if (srcBuf8 == null && srcBufInt == null)
      throw new IllegalStateException("No 8-bit-per-sample source image is associated with this instance");
    if (srcYUVImage != null)
      throw new IllegalStateException("Source image is not correct type");
    if (srcWidth != dstImage.getWidth() || srcHeight != dstImage.getHeight())
      throw new IllegalStateException("Destination image is the wrong size");
    set(TJ.PARAM_SUBSAMP, dstImage.getSubsamp());

    if (srcBufInt != null) {
      encodeYUV8(srcBufInt, srcX, srcY, srcWidth, srcStride, srcHeight,
                 srcPixelFormat, dstImage.getPlanes(), dstImage.getOffsets(),
                 dstImage.getStrides());
    } else {
      encodeYUV8(srcBuf8, srcX, srcY, srcWidth, srcPitch, srcHeight,
                 srcPixelFormat, dstImage.getPlanes(), dstImage.getOffsets(),
                 dstImage.getStrides());
    }
    compressedSize = 0;
  }

  /**
   * @deprecated Use {@link #set set()} and {@link #encodeYUV(YUVImage)}
   * instead.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  @Deprecated
  public void encodeYUV(YUVImage dstImage, int flags) throws TJException {
    if (flags < 0)
      throw new IllegalArgumentException("Invalid argument in encodeYUV()");

    processFlags(flags);
    encodeYUV(dstImage);
  }

  /**
   * Encode the 8-bit-per-sample packed-pixel source image associated with this
   * compressor instance into an 8-bit-per-sample unified planar YUV image and
   * return a {@link YUVImage} instance containing the encoded image.  This
   * method performs color conversion (which is accelerated in the
   * libjpeg-turbo implementation) but does not execute any of the other steps
   * in the JPEG compression process.  Encoding CMYK source images into YUV
   * images is not supported.
   *
   * @param align row alignment (in bytes) of the YUV image (must be a power of
   * 2.)  Setting this parameter to n will cause each row in each plane of the
   * YUV image to be padded to the nearest multiple of n bytes (1 = unpadded.)
   *
   * @return a {@link YUVImage} instance containing the unified planar YUV
   * encoded image
   */
  public YUVImage encodeYUV(int align) throws TJException {
    if (srcBuf8 == null && srcBufInt == null)
      throw new IllegalStateException("No 8-bit-per-sample source image is associated with this instance");
    checkSubsampling();
    if (align < 1 || ((align & (align - 1)) != 0))
      throw new IllegalStateException("Invalid argument in encodeYUV()");
    YUVImage dstYUVImage = new YUVImage(srcWidth, align, srcHeight,
                                        get(TJ.PARAM_SUBSAMP));
    encodeYUV(dstYUVImage);
    return dstYUVImage;
  }

  /**
   * @deprecated Use {@link #set set()} and {@link #encodeYUV(int)} instead.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  @Deprecated
  public YUVImage encodeYUV(int align, int flags) throws TJException {
    processFlags(flags);
    return encodeYUV(align);
  }

  /**
   * Encode the 8-bit-per-sample packed-pixel source image associated with this
   * compressor instance into separate 8-bit-per-sample Y, U (Cb), and V (Cr)
   * image planes and return a {@link YUVImage} instance containing the encoded
   * image planes.  This method performs color conversion (which is accelerated
   * in the libjpeg-turbo implementation) but does not execute any of the other
   * steps in the JPEG compression process.  Encoding CMYK source images into
   * YUV images is not supported.
   *
   * @param strides an array of integers, each specifying the number of bytes
   * per row in the corresponding plane of the YUV source image.  Setting the
   * stride for any plane to 0 is the same as setting it to the plane width
   * (see {@link YUVImage}.)  If <code>strides</code> is null, then the strides
   * for all planes will be set to their respective plane widths.  You can
   * adjust the strides in order to add an arbitrary amount of row padding to
   * each plane.
   *
   * @return a {@link YUVImage} instance containing the encoded image planes
   */
  public YUVImage encodeYUV(int[] strides) throws TJException {
    if (srcBuf8 == null && srcBufInt == null)
      throw new IllegalStateException("No 8-bit-per-sample source image is associated with this instance");
    checkSubsampling();
    YUVImage dstYUVImage = new YUVImage(srcWidth, strides, srcHeight,
                                        get(TJ.PARAM_SUBSAMP));
    encodeYUV(dstYUVImage);
    return dstYUVImage;
  }

  /**
   * @deprecated Use {@link #set set()} and {@link #encodeYUV(int[])} instead.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  @Deprecated
  public YUVImage encodeYUV(int[] strides, int flags) throws TJException {
    processFlags(flags);
    return encodeYUV(strides);
  }

  /**
   * 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();
  }

  @SuppressWarnings("checkstyle:DesignForExtension")
  @Override
  protected void finalize() throws Throwable {
    try {
      close();
    } catch (TJException e) {
    } finally {
      super.finalize();
    }
  };

  @SuppressWarnings("deprecation")
  private void processFlags(int flags) {
    set(TJ.PARAM_BOTTOMUP, (flags & TJ.FLAG_BOTTOMUP) != 0 ? 1 : 0);

    if (get(TJ.PARAM_QUALITY) >= 96 || (flags & TJ.FLAG_ACCURATEDCT) != 0)
      set(TJ.PARAM_FASTDCT, 0);
    else
      set(TJ.PARAM_FASTDCT, 1);

    set(TJ.PARAM_STOPONWARNING, (flags & TJ.FLAG_STOPONWARNING) != 0 ? 1 : 0);
    set(TJ.PARAM_PROGRESSIVE, (flags & TJ.FLAG_PROGRESSIVE) != 0 ? 1 : 0);
  }

  private void checkSubsampling() {
    if (get(TJ.PARAM_SUBSAMP) == TJ.SAMP_UNKNOWN)
      throw new IllegalStateException("TJ.PARAM_SUBSAMP must be specified");
  }

  private native void init() throws TJException;

  private native void destroy() throws TJException;

  // JPEG size in bytes is returned
  @SuppressWarnings("checkstyle:HiddenField")
  private native int compress8(byte[] srcBuf, int x, int y, int width,
    int pitch, int height, int pixelFormat, byte[] jpegBuf) throws TJException;

  @SuppressWarnings("checkstyle:HiddenField")
  private native int compress12(short[] srcBuf, int x, int y, int width,
    int pitch, int height, int pixelFormat, byte[] jpegBuf) throws TJException;

  @SuppressWarnings("checkstyle:HiddenField")
  private native int compress16(short[] srcBuf, int x, int y, int width,
    int pitch, int height, int pixelFormat, byte[] jpegBuf) throws TJException;

  @SuppressWarnings("checkstyle:HiddenField")
  private native int compress8(int[] srcBuf, int x, int y, int width,
    int stride, int height, int pixelFormat, byte[] jpegBuf)
    throws TJException;

  @SuppressWarnings("checkstyle:HiddenField")
  private native int compressFromYUV8(byte[][] srcPlanes, int[] srcOffsets,
    int width, int[] srcStrides, int height, byte[] jpegBuf)
    throws TJException;

  @SuppressWarnings("checkstyle:HiddenField")
  private native void encodeYUV8(byte[] srcBuf, int x, int y, int width,
    int pitch, int height, int pixelFormat, byte[][] dstPlanes,
    int[] dstOffsets, int[] dstStrides) throws TJException;

  @SuppressWarnings("checkstyle:HiddenField")
  private native void encodeYUV8(int[] srcBuf, int x, int y, int width,
    int srcStride, int height, int pixelFormat, byte[][] dstPlanes,
    int[] dstOffsets, int[] dstStrides) throws TJException;

  /**
   * @hidden
   * Ugly hack alert.  It isn't straightforward to load 12-bit-per-sample and
   * 16-bit-per-sample images using the ImageIO and BufferedImage classes, and
   * ImageIO doesn't support PBMPLUS files anyhow.  This method accesses
   * tj3LoadImage() through JNI and copies the pixel data between the C and
   * Java heaps.  Currently it is undocumented and used only by TJBench.
   */
  @SuppressWarnings("checkstyle:JavadocMethod")
  public native Object loadImage(int precision, String fileName, int[] width,
                                 int align, int[] height, int[] pixelFormat)
                                 throws TJException;

  static {
    TJLoader.load();
  }

  private long handle = 0;
  private byte[] srcBuf8 = null;
  private short[] srcBuf12 = null;
  private short[] srcBuf16 = 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 compressedSize = 0;
  private ByteOrder byteOrder = null;
}

Download

kc3-lang/libjpeg-turbo/java/org/libjpegturbo/turbojpeg/TJCompressor.java

Commit

java/org/libjpegturbo/turbojpeg/TJCompressor.java