1 /*
   2  * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.imageio.plugins.jpeg;
  27 
  28 import javax.imageio.metadata.IIOMetadataFormatImpl;
  29 import javax.imageio.ImageTypeSpecifier;
  30 import javax.imageio.plugins.jpeg.JPEGQTable;
  31 import javax.imageio.plugins.jpeg.JPEGHuffmanTable;
  32 
  33 import java.awt.image.ColorModel;
  34 import java.awt.image.BufferedImage;
  35 import java.awt.image.DataBuffer;
  36 import java.awt.color.ColorSpace;
  37 import java.awt.color.ICC_ColorSpace;
  38 
  39 /**
  40  * A class containing JPEG-related constants, definitions, and
  41  * static methods.  This class and its constants must be public so that
  42  * <code>JPEGImageWriteParam</code> can see it.
  43  */
  44 public class JPEG {
  45 
  46     // List of all the JPEG markers (pre-JPEG2000)
  47 
  48     /** For temporary use in arithmetic coding */
  49     public static final int TEM = 0x01;
  50 
  51     // Codes 0x02 - 0xBF are reserved
  52 
  53     // SOF markers for Nondifferential Huffman coding
  54     /** Baseline DCT */
  55     public static final int SOF0 = 0xC0;
  56     /** Extended Sequential DCT */
  57     public static final int SOF1 = 0xC1;
  58     /** Progressive DCT */
  59     public static final int SOF2 = 0xC2;
  60     /** Lossless Sequential */
  61     public static final int SOF3 = 0xC3;
  62 
  63     /** Define Huffman Tables */
  64     public static final int DHT = 0xC4;
  65 
  66     // SOF markers for Differential Huffman coding
  67     /** Differential Sequential DCT */
  68     public static final int SOF5 = 0xC5;
  69     /** Differential Progressive DCT */
  70     public static final int SOF6 = 0xC6;
  71     /** Differential Lossless */
  72     public static final int SOF7 = 0xC7;
  73 
  74     /** Reserved for JPEG extensions */
  75     public static final int JPG = 0xC8;
  76 
  77     // SOF markers for Nondifferential arithmetic coding
  78     /** Extended Sequential DCT, Arithmetic coding */
  79     public static final int SOF9 = 0xC9;
  80     /** Progressive DCT, Arithmetic coding */
  81     public static final int SOF10 = 0xCA;
  82     /** Lossless Sequential, Arithmetic coding */
  83     public static final int SOF11 = 0xCB;
  84 
  85     /** Define Arithmetic conditioning tables */
  86     public static final int DAC = 0xCC;
  87 
  88     // SOF markers for Differential arithmetic coding
  89     /** Differential Sequential DCT, Arithmetic coding */
  90     public static final int SOF13 = 0xCD;
  91     /** Differential Progressive DCT, Arithmetic coding */
  92     public static final int SOF14 = 0xCE;
  93     /** Differential Lossless, Arithmetic coding */
  94     public static final int SOF15 = 0xCF;
  95 
  96     // Restart Markers
  97     public static final int RST0 = 0xD0;
  98     public static final int RST1 = 0xD1;
  99     public static final int RST2 = 0xD2;
 100     public static final int RST3 = 0xD3;
 101     public static final int RST4 = 0xD4;
 102     public static final int RST5 = 0xD5;
 103     public static final int RST6 = 0xD6;
 104     public static final int RST7 = 0xD7;
 105     /** Number of restart markers */
 106     public static final int RESTART_RANGE = 8;
 107 
 108     /** Start of Image */
 109     public static final int SOI = 0xD8;
 110     /** End of Image */
 111     public static final int EOI = 0xD9;
 112     /** Start of Scan */
 113     public static final int SOS = 0xDA;
 114 
 115     /** Define Quantisation Tables */
 116     public static final int DQT = 0xDB;
 117 
 118     /** Define Number of lines */
 119     public static final int DNL = 0xDC;
 120 
 121     /** Define Restart Interval */
 122     public static final int DRI = 0xDD;
 123 
 124     /** Define Heirarchical progression */
 125     public static final int DHP = 0xDE;
 126 
 127     /** Expand reference image(s) */
 128     public static final int EXP = 0xDF;
 129 
 130     // Application markers
 131     /** APP0 used by JFIF */
 132     public static final int APP0 = 0xE0;
 133     public static final int APP1 = 0xE1;
 134     public static final int APP2 = 0xE2;
 135     public static final int APP3 = 0xE3;
 136     public static final int APP4 = 0xE4;
 137     public static final int APP5 = 0xE5;
 138     public static final int APP6 = 0xE6;
 139     public static final int APP7 = 0xE7;
 140     public static final int APP8 = 0xE8;
 141     public static final int APP9 = 0xE9;
 142     public static final int APP10 = 0xEA;
 143     public static final int APP11 = 0xEB;
 144     public static final int APP12 = 0xEC;
 145     public static final int APP13 = 0xED;
 146     /** APP14 used by Adobe */
 147     public static final int APP14 = 0xEE;
 148     public static final int APP15 = 0xEF;
 149 
 150     // codes 0xF0 to 0xFD are reserved
 151 
 152     /** Comment marker */
 153     public static final int COM = 0xFE;
 154 
 155     // JFIF Resolution units
 156     /** The X and Y units simply indicate the aspect ratio of the pixels. */
 157     public static final int DENSITY_UNIT_ASPECT_RATIO = 0;
 158     /** Pixel density is in pixels per inch. */
 159     public static final int DENSITY_UNIT_DOTS_INCH    = 1;
 160     /** Pixel density is in pixels per centemeter. */
 161     public static final int DENSITY_UNIT_DOTS_CM      = 2;
 162     /** The max known value for DENSITY_UNIT */
 163     public static final int NUM_DENSITY_UNIT = 3;
 164 
 165     // Adobe transform values
 166     public static final int ADOBE_IMPOSSIBLE = -1;
 167     public static final int ADOBE_UNKNOWN = 0;
 168     public static final int ADOBE_YCC = 1;
 169     public static final int ADOBE_YCCK = 2;
 170 
 171     // Spi initialization stuff
 172     public static final String vendor = "Oracle Corporation";
 173     public static final String version = "0.5";
 174     // Names of the formats we can read or write
 175     public static final String [] names = {"JPEG", "jpeg", "JPG", "jpg"};
 176     public static final String [] suffixes = {"jpg", "jpeg"};
 177     public static final String [] MIMETypes = {"image/jpeg"};
 178     public static final String nativeImageMetadataFormatName =
 179         "javax_imageio_jpeg_image_1.0";
 180     public static final String nativeImageMetadataFormatClassName =
 181         "com.sun.imageio.plugins.jpeg.JPEGImageMetadataFormat";
 182     public static final String nativeStreamMetadataFormatName =
 183         "javax_imageio_jpeg_stream_1.0";
 184     public static final String nativeStreamMetadataFormatClassName =
 185         "com.sun.imageio.plugins.jpeg.JPEGStreamMetadataFormat";
 186 
 187     // IJG Color codes.
 188     public static final int JCS_UNKNOWN = 0;       // error/unspecified
 189     public static final int JCS_GRAYSCALE = 1;     // monochrome
 190     public static final int JCS_RGB = 2;           // red/green/blue
 191     public static final int JCS_YCbCr = 3;         // Y/Cb/Cr (also known as YUV)
 192     public static final int JCS_CMYK = 4;          // C/M/Y/K
 193     public static final int JCS_YCC = 5;           // PhotoYCC
 194     public static final int JCS_RGBA = 6;          // RGB-Alpha
 195     public static final int JCS_YCbCrA = 7;        // Y/Cb/Cr/Alpha
 196     // 8 and 9 were old "Legacy" codes which the old code never identified
 197     // on reading anyway.  Support for writing them is being dropped, too.
 198     public static final int JCS_YCCA = 10;         // PhotoYCC-Alpha
 199     public static final int JCS_YCCK = 11;         // Y/Cb/Cr/K
 200 
 201     public static final int NUM_JCS_CODES = JCS_YCCK+1;
 202 
 203     /** IJG can handle up to 4-channel JPEGs */
 204     public static final int [] [] bandOffsets = {{0},
 205                                           {0, 1},
 206                                           {0, 1, 2},
 207                                           {0, 1, 2, 3}};
 208 
 209     public static final int [] bOffsRGB = { 2, 1, 0 };
 210 
 211     /* These are kept in the inner class to avoid static initialization
 212      * of the CMM class until someone actually needs it.
 213      * (e.g. do not init CMM on the request for jpeg mime types)
 214      */
 215     public static class JCS {
 216         public static final ColorSpace sRGB =
 217             ColorSpace.getInstance(ColorSpace.CS_sRGB);
 218 
 219         private static ColorSpace YCC = null;
 220         private static boolean yccInited = false;
 221 
 222         public static ColorSpace getYCC() {
 223             if (!yccInited) {
 224                 try {
 225                     YCC = ColorSpace.getInstance(ColorSpace.CS_PYCC);
 226                 } catch (IllegalArgumentException e) {
 227                     // PYCC.pf may not always be installed
 228                 } finally {
 229                     yccInited = true;
 230                 }
 231             }
 232             return YCC;
 233         }
 234     }
 235 
 236     // Default value for ImageWriteParam
 237     public static final float DEFAULT_QUALITY = 0.75F;
 238 
 239     /**
 240      * Returns <code>true</code> if the given <code>ColorSpace</code>
 241      * object is an instance of ICC_ColorSpace but is not one of the
 242      * standard <code>ColorSpaces</code> returned by
 243      * <code>ColorSpace.getInstance()</code>.
 244      */
 245     static boolean isNonStandardICC(ColorSpace cs) {
 246         boolean retval = false;
 247         if ((cs instanceof ICC_ColorSpace)
 248             && (!cs.isCS_sRGB())
 249             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ)))
 250             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_GRAY)))
 251             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB)))
 252             && (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_PYCC)))
 253             ) {
 254             retval = true;
 255         }
 256         return retval;
 257     }
 258 
 259 
 260     /**
 261      * Returns <code>true</code> if the given imageType can be used
 262      * in a JFIF file.  If <code>input</code> is true, then the
 263      * image type is considered before colorspace conversion.
 264      */
 265     static boolean isJFIFcompliant(ImageTypeSpecifier imageType,
 266                                    boolean input) {
 267         ColorModel cm = imageType.getColorModel();
 268         // Can't have alpha
 269         if (cm.hasAlpha()) {
 270             return false;
 271         }
 272         // Gray is OK, always
 273         int numComponents = imageType.getNumComponents();
 274         if (numComponents == 1) {
 275             return true;
 276         }
 277 
 278         // If it isn't gray, it must have 3 channels
 279         if (numComponents != 3) {
 280             return false;
 281         }
 282 
 283         if (input) {
 284             // Must be RGB
 285             if (cm.getColorSpace().getType() == ColorSpace.TYPE_RGB) {
 286                 return true;
 287             }
 288         } else {
 289             // Must be YCbCr
 290             if (cm.getColorSpace().getType() == ColorSpace.TYPE_YCbCr) {
 291                 return true;
 292             }
 293         }
 294 
 295         return false;
 296     }
 297 
 298     /**
 299      * Given an image type, return the Adobe transform corresponding to
 300      * that type, or ADOBE_IMPOSSIBLE if the image type is incompatible
 301      * with an Adobe marker segment.  If <code>input</code> is true, then
 302      * the image type is considered before colorspace conversion.
 303      */
 304     static int transformForType(ImageTypeSpecifier imageType, boolean input) {
 305         int retval = ADOBE_IMPOSSIBLE;
 306         ColorModel cm = imageType.getColorModel();
 307         switch (cm.getColorSpace().getType()) {
 308         case ColorSpace.TYPE_GRAY:
 309             retval = ADOBE_UNKNOWN;
 310             break;
 311         case ColorSpace.TYPE_RGB:
 312             retval = input ? ADOBE_YCC : ADOBE_UNKNOWN;
 313             break;
 314         case ColorSpace.TYPE_YCbCr:
 315             retval = ADOBE_YCC;
 316             break;
 317         case ColorSpace.TYPE_CMYK:
 318             retval = input ? ADOBE_YCCK : ADOBE_IMPOSSIBLE;
 319         }
 320         return retval;
 321     }
 322 
 323     /**
 324      * Converts an ImageWriteParam (i.e. IJG) non-linear quality value
 325      * to a float suitable for passing to JPEGQTable.getScaledInstance().
 326      */
 327     static float convertToLinearQuality(float quality) {
 328         // The following is converted from the IJG code.
 329         if (quality <= 0.0F) {
 330             quality = 0.01F;
 331         }
 332 
 333         if (quality > 1.00F) {
 334             quality = 1.00F;
 335         }
 336 
 337         if (quality < 0.5F) {
 338             quality = 0.5F / quality;
 339         } else {
 340             quality = 2.0F - (quality * 2.0F);
 341         }
 342 
 343         return quality;
 344     }
 345 
 346     /**
 347      * Return an array of default, visually lossless quantization tables.
 348      */
 349     static JPEGQTable [] getDefaultQTables() {
 350         JPEGQTable [] qTables = new JPEGQTable[2];
 351         qTables[0] = JPEGQTable.K1Div2Luminance;
 352         qTables[1] = JPEGQTable.K2Div2Chrominance;
 353         return qTables;
 354     }
 355 
 356     /**
 357      * Return an array of default Huffman tables.
 358      */
 359     static JPEGHuffmanTable [] getDefaultHuffmanTables(boolean wantDC) {
 360         JPEGHuffmanTable [] tables = new JPEGHuffmanTable[2];
 361         if (wantDC) {
 362             tables[0] = JPEGHuffmanTable.StdDCLuminance;
 363             tables[1] = JPEGHuffmanTable.StdDCChrominance;
 364         } else {
 365             tables[0] = JPEGHuffmanTable.StdACLuminance;
 366             tables[1] = JPEGHuffmanTable.StdACChrominance;
 367         }
 368         return tables;
 369     }
 370 
 371 }
--- EOF ---