Back to index...

	/*
	* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.imageio.plugins.jpeg;

	import javax.imageio.ImageTypeSpecifier;
	import javax.imageio.plugins.jpeg.JPEGQTable;
	import javax.imageio.plugins.jpeg.JPEGHuffmanTable;

	import java.awt.image.ColorModel;
	import java.awt.color.ColorSpace;
	import java.awt.color.ICC_ColorSpace;

	/**
	* A class containing JPEG-related constants, definitions, and
	* static methods. This class and its constants must be public so that
	* <code>JPEGImageWriteParam</code> can see it.
	*/
	public class JPEG {

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

	/** For temporary use in arithmetic coding */
	public static final int TEM = 0x01;

	// Codes 0x02 - 0xBF are reserved

	// SOF markers for Nondifferential Huffman coding
	/** Baseline DCT */
	public static final int SOF0 = 0xC0;
	/** Extended Sequential DCT */
	public static final int SOF1 = 0xC1;
	/** Progressive DCT */
	public static final int SOF2 = 0xC2;
	/** Lossless Sequential */
	public static final int SOF3 = 0xC3;

	/** Define Huffman Tables */
	public static final int DHT = 0xC4;

	// SOF markers for Differential Huffman coding
	/** Differential Sequential DCT */
	public static final int SOF5 = 0xC5;
	/** Differential Progressive DCT */
	public static final int SOF6 = 0xC6;
	/** Differential Lossless */
	public static final int SOF7 = 0xC7;

	/** Reserved for JPEG extensions */
	public static final int JPG = 0xC8;

	// SOF markers for Nondifferential arithmetic coding
	/** Extended Sequential DCT, Arithmetic coding */
	public static final int SOF9 = 0xC9;
	/** Progressive DCT, Arithmetic coding */
	public static final int SOF10 = 0xCA;
	/** Lossless Sequential, Arithmetic coding */
	public static final int SOF11 = 0xCB;

	/** Define Arithmetic conditioning tables */
	public static final int DAC = 0xCC;

	// SOF markers for Differential arithmetic coding
	/** Differential Sequential DCT, Arithmetic coding */
	public static final int SOF13 = 0xCD;
	/** Differential Progressive DCT, Arithmetic coding */
	public static final int SOF14 = 0xCE;
	/** Differential Lossless, Arithmetic coding */
	public static final int SOF15 = 0xCF;

	// Restart Markers
	public static final int RST0 = 0xD0;
	public static final int RST1 = 0xD1;
	public static final int RST2 = 0xD2;
	public static final int RST3 = 0xD3;
	public static final int RST4 = 0xD4;
	public static final int RST5 = 0xD5;
	public static final int RST6 = 0xD6;
	public static final int RST7 = 0xD7;
	/** Number of restart markers */
	public static final int RESTART_RANGE = 8;

	/** Start of Image */
	public static final int SOI = 0xD8;
	/** End of Image */
	public static final int EOI = 0xD9;
	/** Start of Scan */
	public static final int SOS = 0xDA;

	/** Define Quantisation Tables */
	public static final int DQT = 0xDB;

	/** Define Number of lines */
	public static final int DNL = 0xDC;

	/** Define Restart Interval */
	public static final int DRI = 0xDD;

	/** Define Heirarchical progression */
	public static final int DHP = 0xDE;

	/** Expand reference image(s) */
	public static final int EXP = 0xDF;

	// Application markers
	/** APP0 used by JFIF */
	public static final int APP0 = 0xE0;
	public static final int APP1 = 0xE1;
	public static final int APP2 = 0xE2;
	public static final int APP3 = 0xE3;
	public static final int APP4 = 0xE4;
	public static final int APP5 = 0xE5;
	public static final int APP6 = 0xE6;
	public static final int APP7 = 0xE7;
	public static final int APP8 = 0xE8;
	public static final int APP9 = 0xE9;
	public static final int APP10 = 0xEA;
	public static final int APP11 = 0xEB;
	public static final int APP12 = 0xEC;
	public static final int APP13 = 0xED;
	/** APP14 used by Adobe */
	public static final int APP14 = 0xEE;
	public static final int APP15 = 0xEF;

	// codes 0xF0 to 0xFD are reserved

	/** Comment marker */
	public static final int COM = 0xFE;

	// JFIF Resolution units
	/** The X and Y units simply indicate the aspect ratio of the pixels. */
	public static final int DENSITY_UNIT_ASPECT_RATIO = 0;
	/** Pixel density is in pixels per inch. */
	public static final int DENSITY_UNIT_DOTS_INCH = 1;
	/** Pixel density is in pixels per centemeter. */
	public static final int DENSITY_UNIT_DOTS_CM = 2;
	/** The max known value for DENSITY_UNIT */
	public static final int NUM_DENSITY_UNIT = 3;

	// Adobe transform values
	public static final int ADOBE_IMPOSSIBLE = -1;
	public static final int ADOBE_UNKNOWN = 0;
	public static final int ADOBE_YCC = 1;
	public static final int ADOBE_YCCK = 2;

	// Spi initialization stuff
	public static final String vendor = "Oracle Corporation";
	public static final String version = "0.5";
	// Names of the formats we can read or write
	static final String [] names = {"JPEG", "jpeg", "JPG", "jpg"};
	static final String [] suffixes = {"jpg", "jpeg"};
	static final String [] MIMETypes = {"image/jpeg"};
	public static final String nativeImageMetadataFormatName =
	"javax_imageio_jpeg_image_1.0";
	public static final String nativeImageMetadataFormatClassName =
	"com.sun.imageio.plugins.jpeg.JPEGImageMetadataFormat";
	public static final String nativeStreamMetadataFormatName =
	"javax_imageio_jpeg_stream_1.0";
	public static final String nativeStreamMetadataFormatClassName =
	"com.sun.imageio.plugins.jpeg.JPEGStreamMetadataFormat";

	// IJG Color codes.
	public static final int JCS_UNKNOWN = 0; // error/unspecified
	public static final int JCS_GRAYSCALE = 1; // monochrome
	public static final int JCS_RGB = 2; // red/green/blue
	public static final int JCS_YCbCr = 3; // Y/Cb/Cr (also known as YUV)
	public static final int JCS_CMYK = 4; // C/M/Y/K
	public static final int JCS_YCC = 5; // PhotoYCC
	public static final int JCS_RGBA = 6; // RGB-Alpha
	public static final int JCS_YCbCrA = 7; // Y/Cb/Cr/Alpha
	// 8 and 9 were old "Legacy" codes which the old code never identified
	// on reading anyway. Support for writing them is being dropped, too.
	public static final int JCS_YCCA = 10; // PhotoYCC-Alpha
	public static final int JCS_YCCK = 11; // Y/Cb/Cr/K

	public static final int NUM_JCS_CODES = JCS_YCCK+1;

	/** IJG can handle up to 4-channel JPEGs */
	static final int [] [] bandOffsets = {{0},
	{0, 1},
	{0, 1, 2},
	{0, 1, 2, 3}};

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

	/* These are kept in the inner class to avoid static initialization
	* of the CMM class until someone actually needs it.
	* (e.g. do not init CMM on the request for jpeg mime types)
	*/
	public static class JCS {
	public static final ColorSpace sRGB =
	ColorSpace.getInstance(ColorSpace.CS_sRGB);

	private static ColorSpace YCC = null;
	private static boolean yccInited = false;

	public static ColorSpace getYCC() {
	if (!yccInited) {
	try {
	YCC = ColorSpace.getInstance(ColorSpace.CS_PYCC);
	} catch (IllegalArgumentException e) {
	// PYCC.pf may not always be installed
	} finally {
	yccInited = true;
	}
	}
	return YCC;
	}
	}

	// Default value for ImageWriteParam
	public static final float DEFAULT_QUALITY = 0.75F;

	/**
	* Returns <code>true</code> if the given <code>ColorSpace</code>
	* object is an instance of ICC_ColorSpace but is not one of the
	* standard <code>ColorSpaces</code> returned by
	* <code>ColorSpace.getInstance()</code>.
	*/
	static boolean isNonStandardICC(ColorSpace cs) {
	boolean retval = false;
	if ((cs instanceof ICC_ColorSpace)
	&& (!cs.isCS_sRGB())
	&& (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_CIEXYZ)))
	&& (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_GRAY)))
	&& (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB)))
	&& (!cs.equals(ColorSpace.getInstance(ColorSpace.CS_PYCC)))
	) {
	retval = true;
	}
	return retval;
	}


	/**
	* Returns <code>true</code> if the given imageType can be used
	* in a JFIF file. If <code>input</code> is true, then the
	* image type is considered before colorspace conversion.
	*/
	static boolean isJFIFcompliant(ImageTypeSpecifier imageType,
	boolean input) {
	ColorModel cm = imageType.getColorModel();
	// Can't have alpha
	if (cm.hasAlpha()) {
	return false;
	}
	// Gray is OK, always
	int numComponents = imageType.getNumComponents();
	if (numComponents == 1) {
	return true;
	}

	// If it isn't gray, it must have 3 channels
	if (numComponents != 3) {
	return false;
	}

	if (input) {
	// Must be RGB
	if (cm.getColorSpace().getType() == ColorSpace.TYPE_RGB) {
	return true;
	}
	} else {
	// Must be YCbCr
	if (cm.getColorSpace().getType() == ColorSpace.TYPE_YCbCr) {
	return true;
	}
	}

	return false;
	}

	/**
	* Given an image type, return the Adobe transform corresponding to
	* that type, or ADOBE_IMPOSSIBLE if the image type is incompatible
	* with an Adobe marker segment. If <code>input</code> is true, then
	* the image type is considered before colorspace conversion.
	*/
	static int transformForType(ImageTypeSpecifier imageType, boolean input) {
	int retval = ADOBE_IMPOSSIBLE;
	ColorModel cm = imageType.getColorModel();
	switch (cm.getColorSpace().getType()) {
	case ColorSpace.TYPE_GRAY:
	retval = ADOBE_UNKNOWN;
	break;
	case ColorSpace.TYPE_RGB:
	retval = input ? ADOBE_YCC : ADOBE_UNKNOWN;
	break;
	case ColorSpace.TYPE_YCbCr:
	retval = ADOBE_YCC;
	break;
	case ColorSpace.TYPE_CMYK:
	retval = input ? ADOBE_YCCK : ADOBE_IMPOSSIBLE;
	}
	return retval;
	}

	/**
	* Converts an ImageWriteParam (i.e. IJG) non-linear quality value
	* to a float suitable for passing to JPEGQTable.getScaledInstance().
	*/
	static float convertToLinearQuality(float quality) {
	// The following is converted from the IJG code.
	if (quality <= 0.0F) {
	quality = 0.01F;
	}

	if (quality > 1.00F) {
	quality = 1.00F;
	}

	if (quality < 0.5F) {
	quality = 0.5F / quality;
	} else {
	quality = 2.0F - (quality * 2.0F);
	}

	return quality;
	}

	/**
	* Return an array of default, visually lossless quantization tables.
	*/
	static JPEGQTable [] getDefaultQTables() {
	JPEGQTable [] qTables = new JPEGQTable[2];
	qTables[0] = JPEGQTable.K1Div2Luminance;
	qTables[1] = JPEGQTable.K2Div2Chrominance;
	return qTables;
	}

	/**
	* Return an array of default Huffman tables.
	*/
	static JPEGHuffmanTable [] getDefaultHuffmanTables(boolean wantDC) {
	JPEGHuffmanTable [] tables = new JPEGHuffmanTable[2];
	if (wantDC) {
	tables[0] = JPEGHuffmanTable.StdDCLuminance;
	tables[1] = JPEGHuffmanTable.StdDCChrominance;
	} else {
	tables[0] = JPEGHuffmanTable.StdACLuminance;
	tables[1] = JPEGHuffmanTable.StdACChrominance;
	}
	return tables;
	}

	}

Back to index...