Back to index...

	/*
	* Copyright (c) 2001, 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.IIOException;
	import javax.imageio.IIOImage;
	import javax.imageio.ImageTypeSpecifier;
	import javax.imageio.ImageReader;
	import javax.imageio.metadata.IIOInvalidTreeException;
	import javax.imageio.metadata.IIOMetadataNode;
	import javax.imageio.metadata.IIOMetadata;
	import javax.imageio.stream.ImageInputStream;
	import javax.imageio.stream.ImageOutputStream;
	import javax.imageio.stream.MemoryCacheImageOutputStream;
	import javax.imageio.event.IIOReadProgressListener;

	import java.awt.Graphics;
	import java.awt.color.ICC_Profile;
	import java.awt.color.ICC_ColorSpace;
	import java.awt.color.ColorSpace;
	import java.awt.image.ColorModel;
	import java.awt.image.SampleModel;
	import java.awt.image.IndexColorModel;
	import java.awt.image.ComponentColorModel;
	import java.awt.image.BufferedImage;
	import java.awt.image.DataBuffer;
	import java.awt.image.DataBufferByte;
	import java.awt.image.Raster;
	import java.awt.image.WritableRaster;
	import java.io.IOException;
	import java.io.ByteArrayOutputStream;
	import java.util.List;
	import java.util.ArrayList;
	import java.util.Iterator;

	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;
	import org.w3c.dom.NamedNodeMap;

	/**
	* A JFIF (JPEG File Interchange Format) APP0 (Application-Specific)
	* marker segment. Inner classes are included for JFXX extension
	* marker segments, for different varieties of thumbnails, and for
	* ICC Profile APP2 marker segments. Any of these secondary types
	* that occur are kept as members of a single JFIFMarkerSegment object.
	*/
	class JFIFMarkerSegment extends MarkerSegment {
	int majorVersion;
	int minorVersion;
	int resUnits;
	int Xdensity;
	int Ydensity;
	int thumbWidth;
	int thumbHeight;
	JFIFThumbRGB thumb = null; // If present
	ArrayList extSegments = new ArrayList();
	ICCMarkerSegment iccSegment = null; // optional ICC
	private static final int THUMB_JPEG = 0x10;
	private static final int THUMB_PALETTE = 0x11;
	private static final int THUMB_UNASSIGNED = 0x12;
	private static final int THUMB_RGB = 0x13;
	private static final int DATA_SIZE = 14;
	private static final int ID_SIZE = 5;
	private final int MAX_THUMB_WIDTH = 255;
	private final int MAX_THUMB_HEIGHT = 255;

	private final boolean debug = false;

	/**
	* Set to <code>true</code> when reading the chunks of an
	* ICC profile. All chunks are consolidated to create a single
	* "segment" containing all the chunks. This flag is a state
	* variable identifying whether to construct a new segment or
	* append to an old one.
	*/
	private boolean inICC = false;

	/**
	* A placeholder for an ICC profile marker segment under
	* construction. The segment is not added to the list
	* until all chunks have been read.
	*/
	private ICCMarkerSegment tempICCSegment = null;


	/**
	* Default constructor. Used to create a default JFIF header
	*/
	JFIFMarkerSegment() {
	super(JPEG.APP0);
	majorVersion = 1;
	minorVersion = 2;
	resUnits = JPEG.DENSITY_UNIT_ASPECT_RATIO;
	Xdensity = 1;
	Ydensity = 1;
	thumbWidth = 0;
	thumbHeight = 0;
	}

	/**
	* Constructs a JFIF header by reading from a stream wrapped
	* in a JPEGBuffer.
	*/
	JFIFMarkerSegment(JPEGBuffer buffer) throws IOException {
	super(buffer);
	buffer.bufPtr += ID_SIZE; // skip the id, we already checked it

	majorVersion = buffer.buf[buffer.bufPtr++];
	minorVersion = buffer.buf[buffer.bufPtr++];
	resUnits = buffer.buf[buffer.bufPtr++];
	Xdensity = (buffer.buf[buffer.bufPtr++] & 0xff) << 8;
	Xdensity \|= buffer.buf[buffer.bufPtr++] & 0xff;
	Ydensity = (buffer.buf[buffer.bufPtr++] & 0xff) << 8;
	Ydensity \|= buffer.buf[buffer.bufPtr++] & 0xff;
	thumbWidth = buffer.buf[buffer.bufPtr++] & 0xff;
	thumbHeight = buffer.buf[buffer.bufPtr++] & 0xff;
	buffer.bufAvail -= DATA_SIZE;
	if (thumbWidth > 0) {
	thumb = new JFIFThumbRGB(buffer, thumbWidth, thumbHeight);
	}
	}

	/**
	* Constructs a JFIF header from a DOM Node.
	*/
	JFIFMarkerSegment(Node node) throws IIOInvalidTreeException {
	this();
	updateFromNativeNode(node, true);
	}

	/**
	* Returns a deep-copy clone of this object.
	*/
	protected Object clone() {
	JFIFMarkerSegment newGuy = (JFIFMarkerSegment) super.clone();
	if (!extSegments.isEmpty()) { // Clone the list with a deep copy
	newGuy.extSegments = new ArrayList();
	for (Iterator iter = extSegments.iterator(); iter.hasNext();) {
	JFIFExtensionMarkerSegment jfxx =
	(JFIFExtensionMarkerSegment) iter.next();
	newGuy.extSegments.add(jfxx.clone());
	}
	}
	if (iccSegment != null) {
	newGuy.iccSegment = (ICCMarkerSegment) iccSegment.clone();
	}
	return newGuy;
	}

	/**
	* Add an JFXX extension marker segment from the stream wrapped
	* in the JPEGBuffer to the list of extension segments.
	*/
	void addJFXX(JPEGBuffer buffer, JPEGImageReader reader)
	throws IOException {
	extSegments.add(new JFIFExtensionMarkerSegment(buffer, reader));
	}

	/**
	* Adds an ICC Profile APP2 segment from the stream wrapped
	* in the JPEGBuffer.
	*/
	void addICC(JPEGBuffer buffer) throws IOException {
	if (inICC == false) {
	if (iccSegment != null) {
	throw new IIOException
	("> 1 ICC APP2 Marker Segment not supported");
	}
	tempICCSegment = new ICCMarkerSegment(buffer);
	if (inICC == false) { // Just one chunk
	iccSegment = tempICCSegment;
	tempICCSegment = null;
	}
	} else {
	if (tempICCSegment.addData(buffer) == true) {
	iccSegment = tempICCSegment;
	tempICCSegment = null;
	}
	}
	}

	/**
	* Add an ICC Profile APP2 segment by constructing it from
	* the given ICC_ColorSpace object.
	*/
	void addICC(ICC_ColorSpace cs) throws IOException {
	if (iccSegment != null) {
	throw new IIOException
	("> 1 ICC APP2 Marker Segment not supported");
	}
	iccSegment = new ICCMarkerSegment(cs);
	}

	/**
	* Returns a tree of DOM nodes representing this object and any
	* subordinate JFXX extension or ICC Profile segments.
	*/
	IIOMetadataNode getNativeNode() {
	IIOMetadataNode node = new IIOMetadataNode("app0JFIF");
	node.setAttribute("majorVersion", Integer.toString(majorVersion));
	node.setAttribute("minorVersion", Integer.toString(minorVersion));
	node.setAttribute("resUnits", Integer.toString(resUnits));
	node.setAttribute("Xdensity", Integer.toString(Xdensity));
	node.setAttribute("Ydensity", Integer.toString(Ydensity));
	node.setAttribute("thumbWidth", Integer.toString(thumbWidth));
	node.setAttribute("thumbHeight", Integer.toString(thumbHeight));
	if (!extSegments.isEmpty()) {
	IIOMetadataNode JFXXnode = new IIOMetadataNode("JFXX");
	node.appendChild(JFXXnode);
	for (Iterator iter = extSegments.iterator(); iter.hasNext();) {
	JFIFExtensionMarkerSegment seg =
	(JFIFExtensionMarkerSegment) iter.next();
	JFXXnode.appendChild(seg.getNativeNode());
	}
	}
	if (iccSegment != null) {
	node.appendChild(iccSegment.getNativeNode());
	}

	return node;
	}

	/**
	* Updates the data in this object from the given DOM Node tree.
	* If fromScratch is true, this object is being constructed.
	* Otherwise an existing object is being modified.
	* Throws an IIOInvalidTreeException if the tree is invalid in
	* any way.
	*/
	void updateFromNativeNode(Node node, boolean fromScratch)
	throws IIOInvalidTreeException {
	// none of the attributes are required
	NamedNodeMap attrs = node.getAttributes();
	if (attrs.getLength() > 0) {
	int value = getAttributeValue(node, attrs, "majorVersion",
	0, 255, false);
	majorVersion = (value != -1) ? value : majorVersion;
	value = getAttributeValue(node, attrs, "minorVersion",
	0, 255, false);
	minorVersion = (value != -1) ? value : minorVersion;
	value = getAttributeValue(node, attrs, "resUnits", 0, 2, false);
	resUnits = (value != -1) ? value : resUnits;
	value = getAttributeValue(node, attrs, "Xdensity", 1, 65535, false);
	Xdensity = (value != -1) ? value : Xdensity;
	value = getAttributeValue(node, attrs, "Ydensity", 1, 65535, false);
	Ydensity = (value != -1) ? value : Ydensity;
	value = getAttributeValue(node, attrs, "thumbWidth", 0, 255, false);
	thumbWidth = (value != -1) ? value : thumbWidth;
	value = getAttributeValue(node, attrs, "thumbHeight", 0, 255, false);
	thumbHeight = (value != -1) ? value : thumbHeight;
	}
	if (node.hasChildNodes()) {
	NodeList children = node.getChildNodes();
	int count = children.getLength();
	if (count > 2) {
	throw new IIOInvalidTreeException
	("app0JFIF node cannot have > 2 children", node);
	}
	for (int i = 0; i < count; i++) {
	Node child = children.item(i);
	String name = child.getNodeName();
	if (name.equals("JFXX")) {
	if ((!extSegments.isEmpty()) && fromScratch) {
	throw new IIOInvalidTreeException
	("app0JFIF node cannot have > 1 JFXX node", node);
	}
	NodeList exts = child.getChildNodes();
	int extCount = exts.getLength();
	for (int j = 0; j < extCount; j++) {
	Node ext = exts.item(j);
	extSegments.add(new JFIFExtensionMarkerSegment(ext));
	}
	}
	if (name.equals("app2ICC")) {
	if ((iccSegment != null) && fromScratch) {
	throw new IIOInvalidTreeException
	("> 1 ICC APP2 Marker Segment not supported", node);
	}
	iccSegment = new ICCMarkerSegment(child);
	}
	}
	}
	}

	int getThumbnailWidth(int index) {
	if (thumb != null) {
	if (index == 0) {
	return thumb.getWidth();
	}
	index--;
	}
	JFIFExtensionMarkerSegment jfxx =
	(JFIFExtensionMarkerSegment) extSegments.get(index);
	return jfxx.thumb.getWidth();
	}

	int getThumbnailHeight(int index) {
	if (thumb != null) {
	if (index == 0) {
	return thumb.getHeight();
	}
	index--;
	}
	JFIFExtensionMarkerSegment jfxx =
	(JFIFExtensionMarkerSegment) extSegments.get(index);
	return jfxx.thumb.getHeight();
	}

	BufferedImage getThumbnail(ImageInputStream iis,
	int index,
	JPEGImageReader reader) throws IOException {
	reader.thumbnailStarted(index);
	BufferedImage ret = null;
	if ((thumb != null) && (index == 0)) {
	ret = thumb.getThumbnail(iis, reader);
	} else {
	if (thumb != null) {
	index--;
	}
	JFIFExtensionMarkerSegment jfxx =
	(JFIFExtensionMarkerSegment) extSegments.get(index);
	ret = jfxx.thumb.getThumbnail(iis, reader);
	}
	reader.thumbnailComplete();
	return ret;
	}


	/**
	* Writes the data for this segment to the stream in
	* valid JPEG format. Assumes that there will be no thumbnail.
	*/
	void write(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	// No thumbnail
	write(ios, null, writer);
	}

	/**
	* Writes the data for this segment to the stream in
	* valid JPEG format. The length written takes the thumbnail
	* width and height into account. If necessary, the thumbnail
	* is clipped to 255 x 255 and a warning is sent to the writer
	* argument. Progress updates are sent to the writer argument.
	*/
	void write(ImageOutputStream ios,
	BufferedImage thumb,
	JPEGImageWriter writer) throws IOException {
	int thumbWidth = 0;
	int thumbHeight = 0;
	int thumbLength = 0;
	int [] thumbData = null;
	if (thumb != null) {
	// Clip if necessary and get the data in thumbData
	thumbWidth = thumb.getWidth();
	thumbHeight = thumb.getHeight();
	if ((thumbWidth > MAX_THUMB_WIDTH)
	\|\| (thumbHeight > MAX_THUMB_HEIGHT)) {
	writer.warningOccurred(JPEGImageWriter.WARNING_THUMB_CLIPPED);
	}
	thumbWidth = Math.min(thumbWidth, MAX_THUMB_WIDTH);
	thumbHeight = Math.min(thumbHeight, MAX_THUMB_HEIGHT);
	thumbData = thumb.getRaster().getPixels(0, 0,
	thumbWidth, thumbHeight,
	(int []) null);
	thumbLength = thumbData.length;
	}
	length = DATA_SIZE + LENGTH_SIZE + thumbLength;
	writeTag(ios);
	byte [] id = {0x4A, 0x46, 0x49, 0x46, 0x00};
	ios.write(id);
	ios.write(majorVersion);
	ios.write(minorVersion);
	ios.write(resUnits);
	write2bytes(ios, Xdensity);
	write2bytes(ios, Ydensity);
	ios.write(thumbWidth);
	ios.write(thumbHeight);
	if (thumbData != null) {
	writer.thumbnailStarted(0);
	writeThumbnailData(ios, thumbData, writer);
	writer.thumbnailComplete();
	}
	}

	/*
	* Write out the values in the integer array as a sequence of bytes,
	* reporting progress to the writer argument.
	*/
	void writeThumbnailData(ImageOutputStream ios,
	int [] thumbData,
	JPEGImageWriter writer) throws IOException {
	int progInterval = thumbData.length / 20; // approx. every 5%
	if (progInterval == 0) {
	progInterval = 1;
	}
	for (int i = 0; i < thumbData.length; i++) {
	ios.write(thumbData[i]);
	if ((i > progInterval) && (i % progInterval == 0)) {
	writer.thumbnailProgress
	(((float) i * 100) / ((float) thumbData.length));
	}
	}
	}

	/**
	* Write out this JFIF Marker Segment, including a thumbnail or
	* appending a series of JFXX Marker Segments, as appropriate.
	* Warnings and progress reports are sent to the writer argument.
	* The list of thumbnails is matched to the list of JFXX extension
	* segments, if any, in order to determine how to encode the
	* thumbnails. If there are more thumbnails than metadata segments,
	* default encoding is used for the extra thumbnails.
	*/
	void writeWithThumbs(ImageOutputStream ios,
	List thumbnails,
	JPEGImageWriter writer) throws IOException {
	if (thumbnails != null) {
	JFIFExtensionMarkerSegment jfxx = null;
	if (thumbnails.size() == 1) {
	if (!extSegments.isEmpty()) {
	jfxx = (JFIFExtensionMarkerSegment) extSegments.get(0);
	}
	writeThumb(ios,
	(BufferedImage) thumbnails.get(0),
	jfxx,
	0,
	true,
	writer);
	} else {
	// All others write as separate JFXX segments
	write(ios, writer); // Just the header without any thumbnail
	for (int i = 0; i < thumbnails.size(); i++) {
	jfxx = null;
	if (i < extSegments.size()) {
	jfxx = (JFIFExtensionMarkerSegment) extSegments.get(i);
	}
	writeThumb(ios,
	(BufferedImage) thumbnails.get(i),
	jfxx,
	i,
	false,
	writer);
	}
	}
	} else { // No thumbnails
	write(ios, writer);
	}

	}

	private void writeThumb(ImageOutputStream ios,
	BufferedImage thumb,
	JFIFExtensionMarkerSegment jfxx,
	int index,
	boolean onlyOne,
	JPEGImageWriter writer) throws IOException {
	ColorModel cm = thumb.getColorModel();
	ColorSpace cs = cm.getColorSpace();

	if (cm instanceof IndexColorModel) {
	// We never write a palette image into the header
	// So if it's the only one, we need to write the header first
	if (onlyOne) {
	write(ios, writer);
	}
	if ((jfxx == null)
	\|\| (jfxx.code == THUMB_PALETTE)) {
	writeJFXXSegment(index, thumb, ios, writer); // default
	} else {
	// Expand to RGB
	BufferedImage thumbRGB =
	((IndexColorModel) cm).convertToIntDiscrete
	(thumb.getRaster(), false);
	jfxx.setThumbnail(thumbRGB);
	writer.thumbnailStarted(index);
	jfxx.write(ios, writer); // Handles clipping if needed
	writer.thumbnailComplete();
	}
	} else if (cs.getType() == ColorSpace.TYPE_RGB) {
	if (jfxx == null) {
	if (onlyOne) {
	write(ios, thumb, writer); // As part of the header
	} else {
	writeJFXXSegment(index, thumb, ios, writer); // default
	}
	} else {
	// If this is the only one, write the header first
	if (onlyOne) {
	write(ios, writer);
	}
	if (jfxx.code == THUMB_PALETTE) {
	writeJFXXSegment(index, thumb, ios, writer); // default
	writer.warningOccurred
	(JPEGImageWriter.WARNING_NO_RGB_THUMB_AS_INDEXED);
	} else {
	jfxx.setThumbnail(thumb);
	writer.thumbnailStarted(index);
	jfxx.write(ios, writer); // Handles clipping if needed
	writer.thumbnailComplete();
	}
	}
	} else if (cs.getType() == ColorSpace.TYPE_GRAY) {
	if (jfxx == null) {
	if (onlyOne) {
	BufferedImage thumbRGB = expandGrayThumb(thumb);
	write(ios, thumbRGB, writer); // As part of the header
	} else {
	writeJFXXSegment(index, thumb, ios, writer); // default
	}
	} else {
	// If this is the only one, write the header first
	if (onlyOne) {
	write(ios, writer);
	}
	if (jfxx.code == THUMB_RGB) {
	BufferedImage thumbRGB = expandGrayThumb(thumb);
	writeJFXXSegment(index, thumbRGB, ios, writer);
	} else if (jfxx.code == THUMB_JPEG) {
	jfxx.setThumbnail(thumb);
	writer.thumbnailStarted(index);
	jfxx.write(ios, writer); // Handles clipping if needed
	writer.thumbnailComplete();
	} else if (jfxx.code == THUMB_PALETTE) {
	writeJFXXSegment(index, thumb, ios, writer); // default
	writer.warningOccurred
	(JPEGImageWriter.WARNING_NO_GRAY_THUMB_AS_INDEXED);
	}
	}
	} else {
	writer.warningOccurred
	(JPEGImageWriter.WARNING_ILLEGAL_THUMBNAIL);
	}
	}

	// Could put reason codes in here to be parsed in writeJFXXSegment
	// in order to provide more meaningful warnings.
	private class IllegalThumbException extends Exception {}

	/**
	* Writes out a new JFXX extension segment, without saving it.
	*/
	private void writeJFXXSegment(int index,
	BufferedImage thumbnail,
	ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	JFIFExtensionMarkerSegment jfxx = null;
	try {
	jfxx = new JFIFExtensionMarkerSegment(thumbnail);
	} catch (IllegalThumbException e) {
	writer.warningOccurred
	(JPEGImageWriter.WARNING_ILLEGAL_THUMBNAIL);
	return;
	}
	writer.thumbnailStarted(index);
	jfxx.write(ios, writer);
	writer.thumbnailComplete();
	}


	/**
	* Return an RGB image that is the expansion of the given grayscale
	* image.
	*/
	private static BufferedImage expandGrayThumb(BufferedImage thumb) {
	BufferedImage ret = new BufferedImage(thumb.getWidth(),
	thumb.getHeight(),
	BufferedImage.TYPE_INT_RGB);
	Graphics g = ret.getGraphics();
	g.drawImage(thumb, 0, 0, null);
	return ret;
	}

	/**
	* Writes out a default JFIF marker segment to the given
	* output stream. If <code>thumbnails</code> is not <code>null</code>,
	* writes out the set of thumbnail images as JFXX marker segments, or
	* incorporated into the JFIF segment if appropriate.
	* If <code>iccProfile</code> is not <code>null</code>,
	* writes out the profile after the JFIF segment using as many APP2
	* marker segments as necessary.
	*/
	static void writeDefaultJFIF(ImageOutputStream ios,
	List thumbnails,
	ICC_Profile iccProfile,
	JPEGImageWriter writer)
	throws IOException {

	JFIFMarkerSegment jfif = new JFIFMarkerSegment();
	jfif.writeWithThumbs(ios, thumbnails, writer);
	if (iccProfile != null) {
	writeICC(iccProfile, ios);
	}
	}

	/**
	* Prints out the contents of this object to System.out for debugging.
	*/
	void print() {
	printTag("JFIF");
	System.out.print("Version ");
	System.out.print(majorVersion);
	System.out.println(".0"
	+ Integer.toString(minorVersion));
	System.out.print("Resolution units: ");
	System.out.println(resUnits);
	System.out.print("X density: ");
	System.out.println(Xdensity);
	System.out.print("Y density: ");
	System.out.println(Ydensity);
	System.out.print("Thumbnail Width: ");
	System.out.println(thumbWidth);
	System.out.print("Thumbnail Height: ");
	System.out.println(thumbHeight);
	if (!extSegments.isEmpty()) {
	for (Iterator iter = extSegments.iterator(); iter.hasNext();) {
	JFIFExtensionMarkerSegment extSegment =
	(JFIFExtensionMarkerSegment) iter.next();
	extSegment.print();
	}
	}
	if (iccSegment != null) {
	iccSegment.print();
	}
	}

	/**
	* A JFIF extension APP0 marker segment.
	*/
	class JFIFExtensionMarkerSegment extends MarkerSegment {
	int code;
	JFIFThumb thumb;
	private static final int DATA_SIZE = 6;
	private static final int ID_SIZE = 5;

	JFIFExtensionMarkerSegment(JPEGBuffer buffer, JPEGImageReader reader)
	throws IOException {

	super(buffer);
	buffer.bufPtr += ID_SIZE; // skip the id, we already checked it

	code = buffer.buf[buffer.bufPtr++] & 0xff;
	buffer.bufAvail -= DATA_SIZE;
	if (code == THUMB_JPEG) {
	thumb = new JFIFThumbJPEG(buffer, length, reader);
	} else {
	buffer.loadBuf(2);
	int thumbX = buffer.buf[buffer.bufPtr++] & 0xff;
	int thumbY = buffer.buf[buffer.bufPtr++] & 0xff;
	buffer.bufAvail -= 2;
	// following constructors handle bufAvail
	if (code == THUMB_PALETTE) {
	thumb = new JFIFThumbPalette(buffer, thumbX, thumbY);
	} else {
	thumb = new JFIFThumbRGB(buffer, thumbX, thumbY);
	}
	}
	}

	JFIFExtensionMarkerSegment(Node node) throws IIOInvalidTreeException {
	super(JPEG.APP0);
	NamedNodeMap attrs = node.getAttributes();
	if (attrs.getLength() > 0) {
	code = getAttributeValue(node,
	attrs,
	"extensionCode",
	THUMB_JPEG,
	THUMB_RGB,
	false);
	if (code == THUMB_UNASSIGNED) {
	throw new IIOInvalidTreeException
	("invalid extensionCode attribute value", node);
	}
	} else {
	code = THUMB_UNASSIGNED;
	}
	// Now the child
	if (node.getChildNodes().getLength() != 1) {
	throw new IIOInvalidTreeException
	("app0JFXX node must have exactly 1 child", node);
	}
	Node child = node.getFirstChild();
	String name = child.getNodeName();
	if (name.equals("JFIFthumbJPEG")) {
	if (code == THUMB_UNASSIGNED) {
	code = THUMB_JPEG;
	}
	thumb = new JFIFThumbJPEG(child);
	} else if (name.equals("JFIFthumbPalette")) {
	if (code == THUMB_UNASSIGNED) {
	code = THUMB_PALETTE;
	}
	thumb = new JFIFThumbPalette(child);
	} else if (name.equals("JFIFthumbRGB")) {
	if (code == THUMB_UNASSIGNED) {
	code = THUMB_RGB;
	}
	thumb = new JFIFThumbRGB(child);
	} else {
	throw new IIOInvalidTreeException
	("unrecognized app0JFXX child node", node);
	}
	}

	JFIFExtensionMarkerSegment(BufferedImage thumbnail)
	throws IllegalThumbException {

	super(JPEG.APP0);
	ColorModel cm = thumbnail.getColorModel();
	int csType = cm.getColorSpace().getType();
	if (cm.hasAlpha()) {
	throw new IllegalThumbException();
	}
	if (cm instanceof IndexColorModel) {
	code = THUMB_PALETTE;
	thumb = new JFIFThumbPalette(thumbnail);
	} else if (csType == ColorSpace.TYPE_RGB) {
	code = THUMB_RGB;
	thumb = new JFIFThumbRGB(thumbnail);
	} else if (csType == ColorSpace.TYPE_GRAY) {
	code = THUMB_JPEG;
	thumb = new JFIFThumbJPEG(thumbnail);
	} else {
	throw new IllegalThumbException();
	}
	}

	void setThumbnail(BufferedImage thumbnail) {
	try {
	switch (code) {
	case THUMB_PALETTE:
	thumb = new JFIFThumbPalette(thumbnail);
	break;
	case THUMB_RGB:
	thumb = new JFIFThumbRGB(thumbnail);
	break;
	case THUMB_JPEG:
	thumb = new JFIFThumbJPEG(thumbnail);
	break;
	}
	} catch (IllegalThumbException e) {
	// Should never happen
	throw new InternalError("Illegal thumb in setThumbnail!", e);
	}
	}

	protected Object clone() {
	JFIFExtensionMarkerSegment newGuy =
	(JFIFExtensionMarkerSegment) super.clone();
	if (thumb != null) {
	newGuy.thumb = (JFIFThumb) thumb.clone();
	}
	return newGuy;
	}

	IIOMetadataNode getNativeNode() {
	IIOMetadataNode node = new IIOMetadataNode("app0JFXX");
	node.setAttribute("extensionCode", Integer.toString(code));
	node.appendChild(thumb.getNativeNode());
	return node;
	}

	void write(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	length = LENGTH_SIZE + DATA_SIZE + thumb.getLength();
	writeTag(ios);
	byte [] id = {0x4A, 0x46, 0x58, 0x58, 0x00};
	ios.write(id);
	ios.write(code);
	thumb.write(ios, writer);
	}

	void print() {
	printTag("JFXX");
	thumb.print();
	}
	}

	/**
	* A superclass for the varieties of thumbnails that can
	* be stored in a JFIF extension marker segment.
	*/
	abstract class JFIFThumb implements Cloneable {
	long streamPos = -1L; // Save the thumbnail pos when reading
	abstract int getLength(); // When writing
	abstract int getWidth();
	abstract int getHeight();
	abstract BufferedImage getThumbnail(ImageInputStream iis,
	JPEGImageReader reader)
	throws IOException;

	protected JFIFThumb() {}

	protected JFIFThumb(JPEGBuffer buffer) throws IOException{
	// Save the stream position for reading the thumbnail later
	streamPos = buffer.getStreamPosition();
	}

	abstract void print();

	abstract IIOMetadataNode getNativeNode();

	abstract void write(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException;

	protected Object clone() {
	try {
	return super.clone();
	} catch (CloneNotSupportedException e) {} // won't happen
	return null;
	}

	}

	abstract class JFIFThumbUncompressed extends JFIFThumb {
	BufferedImage thumbnail = null;
	int thumbWidth;
	int thumbHeight;
	String name;

	JFIFThumbUncompressed(JPEGBuffer buffer,
	int width,
	int height,
	int skip,
	String name)
	throws IOException {
	super(buffer);
	thumbWidth = width;
	thumbHeight = height;
	// Now skip the thumbnail data
	buffer.skipData(skip);
	this.name = name;
	}

	JFIFThumbUncompressed(Node node, String name)
	throws IIOInvalidTreeException {

	thumbWidth = 0;
	thumbHeight = 0;
	this.name = name;
	NamedNodeMap attrs = node.getAttributes();
	int count = attrs.getLength();
	if (count > 2) {
	throw new IIOInvalidTreeException
	(name +" node cannot have > 2 attributes", node);
	}
	if (count != 0) {
	int value = getAttributeValue(node, attrs, "thumbWidth",
	0, 255, false);
	thumbWidth = (value != -1) ? value : thumbWidth;
	value = getAttributeValue(node, attrs, "thumbHeight",
	0, 255, false);
	thumbHeight = (value != -1) ? value : thumbHeight;
	}
	}

	JFIFThumbUncompressed(BufferedImage thumb) {
	thumbnail = thumb;
	thumbWidth = thumb.getWidth();
	thumbHeight = thumb.getHeight();
	name = null; // not used when writing
	}

	void readByteBuffer(ImageInputStream iis,
	byte [] data,
	JPEGImageReader reader,
	float workPortion,
	float workOffset) throws IOException {
	int progInterval = Math.max((int)(data.length/20/workPortion),
	1);
	for (int offset = 0;
	offset < data.length;) {
	int len = Math.min(progInterval, data.length-offset);
	iis.read(data, offset, len);
	offset += progInterval;
	float percentDone = ((float) offset* 100)
	/ data.length
	* workPortion + workOffset;
	if (percentDone > 100.0F) {
	percentDone = 100.0F;
	}
	reader.thumbnailProgress (percentDone);
	}
	}


	int getWidth() {
	return thumbWidth;
	}

	int getHeight() {
	return thumbHeight;
	}

	IIOMetadataNode getNativeNode() {
	IIOMetadataNode node = new IIOMetadataNode(name);
	node.setAttribute("thumbWidth", Integer.toString(thumbWidth));
	node.setAttribute("thumbHeight", Integer.toString(thumbHeight));
	return node;
	}

	void write(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	if ((thumbWidth > MAX_THUMB_WIDTH)
	\|\| (thumbHeight > MAX_THUMB_HEIGHT)) {
	writer.warningOccurred(JPEGImageWriter.WARNING_THUMB_CLIPPED);
	}
	thumbWidth = Math.min(thumbWidth, MAX_THUMB_WIDTH);
	thumbHeight = Math.min(thumbHeight, MAX_THUMB_HEIGHT);
	ios.write(thumbWidth);
	ios.write(thumbHeight);
	}

	void writePixels(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	if ((thumbWidth > MAX_THUMB_WIDTH)
	\|\| (thumbHeight > MAX_THUMB_HEIGHT)) {
	writer.warningOccurred(JPEGImageWriter.WARNING_THUMB_CLIPPED);
	}
	thumbWidth = Math.min(thumbWidth, MAX_THUMB_WIDTH);
	thumbHeight = Math.min(thumbHeight, MAX_THUMB_HEIGHT);
	int [] data = thumbnail.getRaster().getPixels(0, 0,
	thumbWidth,
	thumbHeight,
	(int []) null);
	writeThumbnailData(ios, data, writer);
	}

	void print() {
	System.out.print(name + " width: ");
	System.out.println(thumbWidth);
	System.out.print(name + " height: ");
	System.out.println(thumbHeight);
	}

	}

	/**
	* A JFIF thumbnail stored as RGB, one byte per channel,
	* interleaved.
	*/
	class JFIFThumbRGB extends JFIFThumbUncompressed {

	JFIFThumbRGB(JPEGBuffer buffer, int width, int height)
	throws IOException {

	super(buffer, width, height, widthheight3, "JFIFthumbRGB");
	}

	JFIFThumbRGB(Node node) throws IIOInvalidTreeException {
	super(node, "JFIFthumbRGB");
	}

	JFIFThumbRGB(BufferedImage thumb) throws IllegalThumbException {
	super(thumb);
	}

	int getLength() {
	return (thumbWidththumbHeight3);
	}

	BufferedImage getThumbnail(ImageInputStream iis,
	JPEGImageReader reader)
	throws IOException {
	iis.mark();
	iis.seek(streamPos);
	DataBufferByte buffer = new DataBufferByte(getLength());
	readByteBuffer(iis,
	buffer.getData(),
	reader,
	1.0F,
	0.0F);
	iis.reset();

	WritableRaster raster =
	Raster.createInterleavedRaster(buffer,
	thumbWidth,
	thumbHeight,
	thumbWidth*3,
	3,
	new int [] {0, 1, 2},
	null);
	ColorModel cm = new ComponentColorModel(JPEG.JCS.sRGB,
	false,
	false,
	ColorModel.OPAQUE,
	DataBuffer.TYPE_BYTE);
	return new BufferedImage(cm,
	raster,
	false,
	null);
	}

	void write(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	super.write(ios, writer); // width and height
	writePixels(ios, writer);
	}

	}

	/**
	* A JFIF thumbnail stored as an indexed palette image
	* using an RGB palette.
	*/
	class JFIFThumbPalette extends JFIFThumbUncompressed {
	private static final int PALETTE_SIZE = 768;

	JFIFThumbPalette(JPEGBuffer buffer, int width, int height)
	throws IOException {
	super(buffer,
	width,
	height,
	PALETTE_SIZE + width * height,
	"JFIFThumbPalette");
	}

	JFIFThumbPalette(Node node) throws IIOInvalidTreeException {
	super(node, "JFIFThumbPalette");
	}

	JFIFThumbPalette(BufferedImage thumb) throws IllegalThumbException {
	super(thumb);
	IndexColorModel icm = (IndexColorModel) thumbnail.getColorModel();
	if (icm.getMapSize() > 256) {
	throw new IllegalThumbException();
	}
	}

	int getLength() {
	return (thumbWidth*thumbHeight + PALETTE_SIZE);
	}

	BufferedImage getThumbnail(ImageInputStream iis,
	JPEGImageReader reader)
	throws IOException {
	iis.mark();
	iis.seek(streamPos);
	// read the palette
	byte [] palette = new byte [PALETTE_SIZE];
	float palettePart = ((float) PALETTE_SIZE) / getLength();
	readByteBuffer(iis,
	palette,
	reader,
	palettePart,
	0.0F);
	DataBufferByte buffer = new DataBufferByte(thumbWidth*thumbHeight);
	readByteBuffer(iis,
	buffer.getData(),
	reader,
	1.0F-palettePart,
	palettePart);
	iis.read();
	iis.reset();

	IndexColorModel cm = new IndexColorModel(8,
	256,
	palette,
	0,
	false);
	SampleModel sm = cm.createCompatibleSampleModel(thumbWidth,
	thumbHeight);
	WritableRaster raster =
	Raster.createWritableRaster(sm, buffer, null);
	return new BufferedImage(cm,
	raster,
	false,
	null);
	}

	void write(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	super.write(ios, writer); // width and height
	// Write the palette (must be 768 bytes)
	byte [] palette = new byte[768];
	IndexColorModel icm = (IndexColorModel) thumbnail.getColorModel();
	byte [] reds = new byte [256];
	byte [] greens = new byte [256];
	byte [] blues = new byte [256];
	icm.getReds(reds);
	icm.getGreens(greens);
	icm.getBlues(blues);
	for (int i = 0; i < 256; i++) {
	palette[i*3] = reds[i];
	palette[i*3+1] = greens[i];
	palette[i*3+2] = blues[i];
	}
	ios.write(palette);
	writePixels(ios, writer);
	}
	}


	/**
	* A JFIF thumbnail stored as a JPEG stream. No JFIF or
	* JFIF extension markers are permitted. There is no need
	* to clip these, but the entire image must fit into a
	* single JFXX marker segment.
	*/
	class JFIFThumbJPEG extends JFIFThumb {
	JPEGMetadata thumbMetadata = null;
	byte [] data = null; // Compressed image data, for writing
	private static final int PREAMBLE_SIZE = 6;

	JFIFThumbJPEG(JPEGBuffer buffer,
	int length,
	JPEGImageReader reader) throws IOException {
	super(buffer);
	// Compute the final stream position
	long finalPos = streamPos + (length - PREAMBLE_SIZE);
	// Set the stream back to the start of the thumbnail
	// and read its metadata (but don't decode the image)
	buffer.iis.seek(streamPos);
	thumbMetadata = new JPEGMetadata(false, true, buffer.iis, reader);
	// Set the stream to the computed final position
	buffer.iis.seek(finalPos);
	// Clear the now invalid buffer
	buffer.bufAvail = 0;
	buffer.bufPtr = 0;
	}

	JFIFThumbJPEG(Node node) throws IIOInvalidTreeException {
	if (node.getChildNodes().getLength() > 1) {
	throw new IIOInvalidTreeException
	("JFIFThumbJPEG node must have 0 or 1 child", node);
	}
	Node child = node.getFirstChild();
	if (child != null) {
	String name = child.getNodeName();
	if (!name.equals("markerSequence")) {
	throw new IIOInvalidTreeException
	("JFIFThumbJPEG child must be a markerSequence node",
	node);
	}
	thumbMetadata = new JPEGMetadata(false, true);
	thumbMetadata.setFromMarkerSequenceNode(child);
	}
	}

	JFIFThumbJPEG(BufferedImage thumb) throws IllegalThumbException {
	int INITIAL_BUFSIZE = 4096;
	int MAZ_BUFSIZE = 65535 - 2 - PREAMBLE_SIZE;
	try {
	ByteArrayOutputStream baos =
	new ByteArrayOutputStream(INITIAL_BUFSIZE);
	MemoryCacheImageOutputStream mos =
	new MemoryCacheImageOutputStream(baos);

	JPEGImageWriter thumbWriter = new JPEGImageWriter(null);

	thumbWriter.setOutput(mos);

	// get default metadata for the thumb
	JPEGMetadata metadata =
	(JPEGMetadata) thumbWriter.getDefaultImageMetadata
	(new ImageTypeSpecifier(thumb), null);

	// Remove the jfif segment, which should be there.
	MarkerSegment jfif = metadata.findMarkerSegment
	(JFIFMarkerSegment.class, true);
	if (jfif == null) {
	throw new IllegalThumbException();
	}

	metadata.markerSequence.remove(jfif);

	/* Use this if removing leaves a hole and causes trouble

	// Get the tree
	String format = metadata.getNativeMetadataFormatName();
	IIOMetadataNode tree =
	(IIOMetadataNode) metadata.getAsTree(format);

	// If there is no app0jfif node, the image is bad
	NodeList jfifs = tree.getElementsByTagName("app0JFIF");
	if (jfifs.getLength() == 0) {
	throw new IllegalThumbException();
	}

	// remove the app0jfif node
	Node jfif = jfifs.item(0);
	Node parent = jfif.getParentNode();
	parent.removeChild(jfif);

	metadata.setFromTree(format, tree);
	*/

	thumbWriter.write(new IIOImage(thumb, null, metadata));

	thumbWriter.dispose();
	// Now check that the size is OK
	if (baos.size() > MAZ_BUFSIZE) {
	throw new IllegalThumbException();
	}
	data = baos.toByteArray();
	} catch (IOException e) {
	throw new IllegalThumbException();
	}
	}

	int getWidth() {
	int retval = 0;
	SOFMarkerSegment sof =
	(SOFMarkerSegment) thumbMetadata.findMarkerSegment
	(SOFMarkerSegment.class, true);
	if (sof != null) {
	retval = sof.samplesPerLine;
	}
	return retval;
	}

	int getHeight() {
	int retval = 0;
	SOFMarkerSegment sof =
	(SOFMarkerSegment) thumbMetadata.findMarkerSegment
	(SOFMarkerSegment.class, true);
	if (sof != null) {
	retval = sof.numLines;
	}
	return retval;
	}

	private class ThumbnailReadListener
	implements IIOReadProgressListener {
	JPEGImageReader reader = null;
	ThumbnailReadListener (JPEGImageReader reader) {
	this.reader = reader;
	}
	public void sequenceStarted(ImageReader source, int minIndex) {}
	public void sequenceComplete(ImageReader source) {}
	public void imageStarted(ImageReader source, int imageIndex) {}
	public void imageProgress(ImageReader source,
	float percentageDone) {
	reader.thumbnailProgress(percentageDone);
	}
	public void imageComplete(ImageReader source) {}
	public void thumbnailStarted(ImageReader source,
	int imageIndex, int thumbnailIndex) {}
	public void thumbnailProgress(ImageReader source, float percentageDone) {}
	public void thumbnailComplete(ImageReader source) {}
	public void readAborted(ImageReader source) {}
	}

	BufferedImage getThumbnail(ImageInputStream iis,
	JPEGImageReader reader)
	throws IOException {
	iis.mark();
	iis.seek(streamPos);
	JPEGImageReader thumbReader = new JPEGImageReader(null);
	thumbReader.setInput(iis);
	thumbReader.addIIOReadProgressListener
	(new ThumbnailReadListener(reader));
	BufferedImage ret = thumbReader.read(0, null);
	thumbReader.dispose();
	iis.reset();
	return ret;
	}

	protected Object clone() {
	JFIFThumbJPEG newGuy = (JFIFThumbJPEG) super.clone();
	if (thumbMetadata != null) {
	newGuy.thumbMetadata = (JPEGMetadata) thumbMetadata.clone();
	}
	return newGuy;
	}

	IIOMetadataNode getNativeNode() {
	IIOMetadataNode node = new IIOMetadataNode("JFIFthumbJPEG");
	if (thumbMetadata != null) {
	node.appendChild(thumbMetadata.getNativeTree());
	}
	return node;
	}

	int getLength() {
	if (data == null) {
	return 0;
	} else {
	return data.length;
	}
	}

	void write(ImageOutputStream ios,
	JPEGImageWriter writer) throws IOException {
	int progInterval = data.length / 20; // approx. every 5%
	if (progInterval == 0) {
	progInterval = 1;
	}
	for (int offset = 0;
	offset < data.length;) {
	int len = Math.min(progInterval, data.length-offset);
	ios.write(data, offset, len);
	offset += progInterval;
	float percentDone = ((float) offset * 100) / data.length;
	if (percentDone > 100.0F) {
	percentDone = 100.0F;
	}
	writer.thumbnailProgress (percentDone);
	}
	}

	void print () {
	System.out.println("JFIF thumbnail stored as JPEG");
	}
	}

	/**
	* Write out the given profile to the stream, embedded in
	* the necessary number of APP2 segments, per the ICC spec.
	* This is the only mechanism for writing an ICC profile
	* to a stream.
	*/
	static void writeICC(ICC_Profile profile, ImageOutputStream ios)
	throws IOException {
	int LENGTH_LENGTH = 2;
	final String ID = "ICC_PROFILE";
	int ID_LENGTH = ID.length()+1; // spec says it's null-terminated
	int COUNTS_LENGTH = 2;
	int MAX_ICC_CHUNK_SIZE =
	65535 - LENGTH_LENGTH - ID_LENGTH - COUNTS_LENGTH;

	byte [] data = profile.getData();
	int numChunks = data.length / MAX_ICC_CHUNK_SIZE;
	if ((data.length % MAX_ICC_CHUNK_SIZE) != 0) {
	numChunks++;
	}
	int chunkNum = 1;
	int offset = 0;
	for (int i = 0; i < numChunks; i++) {
	int dataLength = Math.min(data.length-offset, MAX_ICC_CHUNK_SIZE);
	int segLength = dataLength+COUNTS_LENGTH+ID_LENGTH+LENGTH_LENGTH;
	ios.write(0xff);
	ios.write(JPEG.APP2);
	MarkerSegment.write2bytes(ios, segLength);
	byte [] id = ID.getBytes("US-ASCII");
	ios.write(id);
	ios.write(0); // Null-terminate the string
	ios.write(chunkNum++);
	ios.write(numChunks);
	ios.write(data, offset, dataLength);
	offset += dataLength;
	}
	}

	/**
	* An APP2 marker segment containing an ICC profile. In the stream
	* a profile larger than 64K is broken up into a series of chunks.
	* This inner class represents the complete profile as a single object,
	* combining chunks as necessary.
	*/
	class ICCMarkerSegment extends MarkerSegment {
	ArrayList chunks = null;
	byte [] profile = null; // The complete profile when it's fully read
	// May remain null when writing
	private static final int ID_SIZE = 12;
	int chunksRead;
	int numChunks;

	ICCMarkerSegment(ICC_ColorSpace cs) {
	super(JPEG.APP2);
	chunks = null;
	chunksRead = 0;
	numChunks = 0;
	profile = cs.getProfile().getData();
	}

	ICCMarkerSegment(JPEGBuffer buffer) throws IOException {
	super(buffer); // gets whole segment or fills the buffer
	if (debug) {
	System.out.println("Creating new ICC segment");
	}
	buffer.bufPtr += ID_SIZE; // Skip the id
	buffer.bufAvail -= ID_SIZE;
	/*
	* Reduce the stored length by the id size. The stored
	* length is used to store the length of the profile
	* data only.
	*/
	length -= ID_SIZE;

	// get the chunk number
	int chunkNum = buffer.buf[buffer.bufPtr] & 0xff;
	// get the total number of chunks
	numChunks = buffer.buf[buffer.bufPtr+1] & 0xff;

	if (chunkNum > numChunks) {
	throw new IIOException
	("Image format Error; chunk num > num chunks");
	}

	// if there are no more chunks, set up the data
	if (numChunks == 1) {
	// reduce the stored length by the two chunk numbering bytes
	length -= 2;
	profile = new byte[length];
	buffer.bufPtr += 2;
	buffer.bufAvail-=2;
	buffer.readData(profile);
	inICC = false;
	} else {
	// If we store them away, include the chunk numbering bytes
	byte [] profileData = new byte[length];
	// Now reduce the stored length by the
	// two chunk numbering bytes
	length -= 2;
	buffer.readData(profileData);
	chunks = new ArrayList();
	chunks.add(profileData);
	chunksRead = 1;
	inICC = true;
	}
	}

	ICCMarkerSegment(Node node) throws IIOInvalidTreeException {
	super(JPEG.APP2);
	if (node instanceof IIOMetadataNode) {
	IIOMetadataNode ourNode = (IIOMetadataNode) node;
	ICC_Profile prof = (ICC_Profile) ourNode.getUserObject();
	if (prof != null) { // May be null
	profile = prof.getData();
	}
	}
	}

	protected Object clone () {
	ICCMarkerSegment newGuy = (ICCMarkerSegment) super.clone();
	if (profile != null) {
	newGuy.profile = (byte[]) profile.clone();
	}
	return newGuy;
	}

	boolean addData(JPEGBuffer buffer) throws IOException {
	if (debug) {
	System.out.println("Adding to ICC segment");
	}
	// skip the tag
	buffer.bufPtr++;
	buffer.bufAvail--;
	// Get the length, but not in length
	int dataLen = (buffer.buf[buffer.bufPtr++] & 0xff) << 8;
	dataLen \|= buffer.buf[buffer.bufPtr++] & 0xff;
	buffer.bufAvail -= 2;
	// Don't include length itself
	dataLen -= 2;
	// skip the id
	buffer.bufPtr += ID_SIZE; // Skip the id
	buffer.bufAvail -= ID_SIZE;
	/*
	* Reduce the stored length by the id size. The stored
	* length is used to store the length of the profile
	* data only.
	*/
	dataLen -= ID_SIZE;

	// get the chunk number
	int chunkNum = buffer.buf[buffer.bufPtr] & 0xff;
	if (chunkNum > numChunks) {
	throw new IIOException
	("Image format Error; chunk num > num chunks");
	}

	// get the number of chunks, which should match
	int newNumChunks = buffer.buf[buffer.bufPtr+1] & 0xff;
	if (numChunks != newNumChunks) {
	throw new IIOException
	("Image format Error; icc num chunks mismatch");
	}
	dataLen -= 2;
	if (debug) {
	System.out.println("chunkNum: " + chunkNum
	+ ", numChunks: " + numChunks
	+ ", dataLen: " + dataLen);
	}
	boolean retval = false;
	byte [] profileData = new byte[dataLen];
	buffer.readData(profileData);
	chunks.add(profileData);
	length += dataLen;
	chunksRead++;
	if (chunksRead < numChunks) {
	inICC = true;
	} else {
	if (debug) {
	System.out.println("Completing profile; total length is "
	+ length);
	}
	// create an array for the whole thing
	profile = new byte[length];
	// copy the existing chunks, releasing them
	// Note that they may be out of order

	int index = 0;
	for (int i = 1; i <= numChunks; i++) {
	boolean foundIt = false;
	for (int chunk = 0; chunk < chunks.size(); chunk++) {
	byte [] chunkData = (byte []) chunks.get(chunk);
	if (chunkData[0] == i) { // Right one
	System.arraycopy(chunkData, 2,
	profile, index,
	chunkData.length-2);
	index += chunkData.length-2;
	foundIt = true;
	}
	}
	if (foundIt == false) {
	throw new IIOException
	("Image Format Error: Missing ICC chunk num " + i);
	}
	}

	chunks = null;
	chunksRead = 0;
	numChunks = 0;
	inICC = false;
	retval = true;
	}
	return retval;
	}

	IIOMetadataNode getNativeNode() {
	IIOMetadataNode node = new IIOMetadataNode("app2ICC");
	if (profile != null) {
	node.setUserObject(ICC_Profile.getInstance(profile));
	}
	return node;
	}

	/**
	* No-op. Profiles are never written from metadata.
	* They are written from the ColorSpace of the image.
	*/
	void write(ImageOutputStream ios) throws IOException {
	// No-op
	}

	void print () {
	printTag("ICC Profile APP2");
	}
	}
	}

Back to index...