1. /*

  2.  * @(#)JPEG.java	1.14 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package com.sun.imageio.plugins.jpeg;

  9. 

  10. import javax.imageio.metadata.IIOMetadataFormatImpl;

  11. import javax.imageio.ImageTypeSpecifier;

  12. import javax.imageio.plugins.jpeg.JPEGQTable;

  13. import javax.imageio.plugins.jpeg.JPEGHuffmanTable;

  14. 

  15. import java.awt.image.ColorModel;

  16. import java.awt.image.BufferedImage;

  17. import java.awt.image.DataBuffer;

  18. import java.awt.color.ColorSpace;

  19. import java.awt.color.ICC_ColorSpace;

  20. 

  21. /**

  22.  * A class containing JPEG-related constants, definitions, and 

  23.  * static methods.  This class and its constants must be public so that

  24.  * <code>JPEGImageWriteParam</code> can see it.

  25.  */

  26. public class JPEG {

  27. 

  28.     // List of all the JPEG markers (pre-JPEG2000)

  29. 

  30.     /** For temporary use in arithmetic coding */

  31.     public static final int TEM = 0x01;

  32. 

  33.     // Codes 0x02 - 0xBF are reserved

  34. 

  35.     // SOF markers for Nondifferential Huffman coding

  36.     /** Baseline DCT */

  37.     public static final int SOF0 = 0xC0;

  38.     /** Extended Sequential DCT */

  39.     public static final int SOF1 = 0xC1;

  40.     /** Progressive DCT */

  41.     public static final int SOF2 = 0xC2;

  42.     /** Lossless Sequential */

  43.     public static final int SOF3 = 0xC3;

  44. 

  45.     /** Define Huffman Tables */

  46.     public static final int DHT = 0xC4;    

  47. 

  48.     // SOF markers for Differential Huffman coding

  49.     /** Differential Sequential DCT */

  50.     public static final int SOF5 = 0xC5;

  51.     /** Differential Progressive DCT */

  52.     public static final int SOF6 = 0xC6;

  53.     /** Differential Lossless */

  54.     public static final int SOF7 = 0xC7;

  55. 

  56.     /** Reserved for JPEG extensions */

  57.     public static final int JPG = 0xC8;

  58. 

  59.     // SOF markers for Nondifferential arithmetic coding

  60.     /** Extended Sequential DCT, Arithmetic coding */

  61.     public static final int SOF9 = 0xC9;

  62.     /** Progressive DCT, Arithmetic coding */

  63.     public static final int SOF10 = 0xCA;

  64.     /** Lossless Sequential, Arithmetic coding */

  65.     public static final int SOF11 = 0xCB;

  66. 

  67.     /** Define Arithmetic conditioning tables */

  68.     public static final int DAC = 0xCC;

  69. 

  70.     // SOF markers for Differential arithmetic coding

  71.     /** Differential Sequential DCT, Arithmetic coding */

  72.     public static final int SOF13 = 0xCD;

  73.     /** Differential Progressive DCT, Arithmetic coding */

  74.     public static final int SOF14 = 0xCE;

  75.     /** Differential Lossless, Arithmetic coding */

  76.     public static final int SOF15 = 0xCF;

  77. 

  78.     // Restart Markers

  79.     public static final int RST0 = 0xD0;

  80.     public static final int RST1 = 0xD1;

  81.     public static final int RST2 = 0xD2;

  82.     public static final int RST3 = 0xD3;

  83.     public static final int RST4 = 0xD4;

  84.     public static final int RST5 = 0xD5;

  85.     public static final int RST6 = 0xD6;

  86.     public static final int RST7 = 0xD7;

  87.     /** Number of restart markers */

  88.     public static final int RESTART_RANGE = 8;

  89. 

  90.     /** Start of Image */

  91.     public static final int SOI = 0xD8;

  92.     /** End of Image */

  93.     public static final int EOI = 0xD9;

  94.     /** Start of Scan */

  95.     public static final int SOS = 0xDA;

  96. 

  97.     /** Define Quantisation Tables */

  98.     public static final int DQT = 0xDB;

  99. 

  100.     /** Define Number of lines */

  101.     public static final int DNL = 0xDC;

  102. 

  103.     /** Define Restart Interval */

  104.     public static final int DRI = 0xDD;

  105. 

  106.     /** Define Heirarchical progression */

  107.     public static final int DHP = 0xDE;

  108. 

  109.     /** Expand reference image(s) */

  110.     public static final int EXP = 0xDF;

  111. 

  112.     // Application markers

  113.     /** APP0 used by JFIF */

  114.     public static final int APP0 = 0xE0;

  115.     public static final int APP1 = 0xE1;

  116.     public static final int APP2 = 0xE2;

  117.     public static final int APP3 = 0xE3;

  118.     public static final int APP4 = 0xE4;

  119.     public static final int APP5 = 0xE5;

  120.     public static final int APP6 = 0xE6;

  121.     public static final int APP7 = 0xE7;

  122.     public static final int APP8 = 0xE8;

  123.     public static final int APP9 = 0xE9;

  124.     public static final int APP10 = 0xEA;

  125.     public static final int APP11 = 0xEB;

  126.     public static final int APP12 = 0xEC;

  127.     public static final int APP13 = 0xED;

  128.     /** APP14 used by Adobe */

  129.     public static final int APP14 = 0xEE;

  130.     public static final int APP15 = 0xEF;

  131. 

  132.     // codes 0xF0 to 0xFD are reserved

  133. 

  134.     /** Comment marker */

  135.     public static final int COM = 0xFE;

  136. 

  137.     // JFIF Resolution units

  138.     /** The X and Y units simply indicate the aspect ratio of the pixels. */

  139.     public static final int DENSITY_UNIT_ASPECT_RATIO = 0;

  140.     /** Pixel density is in pixels per inch. */

  141.     public static final int DENSITY_UNIT_DOTS_INCH    = 1;

  142.     /** Pixel density is in pixels per centemeter. */

  143.     public static final int DENSITY_UNIT_DOTS_CM      = 2;

  144.     /** The max known value for DENSITY_UNIT */

  145.     public static final int NUM_DENSITY_UNIT = 3;

  146. 

  147.     // Adobe transform values

  148.     public static final int ADOBE_IMPOSSIBLE = -1;

  149.     public static final int ADOBE_UNKNOWN = 0;

  150.     public static final int ADOBE_YCC = 1;

  151.     public static final int ADOBE_YCCK = 2;

  152. 

  153.     // Spi initialization stuff

  154.     public static final String vendor = "Sun Microsystems, Inc.";

  155.     public static final String version = "0.5";

  156.     // Names of the formats we can read or write

  157.     public static final String [] names = {"JPEG", "jpeg", "JPG", "jpg"};

  158.     public static final String [] suffixes = {"jpg", "jpeg"};

  159.     public static final String [] MIMETypes = {"image/jpeg"};

  160.     public static final String nativeImageMetadataFormatName = 

  161.         "javax_imageio_jpeg_image_1.0";

  162.     public static final String nativeImageMetadataFormatClassName = 

  163.         "com.sun.imageio.plugins.jpeg.JPEGImageMetadataFormat";

  164.     public static final String nativeStreamMetadataFormatName = 

  165.         "javax_imageio_jpeg_stream_1.0";

  166.     public static final String nativeStreamMetadataFormatClassName = 

  167.         "com.sun.imageio.plugins.jpeg.JPEGStreamMetadataFormat";

  168. 

  169.     // IJG Color codes.

  170.     public static final int JCS_UNKNOWN = 0;       // error/unspecified

  171.     public static final int JCS_GRAYSCALE = 1;     // monochrome

  172.     public static final int JCS_RGB = 2;           // red/green/blue

  173.     public static final int JCS_YCbCr = 3;         // Y/Cb/Cr (also known as YUV)

  174.     public static final int JCS_CMYK = 4;          // C/M/Y/K

  175.     public static final int JCS_YCC = 5;           // PhotoYCC

  176.     public static final int JCS_RGBA = 6;          // RGB-Alpha

  177.     public static final int JCS_YCbCrA = 7;        // Y/Cb/Cr/Alpha

  178.     // 8 and 9 were old "Legacy" codes which the old code never identified

  179.     // on reading anyway.  Support for writing them is being dropped, too.

  180.     public static final int JCS_YCCA = 10;         // PhotoYCC-Alpha

  181.     public static final int JCS_YCCK = 11;         // Y/Cb/Cr/K 

  182. 

  183.     public static final int NUM_JCS_CODES = JCS_YCCK+1;

  184. 

  185.     /** IJG can handle up to 4-channel JPEGs */

  186.     public static final int [] [] bandOffsets = {{0}, 

  187.                                           {0, 1}, 

  188.                                           {0, 1, 2}, 

  189.                                           {0, 1, 2, 3}};

  190. 

  191.     public static final int [] bOffsRGB = { 2, 1, 0 };

  192. 

  193.     protected static final ColorSpace sRGB = 

  194.         ColorSpace.getInstance(ColorSpace.CS_sRGB);

  195.     protected static ColorSpace YCC = null;  // Can't be final

  196. 

  197.     static {

  198.         try {

  199.             YCC = ColorSpace.getInstance(ColorSpace.CS_PYCC);

  200.         } catch (IllegalArgumentException e) {

  201.             // PYCC.pf may not always be installed

  202.         }

  203.     }

  204.      

  205.     // Default value for ImageWriteParam

  206.     public static final float DEFAULT_QUALITY = 0.75F;

  207. 

  208.     /**

  209.      * Returns <code>true</code> if the given <code>ColorSpace</code>

  210.      * object is an instance of ICC_ColorSpace but is not one of the

  211.      * standard <code>ColorSpaces</code> returned by 

  212.      * <code>ColorSpace.getInstance()</code>.

  213.      */

  214.     static boolean isNonStandardICC(ColorSpace cs) {

  215.         boolean retval = false;

  216.         if ((cs instanceof ICC_ColorSpace)

  217.             && (!cs.isCS_sRGB())

  218.             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ)))

  219.             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_GRAY)))

  220.             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB)))

  221.             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_PYCC)))

  222.             ) {

  223.             retval = true;

  224.         }

  225.         return retval;

  226.     }

  227. 

  228. 

  229.     /**

  230.      * Returns <code>true</code> if the given imageType can be used

  231.      * in a JFIF file.  If <code>input</code> is true, then the

  232.      * image type is considered before colorspace conversion.

  233.      */

  234.     static boolean isJFIFcompliant(ImageTypeSpecifier imageType,

  235.                                    boolean input) {

  236.         ColorModel cm = imageType.getColorModel();

  237.         // Can't have alpha

  238.         if (cm.hasAlpha()) {

  239.             return false;

  240.         }

  241.         // Gray is OK, always

  242.         int numComponents = imageType.getNumComponents();

  243.         if (numComponents == 1) {

  244.             return true;

  245.         }

  246.         

  247.         // If it isn't gray, it must have 3 channels

  248.         if (numComponents != 3) {

  249.             return false;

  250.         }

  251.         

  252.         if (input) {

  253.             // Must be RGB

  254.             if (cm.getColorSpace().getType() == ColorSpace.TYPE_RGB) {

  255.                 return true;

  256.             }

  257.         } else {

  258.             // Must be YCbCr

  259.             if (cm.getColorSpace().getType() == ColorSpace.TYPE_YCbCr) {

  260.                 return true;

  261.             }

  262.         }

  263. 

  264.         return false;

  265.     }

  266. 

  267.     /**

  268.      * Given an image type, return the Adobe transform corresponding to 

  269.      * that type, or ADOBE_IMPOSSIBLE if the image type is incompatible

  270.      * with an Adobe marker segment.  If <code>input</code> is true, then

  271.      * the image type is considered before colorspace conversion.

  272.      */

  273.     static int transformForType(ImageTypeSpecifier imageType, boolean input) {

  274.         int retval = ADOBE_IMPOSSIBLE;

  275.         ColorModel cm = imageType.getColorModel();

  276.         switch (cm.getColorSpace().getType()) {

  277.         case ColorSpace.TYPE_GRAY:

  278.             retval = ADOBE_UNKNOWN;

  279.             break;

  280.         case ColorSpace.TYPE_RGB:

  281.             retval = input ? ADOBE_YCC : ADOBE_UNKNOWN;

  282.             break;

  283.         case ColorSpace.TYPE_YCbCr:

  284.             retval = ADOBE_YCC;

  285.             break;

  286.         case ColorSpace.TYPE_CMYK:

  287.             retval = input ? ADOBE_YCCK : ADOBE_IMPOSSIBLE;

  288.         }

  289.         return retval;

  290.     }

  291. 

  292.     /**

  293.      * Converts an ImageWriteParam (i.e. IJG) non-linear quality value

  294.      * to a float suitable for passing to JPEGQTable.getScaledInstance().

  295.      */

  296.     static float convertToLinearQuality(float quality) {

  297.         // The following is converted from the IJG code.

  298.         if (quality <= 0.0F) {

  299.             quality = 0.01F;

  300.         }

  301.         

  302.         if (quality > 1.00F) {

  303.             quality = 1.00F;

  304.         }

  305.         

  306.         if (quality < 0.5F) {

  307.             quality = 0.5F / quality;

  308.         } else {

  309.             quality = 2.0F - (quality * 2.0F);

  310.         }

  311. 

  312.         return quality;

  313.     }

  314. 

  315.     /**

  316.      * Return an array of default, visually lossless quantization tables.

  317.      */

  318.     static JPEGQTable [] getDefaultQTables() {

  319.         JPEGQTable [] qTables = new JPEGQTable[2];

  320.         qTables[0] = JPEGQTable.K1Div2Luminance;

  321.         qTables[1] = JPEGQTable.K2Div2Chrominance;

  322.         return qTables;

  323.     }

  324. 

  325.     /**

  326.      * Return an array of default Huffman tables.

  327.      */

  328.     static JPEGHuffmanTable [] getDefaultHuffmanTables(boolean wantDC) {

  329.         JPEGHuffmanTable [] tables = new JPEGHuffmanTable[2];

  330.         if (wantDC) {

  331.             tables[0] = JPEGHuffmanTable.StdDCLuminance;

  332.             tables[1] = JPEGHuffmanTable.StdDCChrominance;

  333.         } else {

  334.             tables[0] = JPEGHuffmanTable.StdACLuminance;

  335.             tables[1] = JPEGHuffmanTable.StdACChrominance;

  336.         }

  337.         return tables;

  338.     }

  339. 

  340. }