libjpeg-turbo/jna/TJComp.java

/*
 * Copyright (C) 2011-2012, 2014-2015, 2017-2018, 2022-2024, 2026
 *           D. R. Commander
 *
 * 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.
 */

// This program demonstrates how to use TurboJPEG/JNA to approximate the
// functionality of the IJG's cjpeg program.  cjpeg features that are not
// covered:
//
// - GIF and Targa input file formats [legacy feature]
// - Separate quality settings for luminance and chrominance
// - The floating-point DCT method [legacy feature]
// - Input image smoothing
// - Progress reporting
// - Debug output
// - Forcing baseline-compatible quantization tables
// - Specifying arbitrary quantization tables
// - Specifying arbitrary sampling factors
// - Scan scripts

import java.io.*;
import java.nio.*;
import java.util.*;

import com.sun.jna.*;
import com.sun.jna.ptr.*;


final class TJComp {

  private TJComp() {}

  static final String CLASS_NAME =
    new TJComp().getClass().getName();

  static final int DEFAULT_SUBSAMP = TJ.SAMP_420;
  static final int DEFAULT_QUALITY = 75;


  static final String[] SUBSAMP_NAME = {
    "444", "422", "420", "GRAY", "440", "411", "441", "410", "24"
  };


  static void usage() {
    System.out.println("\nUSAGE: java [Java options] " + CLASS_NAME +
                       " [options] <Input image> <JPEG image>\n");

    System.out.println("The input image can be in Windows BMP or PBMPLUS (PPM/PGM) format.\n");

    System.out.println("GENERAL OPTIONS (CAN BE ABBREVIATED)");
    System.out.println("------------------------------------");
    System.out.println("-icc FILE");
    System.out.println("    Embed the ICC (International Color Consortium) color management profile");
    System.out.println("    from the specified file into the JPEG image");
    System.out.println("-lossless PSV[,Pt]");
    System.out.println("    Create a lossless JPEG image (implies -subsamp 444) using predictor");
    System.out.println("    selection value PSV (1-7) and optional point transform Pt (0 through");
    System.out.println("    {data precision} - 1)");
    System.out.println("-maxmemory N");
    System.out.println("    Memory limit (in megabytes) for intermediate buffers used with progressive");
    System.out.println("    JPEG compression, lossless JPEG compression, and Huffman table optimization");
    System.out.println("    [default = no limit]");
    System.out.println("-noicc");
    System.out.println("    Do not transfer the embedded ICC profile (if any) from a PNG input image");
    System.out.println("-precision N");
    System.out.println("    Create a JPEG image with N-bit data precision [N = 2..16; default = 8; if N");
    System.out.println("    is not 8 or 12, then -lossless must also be specified] (-precision 12");
    System.out.println("    implies -optimize unless -arithmetic is also specified)");
    System.out.println("-restart N");
    System.out.println("    Add a restart marker every N MCU rows [default = 0 (no restart markers)].");
    System.out.println("    Append 'B' to specify the restart marker interval in MCUs (lossy only.)\n");

    System.out.println("LOSSY JPEG OPTIONS (CAN BE ABBREVIATED)");
    System.out.println("---------------------------------------");
    System.out.println("-arithmetic");
    System.out.println("    Use arithmetic entropy coding instead of Huffman entropy coding (can be");
    System.out.println("    combined with -progressive)");
    System.out.println("-dct fast");
    System.out.println("    Use less accurate DCT algorithm [legacy feature]");
    System.out.println("-dct int");
    System.out.println("    Use more accurate DCT algorithm [default]");
    System.out.println("-grayscale");
    System.out.println("    Create a grayscale JPEG image from a full-color input image");
    System.out.println("-optimize");
    System.out.println("    Use Huffman table optimization");
    System.out.println("-progressive");
    System.out.println("    Create a progressive JPEG image instead of a single-scan JPEG image (can be");
    System.out.println("    combined with -arithmetic; implies -optimize unless -arithmetic is also");
    System.out.println("    specified)");
    System.out.println("-quality {1..100}");
    System.out.format("    Create a JPEG image with the specified quality level [default = %d]\n",
           DEFAULT_QUALITY);
    System.out.println("-rgb");
    System.out.println("    Create a JPEG image that uses the RGB colorspace instead of the YCbCr");
    System.out.println("    colorspace");
    System.out.println("-subsamp {444|422|440|420|411|441|410|24}");
    System.out.println("    Create a JPEG image that uses the specified chrominance subsampling level");
    System.out.format("    [default = %s]\n\n", SUBSAMP_NAME[DEFAULT_SUBSAMP]);

    System.exit(1);
  }


  static boolean matchArg(String arg, String string, int minChars) {
    if (arg.length() > string.length() || arg.length() < minChars)
      return false;

    int cmpChars = Math.max(arg.length(), minChars);
    string = string.substring(0, cmpChars);

    return arg.equalsIgnoreCase(string);
  }


  public static void main(String[] argv) {
    int exitStatus = 0;
    Pointer srcBuf = null;
    PointerByReference jpegBuf = new PointerByReference();

    try {
      int i;
      int arithmetic = -1, colorspace = TJ.CS_DEFAULT, fastDCT = -1,
        losslessPSV = -1, losslessPt = -1, maxMemory = -1, optimize = -1,
        precision = 8, progressive = -1, quality = DEFAULT_QUALITY,
        restartIntervalBlocks = -1, restartIntervalRows = -1,
        subsamp = DEFAULT_SUBSAMP;
      boolean noICC = false;
      String iccFilename = null;
      IntByReference width = new IntByReference(),
        height = new IntByReference(),
        pixelFormat = new IntByReference(TJ.PF_UNKNOWN);
      NativeLongByReference jpegSize = new NativeLongByReference();

      for (i = 0; i < argv.length; i++) {
        if (matchArg(argv[i], "-arithmetic", 2))
          arithmetic = 1;
        else if (matchArg(argv[i], "-dct", 2) && i < argv.length - 1) {
          i++;
          if (matchArg(argv[i], "fast", 1))
            fastDCT = 1;
          else if (!matchArg(argv[i], "int", 1))
            usage();
        } else if (matchArg(argv[i], "-grayscale", 2) ||
                   matchArg(argv[i], "-greyscale", 2))
          colorspace = TJ.CS_GRAY;
        else if (matchArg(argv[i], "-icc", 2) && i < argv.length - 1)
          iccFilename = argv[++i];
        else if (matchArg(argv[i], "-lossless", 2) && i < argv.length - 1) {
          Scanner scanner = new Scanner(argv[++i]).useDelimiter(",");

          try {
            if (scanner.hasNextInt())
              losslessPSV = scanner.nextInt();
            if (scanner.hasNextInt())
              losslessPt = scanner.nextInt();
          } catch (Exception e) {}

          if (losslessPSV < 1 || losslessPSV > 7)
            usage();
        } else if (matchArg(argv[i], "-maxmemory", 2) && i < argv.length - 1) {
          int temp = -1;

          try {
            temp = Integer.parseInt(argv[++i]);
          } catch (NumberFormatException e) {}
          if (temp < 0)
            usage();
          maxMemory = temp;
        } else if (matchArg(argv[i], "-noicc", 4))
          noICC = true;
        else if (matchArg(argv[i], "-optimize", 2) ||
                 matchArg(argv[i], "-optimise", 2))
          optimize = 1;
        else if (matchArg(argv[i], "-precision", 4) && i < argv.length - 1) {
          int temp = 0;

          try {
            temp = Integer.parseInt(argv[++i]);
          } catch (NumberFormatException e) {}
          if (temp < 2 || temp > 16)
            usage();
          precision = temp;
        } else if (matchArg(argv[i], "-progressive", 2))
          progressive = 1;
        else if (matchArg(argv[i], "-quality", 2) && i < argv.length - 1) {
          int temp = 0;

          try {
            temp = Integer.parseInt(argv[++i]);
          } catch (NumberFormatException e) {}
          if (temp < 1 || temp > 100)
            usage();
          quality = temp;
        } else if (matchArg(argv[i], "-rgb", 3))
          colorspace = TJ.CS_RGB;
        else if (matchArg(argv[i], "-restart", 2) && 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 (matchArg(argv[i], "-subsamp", 2) && i < argv.length - 1) {
          i++;
          if (matchArg(argv[i], "444", 3))
            subsamp = TJ.SAMP_444;
          else if (matchArg(argv[i], "422", 3))
            subsamp = TJ.SAMP_422;
          else if (matchArg(argv[i], "440", 3))
            subsamp = TJ.SAMP_440;
          else if (matchArg(argv[i], "420", 3))
            subsamp = TJ.SAMP_420;
          else if (matchArg(argv[i], "411", 3))
            subsamp = TJ.SAMP_411;
          else if (matchArg(argv[i], "441", 3))
            subsamp = TJ.SAMP_441;
          else if (matchArg(argv[i], "410", 3))
            subsamp = TJ.SAMP_410;
          else if (matchArg(argv[i], "24", 2))
            subsamp = TJ.SAMP_24;
          else
            usage();
        } else break;
      }

      if (i != argv.length - 2)
        usage();
      if (losslessPSV == -1 && precision != 8 && precision != 12)
        usage();

      try (TJ.Handle tjInstance = new TJ.Handle(TJ.INIT_COMPRESS)) {

        TJ.set(tjInstance, TJ.PARAM_QUALITY, quality);
        TJ.set(tjInstance, TJ.PARAM_SUBSAMP, subsamp);
        TJ.set(tjInstance, TJ.PARAM_PRECISION, precision);
        if (fastDCT >= 0)
          TJ.set(tjInstance, TJ.PARAM_FASTDCT, fastDCT);
        if (optimize >= 0)
          TJ.set(tjInstance, TJ.PARAM_OPTIMIZE, optimize);
        if (progressive >= 0)
          TJ.set(tjInstance, TJ.PARAM_PROGRESSIVE, progressive);
        if (arithmetic >= 0)
          TJ.set(tjInstance, TJ.PARAM_ARITHMETIC, arithmetic);
        if (losslessPSV >= 1 && losslessPSV <= 7) {
          TJ.set(tjInstance, TJ.PARAM_LOSSLESS, 1);
          TJ.set(tjInstance, TJ.PARAM_LOSSLESSPSV, losslessPSV);
          if (losslessPt >= 0)
            TJ.set(tjInstance, TJ.PARAM_LOSSLESSPT, losslessPt);
        }
        if (restartIntervalBlocks >= 0)
          TJ.set(tjInstance, TJ.PARAM_RESTARTBLOCKS, restartIntervalBlocks);
        if (restartIntervalRows >= 0)
          TJ.set(tjInstance, TJ.PARAM_RESTARTROWS, restartIntervalRows);
        if (maxMemory >= 0)
          TJ.set(tjInstance, TJ.PARAM_MAXMEMORY, maxMemory);
        if (noICC)
          TJ.set(tjInstance, TJ.PARAM_SAVEMARKERS, 0);

        if (precision <= 8)
          srcBuf = TJ.loadImage8(tjInstance, argv[i], width, 1, height,
                                 pixelFormat);
        else if (precision <= 12)
          srcBuf = TJ.loadImage12(tjInstance, argv[i], width, 1, height,
                                  pixelFormat);
        else
          srcBuf = TJ.loadImage16(tjInstance, argv[i], width, 1, height,
                                  pixelFormat);

        if (pixelFormat.getValue() == TJ.PF_GRAY &&
            colorspace == TJ.CS_DEFAULT)
          colorspace = TJ.CS_GRAY;
        TJ.set(tjInstance, TJ.PARAM_COLORSPACE, colorspace);

        if (iccFilename != null) {
          File iccFile = new File(iccFilename);
          try (FileInputStream fis = new FileInputStream(iccFile)) {
            int iccSize = fis.available();
            if (iccSize < 1)
              throw new Exception("ICC profile contains no data");
            try (Memory iccBuf = new Memory(iccSize)) {
              fis.getChannel().read(iccBuf.getByteBuffer(0, iccSize));
              TJ.setICCProfile(tjInstance, iccBuf, new NativeLong(iccSize));
            }
          }
        }

        if (precision <= 8)
          TJ.compress8(tjInstance, srcBuf, width.getValue(), 0,
                       height.getValue(), pixelFormat.getValue(), jpegBuf,
                       jpegSize);
        else if (precision <= 12)
          TJ.compress12(tjInstance, srcBuf, width.getValue(), 0,
                        height.getValue(), pixelFormat.getValue(), jpegBuf,
                        jpegSize);
        else
          TJ.compress16(tjInstance, srcBuf, width.getValue(), 0,
                        height.getValue(), pixelFormat.getValue(), jpegBuf,
                        jpegSize);

      }  // try (tjInstance)

      File outFile = new File(argv[++i]);
      try (FileOutputStream fos = new FileOutputStream(outFile)) {
        ByteBuffer bb =
          jpegBuf.getValue().getByteBuffer(0, jpegSize.getValue().longValue());
        fos.getChannel().write(bb);
      }
    } catch (Exception e) {
      e.printStackTrace();
      exitStatus = -1;
    } finally {
      TJ.free(srcBuf);
      TJ.free(jpegBuf.getValue());
    }

    System.exit(exitStatus);
  }
};