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.ImageTypeSpecifier;
	import javax.imageio.ImageWriteParam;
	import javax.imageio.IIOException;
	import javax.imageio.stream.ImageInputStream;
	import javax.imageio.stream.ImageOutputStream;
	import javax.imageio.metadata.IIOMetadata;
	import javax.imageio.metadata.IIOMetadataNode;
	import javax.imageio.metadata.IIOMetadataFormat;
	import javax.imageio.metadata.IIOMetadataFormatImpl;
	import javax.imageio.metadata.IIOInvalidTreeException;
	import javax.imageio.plugins.jpeg.JPEGQTable;
	import javax.imageio.plugins.jpeg.JPEGHuffmanTable;
	import javax.imageio.plugins.jpeg.JPEGImageWriteParam;

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

	import java.util.List;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Iterator;
	import java.util.ListIterator;
	import java.io.IOException;
	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.Point;

	/**
	* Metadata for the JPEG plug-in.
	*/
	public class JPEGMetadata extends IIOMetadata implements Cloneable {

	//////// Private variables

	private static final boolean debug = false;

	/**
	* A copy of <code>markerSequence</code>, created the first time the
	* <code>markerSequence</code> is modified. This is used by reset
	* to restore the original state.
	*/
	private List resetSequence = null;

	/**
	* Set to <code>true</code> when reading a thumbnail stored as
	* JPEG. This is used to enforce the prohibition of JFIF thumbnails
	* containing any JFIF marker segments, and to ensure generation of
	* a correct native subtree during <code>getAsTree</code>.
	*/
	private boolean inThumb = false;

	/**
	* Set by the chroma node construction method to signal the
	* presence or absence of an alpha channel to the transparency
	* node construction method. Used only when constructing a
	* standard metadata tree.
	*/
	private boolean hasAlpha;

	//////// end of private variables

	/////// Package-access variables

	/**
	* All data is a list of <code>MarkerSegment</code> objects.
	* When accessing the list, use the tag to identify the particular
	* subclass. Any JFIF marker segment must be the first element
	* of the list if it is present, and any JFXX or APP2ICC marker
	* segments are subordinate to the JFIF marker segment. This
	* list is package visible so that the writer can access it.
	* @see #MarkerSegment
	*/
	List markerSequence = new ArrayList();

	/**
	* Indicates whether this object represents stream or image
	* metadata. Package-visible so the writer can see it.
	*/
	final boolean isStream;

	/////// End of package-access variables

	/////// Constructors

	/**
	* Constructor containing code shared by other constructors.
	*/
	JPEGMetadata(boolean isStream, boolean inThumb) {
	super(true, // Supports standard format
	JPEG.nativeImageMetadataFormatName, // and a native format
	JPEG.nativeImageMetadataFormatClassName,
	null, null); // No other formats
	this.inThumb = inThumb;
	// But if we are stream metadata, adjust the variables
	this.isStream = isStream;
	if (isStream) {
	nativeMetadataFormatName = JPEG.nativeStreamMetadataFormatName;
	nativeMetadataFormatClassName =
	JPEG.nativeStreamMetadataFormatClassName;
	}
	}

	/*
	* Constructs a <code>JPEGMetadata</code> object by reading the
	* contents of an <code>ImageInputStream</code>. Has package-only
	* access.
	*
	* @param isStream A boolean indicating whether this object will be
	* stream or image metadata.
	* @param isThumb A boolean indicating whether this metadata object
	* is for an image or for a thumbnail stored as JPEG.
	* @param iis An <code>ImageInputStream</code> from which to read
	* the metadata.
	* @param reader The <code>JPEGImageReader</code> calling this
	* constructor, to which warnings should be sent.
	*/
	JPEGMetadata(boolean isStream,
	boolean isThumb,
	ImageInputStream iis,
	JPEGImageReader reader) throws IOException {
	this(isStream, isThumb);

	JPEGBuffer buffer = new JPEGBuffer(iis);

	buffer.loadBuf(0);

	// The first three bytes should be FF, SOI, FF
	if (((buffer.buf[0] & 0xff) != 0xff)
	\|\| ((buffer.buf[1] & 0xff) != JPEG.SOI)
	\|\| ((buffer.buf[2] & 0xff) != 0xff)) {
	throw new IIOException ("Image format error");
	}

	boolean done = false;
	buffer.bufAvail -=2; // Next byte should be the ff before a marker
	buffer.bufPtr = 2;
	MarkerSegment newGuy = null;
	while (!done) {
	byte [] buf;
	int ptr;
	buffer.loadBuf(1);
	if (debug) {
	System.out.println("top of loop");
	buffer.print(10);
	}
	buffer.scanForFF(reader);
	switch (buffer.buf[buffer.bufPtr] & 0xff) {
	case 0:
	if (debug) {
	System.out.println("Skipping 0");
	}
	buffer.bufAvail--;
	buffer.bufPtr++;
	break;
	case JPEG.SOF0:
	case JPEG.SOF1:
	case JPEG.SOF2:
	if (isStream) {
	throw new IIOException
	("SOF not permitted in stream metadata");
	}
	newGuy = new SOFMarkerSegment(buffer);
	break;
	case JPEG.DQT:
	newGuy = new DQTMarkerSegment(buffer);
	break;
	case JPEG.DHT:
	newGuy = new DHTMarkerSegment(buffer);
	break;
	case JPEG.DRI:
	newGuy = new DRIMarkerSegment(buffer);
	break;
	case JPEG.APP0:
	// Either JFIF, JFXX, or unknown APP0
	buffer.loadBuf(8); // tag, length, id
	buf = buffer.buf;
	ptr = buffer.bufPtr;
	if ((buf[ptr+3] == 'J')
	&& (buf[ptr+4] == 'F')
	&& (buf[ptr+5] == 'I')
	&& (buf[ptr+6] == 'F')
	&& (buf[ptr+7] == 0)) {
	if (inThumb) {
	reader.warningOccurred
	(JPEGImageReader.WARNING_NO_JFIF_IN_THUMB);
	// Leave newGuy null
	// Read a dummy to skip the segment
	JFIFMarkerSegment dummy =
	new JFIFMarkerSegment(buffer);
	} else if (isStream) {
	throw new IIOException
	("JFIF not permitted in stream metadata");
	} else if (markerSequence.isEmpty() == false) {
	throw new IIOException
	("JFIF APP0 must be first marker after SOI");
	} else {
	newGuy = new JFIFMarkerSegment(buffer);
	}
	} else if ((buf[ptr+3] == 'J')
	&& (buf[ptr+4] == 'F')
	&& (buf[ptr+5] == 'X')
	&& (buf[ptr+6] == 'X')
	&& (buf[ptr+7] == 0)) {
	if (isStream) {
	throw new IIOException
	("JFXX not permitted in stream metadata");
	}
	if (inThumb) {
	throw new IIOException
	("JFXX markers not allowed in JFIF JPEG thumbnail");
	}
	JFIFMarkerSegment jfif =
	(JFIFMarkerSegment) findMarkerSegment
	(JFIFMarkerSegment.class, true);
	if (jfif == null) {
	throw new IIOException
	("JFXX encountered without prior JFIF!");
	}
	jfif.addJFXX(buffer, reader);
	// newGuy remains null
	} else {
	newGuy = new MarkerSegment(buffer);
	newGuy.loadData(buffer);
	}
	break;
	case JPEG.APP2:
	// Either an ICC profile or unknown APP2
	buffer.loadBuf(15); // tag, length, id
	if ((buffer.buf[buffer.bufPtr+3] == 'I')
	&& (buffer.buf[buffer.bufPtr+4] == 'C')
	&& (buffer.buf[buffer.bufPtr+5] == 'C')
	&& (buffer.buf[buffer.bufPtr+6] == '_')
	&& (buffer.buf[buffer.bufPtr+7] == 'P')
	&& (buffer.buf[buffer.bufPtr+8] == 'R')
	&& (buffer.buf[buffer.bufPtr+9] == 'O')
	&& (buffer.buf[buffer.bufPtr+10] == 'F')
	&& (buffer.buf[buffer.bufPtr+11] == 'I')
	&& (buffer.buf[buffer.bufPtr+12] == 'L')
	&& (buffer.buf[buffer.bufPtr+13] == 'E')
	&& (buffer.buf[buffer.bufPtr+14] == 0)
	) {
	if (isStream) {
	throw new IIOException
	("ICC profiles not permitted in stream metadata");
	}

	JFIFMarkerSegment jfif =
	(JFIFMarkerSegment) findMarkerSegment
	(JFIFMarkerSegment.class, true);
	if (jfif == null) {
	newGuy = new MarkerSegment(buffer);
	newGuy.loadData(buffer);
	} else {
	jfif.addICC(buffer);
	}
	// newGuy remains null
	} else {
	newGuy = new MarkerSegment(buffer);
	newGuy.loadData(buffer);
	}
	break;
	case JPEG.APP14:
	// Either Adobe or unknown APP14
	buffer.loadBuf(8); // tag, length, id
	if ((buffer.buf[buffer.bufPtr+3] == 'A')
	&& (buffer.buf[buffer.bufPtr+4] == 'd')
	&& (buffer.buf[buffer.bufPtr+5] == 'o')
	&& (buffer.buf[buffer.bufPtr+6] == 'b')
	&& (buffer.buf[buffer.bufPtr+7] == 'e')) {
	if (isStream) {
	throw new IIOException
	("Adobe APP14 markers not permitted in stream metadata");
	}
	newGuy = new AdobeMarkerSegment(buffer);
	} else {
	newGuy = new MarkerSegment(buffer);
	newGuy.loadData(buffer);
	}

	break;
	case JPEG.COM:
	newGuy = new COMMarkerSegment(buffer);
	break;
	case JPEG.SOS:
	if (isStream) {
	throw new IIOException
	("SOS not permitted in stream metadata");
	}
	newGuy = new SOSMarkerSegment(buffer);
	break;
	case JPEG.RST0:
	case JPEG.RST1:
	case JPEG.RST2:
	case JPEG.RST3:
	case JPEG.RST4:
	case JPEG.RST5:
	case JPEG.RST6:
	case JPEG.RST7:
	if (debug) {
	System.out.println("Restart Marker");
	}
	buffer.bufPtr++; // Just skip it
	buffer.bufAvail--;
	break;
	case JPEG.EOI:
	done = true;
	buffer.bufPtr++;
	buffer.bufAvail--;
	break;
	default:
	newGuy = new MarkerSegment(buffer);
	newGuy.loadData(buffer);
	newGuy.unknown = true;
	break;
	}
	if (newGuy != null) {
	markerSequence.add(newGuy);
	if (debug) {
	newGuy.print();
	}
	newGuy = null;
	}
	}

	// Now that we've read up to the EOI, we need to push back
	// whatever is left in the buffer, so that the next read
	// in the native code will work.

	buffer.pushBack();

	if (!isConsistent()) {
	throw new IIOException("Inconsistent metadata read from stream");
	}
	}

	/**
	* Constructs a default stream <code>JPEGMetadata</code> object appropriate
	* for the given write parameters.
	*/
	JPEGMetadata(ImageWriteParam param, JPEGImageWriter writer) {
	this(true, false);

	JPEGImageWriteParam jparam = null;

	if ((param != null) && (param instanceof JPEGImageWriteParam)) {
	jparam = (JPEGImageWriteParam) param;
	if (!jparam.areTablesSet()) {
	jparam = null;
	}
	}
	if (jparam != null) {
	markerSequence.add(new DQTMarkerSegment(jparam.getQTables()));
	markerSequence.add
	(new DHTMarkerSegment(jparam.getDCHuffmanTables(),
	jparam.getACHuffmanTables()));
	} else {
	// default tables.
	markerSequence.add(new DQTMarkerSegment(JPEG.getDefaultQTables()));
	markerSequence.add(new DHTMarkerSegment(JPEG.getDefaultHuffmanTables(true),
	JPEG.getDefaultHuffmanTables(false)));
	}

	// Defensive programming
	if (!isConsistent()) {
	throw new InternalError("Default stream metadata is inconsistent");
	}
	}

	/**
	* Constructs a default image <code>JPEGMetadata</code> object appropriate
	* for the given image type and write parameters.
	*/
	JPEGMetadata(ImageTypeSpecifier imageType,
	ImageWriteParam param,
	JPEGImageWriter writer) {
	this(false, false);

	boolean wantJFIF = true;
	boolean wantAdobe = false;
	int transform = JPEG.ADOBE_UNKNOWN;
	boolean willSubsample = true;
	boolean wantICC = false;
	boolean wantProg = false;
	boolean wantOptimized = false;
	boolean wantExtended = false;
	boolean wantQTables = true;
	boolean wantHTables = true;
	float quality = JPEG.DEFAULT_QUALITY;
	byte[] componentIDs = { 1, 2, 3, 4};
	int numComponents = 0;

	ImageTypeSpecifier destType = null;

	if (param != null) {
	destType = param.getDestinationType();
	if (destType != null) {
	if (imageType != null) {
	// Ignore the destination type.
	writer.warningOccurred
	(JPEGImageWriter.WARNING_DEST_IGNORED);
	destType = null;
	}
	}
	// The only progressive mode that makes sense here is MODE_DEFAULT
	if (param.canWriteProgressive()) {
	// the param may not be one of ours, so it may return false.
	// If so, the following would throw an exception
	if (param.getProgressiveMode() == ImageWriteParam.MODE_DEFAULT) {
	wantProg = true;
	wantOptimized = true;
	wantHTables = false;
	}
	}

	if (param instanceof JPEGImageWriteParam) {
	JPEGImageWriteParam jparam = (JPEGImageWriteParam) param;
	if (jparam.areTablesSet()) {
	wantQTables = false; // If the param has them, metadata shouldn't
	wantHTables = false;
	if ((jparam.getDCHuffmanTables().length > 2)
	\|\| (jparam.getACHuffmanTables().length > 2)) {
	wantExtended = true;
	}
	}
	// Progressive forces optimized, regardless of param setting
	// so consult the param re optimized only if not progressive
	if (!wantProg) {
	wantOptimized = jparam.getOptimizeHuffmanTables();
	if (wantOptimized) {
	wantHTables = false;
	}
	}
	}

	// compression quality should determine the q tables. Note that this
	// will be ignored if we already decided not to create any.
	// Again, the param may not be one of ours, so we must check that it
	// supports compression settings
	if (param.canWriteCompressed()) {
	if (param.getCompressionMode() == ImageWriteParam.MODE_EXPLICIT) {
	quality = param.getCompressionQuality();
	}
	}
	}

	// We are done with the param, now for the image types

	ColorSpace cs = null;
	if (destType != null) {
	ColorModel cm = destType.getColorModel();
	numComponents = cm.getNumComponents();
	boolean hasExtraComponents = (cm.getNumColorComponents() != numComponents);
	boolean hasAlpha = cm.hasAlpha();
	cs = cm.getColorSpace();
	int type = cs.getType();
	switch(type) {
	case ColorSpace.TYPE_GRAY:
	willSubsample = false;
	if (hasExtraComponents) { // e.g. alpha
	wantJFIF = false;
	}
	break;
	case ColorSpace.TYPE_3CLR:
	if (cs == JPEG.JCS.getYCC()) {
	wantJFIF = false;
	componentIDs[0] = (byte) 'Y';
	componentIDs[1] = (byte) 'C';
	componentIDs[2] = (byte) 'c';
	if (hasAlpha) {
	componentIDs[3] = (byte) 'A';
	}
	}
	break;
	case ColorSpace.TYPE_YCbCr:
	if (hasExtraComponents) { // e.g. K or alpha
	wantJFIF = false;
	if (!hasAlpha) { // Not alpha, so must be K
	wantAdobe = true;
	transform = JPEG.ADOBE_YCCK;
	}
	}
	break;
	case ColorSpace.TYPE_RGB: // with or without alpha
	wantJFIF = false;
	wantAdobe = true;
	willSubsample = false;
	componentIDs[0] = (byte) 'R';
	componentIDs[1] = (byte) 'G';
	componentIDs[2] = (byte) 'B';
	if (hasAlpha) {
	componentIDs[3] = (byte) 'A';
	}
	break;
	default:
	// Everything else is not subsampled, gets no special marker,
	// and component ids are 1 - N
	wantJFIF = false;
	willSubsample = false;
	}
	} else if (imageType != null) {
	ColorModel cm = imageType.getColorModel();
	numComponents = cm.getNumComponents();
	boolean hasExtraComponents = (cm.getNumColorComponents() != numComponents);
	boolean hasAlpha = cm.hasAlpha();
	cs = cm.getColorSpace();
	int type = cs.getType();
	switch(type) {
	case ColorSpace.TYPE_GRAY:
	willSubsample = false;
	if (hasExtraComponents) { // e.g. alpha
	wantJFIF = false;
	}
	break;
	case ColorSpace.TYPE_RGB: // with or without alpha
	// without alpha we just accept the JFIF defaults
	if (hasAlpha) {
	wantJFIF = false;
	}
	break;
	case ColorSpace.TYPE_3CLR:
	wantJFIF = false;
	willSubsample = false;
	if (cs.equals(ColorSpace.getInstance(ColorSpace.CS_PYCC))) {
	willSubsample = true;
	wantAdobe = true;
	componentIDs[0] = (byte) 'Y';
	componentIDs[1] = (byte) 'C';
	componentIDs[2] = (byte) 'c';
	if (hasAlpha) {
	componentIDs[3] = (byte) 'A';
	}
	}
	break;
	case ColorSpace.TYPE_YCbCr:
	if (hasExtraComponents) { // e.g. K or alpha
	wantJFIF = false;
	if (!hasAlpha) { // then it must be K
	wantAdobe = true;
	transform = JPEG.ADOBE_YCCK;
	}
	}
	break;
	case ColorSpace.TYPE_CMYK:
	wantJFIF = false;
	wantAdobe = true;
	transform = JPEG.ADOBE_YCCK;
	break;

	default:
	// Everything else is not subsampled, gets no special marker,
	// and component ids are 0 - N
	wantJFIF = false;
	willSubsample = false;
	}

	}

	// do we want an ICC profile?
	if (wantJFIF && JPEG.isNonStandardICC(cs)) {
	wantICC = true;
	}

	// Now step through the markers, consulting our variables.
	if (wantJFIF) {
	JFIFMarkerSegment jfif = new JFIFMarkerSegment();
	markerSequence.add(jfif);
	if (wantICC) {
	try {
	jfif.addICC((ICC_ColorSpace)cs);
	} catch (IOException e) {} // Can't happen here
	}
	}
	// Adobe
	if (wantAdobe) {
	markerSequence.add(new AdobeMarkerSegment(transform));
	}

	// dqt
	if (wantQTables) {
	markerSequence.add(new DQTMarkerSegment(quality, willSubsample));
	}

	// dht
	if (wantHTables) {
	markerSequence.add(new DHTMarkerSegment(willSubsample));
	}

	// sof
	markerSequence.add(new SOFMarkerSegment(wantProg,
	wantExtended,
	willSubsample,
	componentIDs,
	numComponents));

	// sos
	if (!wantProg) { // Default progression scans are done in the writer
	markerSequence.add(new SOSMarkerSegment(willSubsample,
	componentIDs,
	numComponents));
	}

	// Defensive programming
	if (!isConsistent()) {
	throw new InternalError("Default image metadata is inconsistent");
	}
	}

	////// End of constructors

	// Utilities for dealing with the marker sequence.
	// The first ones have package access for access from the writer.

	/**
	* Returns the first MarkerSegment object in the list
	* with the given tag, or null if none is found.
	*/
	MarkerSegment findMarkerSegment(int tag) {
	Iterator iter = markerSequence.iterator();
	while (iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment)iter.next();
	if (seg.tag == tag) {
	return seg;
	}
	}
	return null;
	}

	/**
	* Returns the first or last MarkerSegment object in the list
	* of the given class, or null if none is found.
	*/
	MarkerSegment findMarkerSegment(Class cls, boolean first) {
	if (first) {
	Iterator iter = markerSequence.iterator();
	while (iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment)iter.next();
	if (cls.isInstance(seg)) {
	return seg;
	}
	}
	} else {
	ListIterator iter = markerSequence.listIterator(markerSequence.size());
	while (iter.hasPrevious()) {
	MarkerSegment seg = (MarkerSegment)iter.previous();
	if (cls.isInstance(seg)) {
	return seg;
	}
	}
	}
	return null;
	}

	/**
	* Returns the index of the first or last MarkerSegment in the list
	* of the given class, or -1 if none is found.
	*/
	private int findMarkerSegmentPosition(Class cls, boolean first) {
	if (first) {
	ListIterator iter = markerSequence.listIterator();
	for (int i = 0; iter.hasNext(); i++) {
	MarkerSegment seg = (MarkerSegment)iter.next();
	if (cls.isInstance(seg)) {
	return i;
	}
	}
	} else {
	ListIterator iter = markerSequence.listIterator(markerSequence.size());
	for (int i = markerSequence.size()-1; iter.hasPrevious(); i--) {
	MarkerSegment seg = (MarkerSegment)iter.previous();
	if (cls.isInstance(seg)) {
	return i;
	}
	}
	}
	return -1;
	}

	private int findLastUnknownMarkerSegmentPosition() {
	ListIterator iter = markerSequence.listIterator(markerSequence.size());
	for (int i = markerSequence.size()-1; iter.hasPrevious(); i--) {
	MarkerSegment seg = (MarkerSegment)iter.previous();
	if (seg.unknown == true) {
	return i;
	}
	}
	return -1;
	}

	// Implement Cloneable, but restrict access

	protected Object clone() {
	JPEGMetadata newGuy = null;
	try {
	newGuy = (JPEGMetadata) super.clone();
	} catch (CloneNotSupportedException e) {} // won't happen
	if (markerSequence != null) {
	newGuy.markerSequence = (List) cloneSequence();
	}
	newGuy.resetSequence = null;
	return newGuy;
	}

	/**
	* Returns a deep copy of the current marker sequence.
	*/
	private List cloneSequence() {
	if (markerSequence == null) {
	return null;
	}
	List retval = new ArrayList(markerSequence.size());
	Iterator iter = markerSequence.iterator();
	while(iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment)iter.next();
	retval.add(seg.clone());
	}

	return retval;
	}


	// Tree methods

	public Node getAsTree(String formatName) {
	if (formatName == null) {
	throw new IllegalArgumentException("null formatName!");
	}
	if (isStream) {
	if (formatName.equals(JPEG.nativeStreamMetadataFormatName)) {
	return getNativeTree();
	}
	} else {
	if (formatName.equals(JPEG.nativeImageMetadataFormatName)) {
	return getNativeTree();
	}
	if (formatName.equals
	(IIOMetadataFormatImpl.standardMetadataFormatName)) {
	return getStandardTree();
	}
	}
	throw new IllegalArgumentException("Unsupported format name: "
	+ formatName);
	}

	IIOMetadataNode getNativeTree() {
	IIOMetadataNode root;
	IIOMetadataNode top;
	Iterator iter = markerSequence.iterator();
	if (isStream) {
	root = new IIOMetadataNode(JPEG.nativeStreamMetadataFormatName);
	top = root;
	} else {
	IIOMetadataNode sequence = new IIOMetadataNode("markerSequence");
	if (!inThumb) {
	root = new IIOMetadataNode(JPEG.nativeImageMetadataFormatName);
	IIOMetadataNode header = new IIOMetadataNode("JPEGvariety");
	root.appendChild(header);
	JFIFMarkerSegment jfif = (JFIFMarkerSegment)
	findMarkerSegment(JFIFMarkerSegment.class, true);
	if (jfif != null) {
	iter.next(); // JFIF must be first, so this skips it
	header.appendChild(jfif.getNativeNode());
	}
	root.appendChild(sequence);
	} else {
	root = sequence;
	}
	top = sequence;
	}
	while(iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment) iter.next();
	top.appendChild(seg.getNativeNode());
	}
	return root;
	}

	// Standard tree node methods

	protected IIOMetadataNode getStandardChromaNode() {
	hasAlpha = false; // Unless we find otherwise

	// Colorspace type - follow the rules in the spec
	// First get the SOF marker segment, if there is one
	SOFMarkerSegment sof = (SOFMarkerSegment)
	findMarkerSegment(SOFMarkerSegment.class, true);
	if (sof == null) {
	// No image, so no chroma
	return null;
	}

	IIOMetadataNode chroma = new IIOMetadataNode("Chroma");
	IIOMetadataNode csType = new IIOMetadataNode("ColorSpaceType");
	chroma.appendChild(csType);

	// get the number of channels
	int numChannels = sof.componentSpecs.length;

	IIOMetadataNode numChanNode = new IIOMetadataNode("NumChannels");
	chroma.appendChild(numChanNode);
	numChanNode.setAttribute("value", Integer.toString(numChannels));

	// is there a JFIF marker segment?
	if (findMarkerSegment(JFIFMarkerSegment.class, true) != null) {
	if (numChannels == 1) {
	csType.setAttribute("name", "GRAY");
	} else {
	csType.setAttribute("name", "YCbCr");
	}
	return chroma;
	}

	// How about an Adobe marker segment?
	AdobeMarkerSegment adobe =
	(AdobeMarkerSegment) findMarkerSegment(AdobeMarkerSegment.class, true);
	if (adobe != null){
	switch (adobe.transform) {
	case JPEG.ADOBE_YCCK:
	csType.setAttribute("name", "YCCK");
	break;
	case JPEG.ADOBE_YCC:
	csType.setAttribute("name", "YCbCr");
	break;
	case JPEG.ADOBE_UNKNOWN:
	if (numChannels == 3) {
	csType.setAttribute("name", "RGB");
	} else if (numChannels == 4) {
	csType.setAttribute("name", "CMYK");
	}
	break;
	}
	return chroma;
	}

	// Neither marker. Check components
	if (numChannels < 3) {
	csType.setAttribute("name", "GRAY");
	if (numChannels == 2) {
	hasAlpha = true;
	}
	return chroma;
	}

	boolean idsAreJFIF = true;

	for (int i = 0; i < sof.componentSpecs.length; i++) {
	int id = sof.componentSpecs[i].componentId;
	if ((id < 1) \|\| (id >= sof.componentSpecs.length)) {
	idsAreJFIF = false;
	}
	}

	if (idsAreJFIF) {
	csType.setAttribute("name", "YCbCr");
	if (numChannels == 4) {
	hasAlpha = true;
	}
	return chroma;
	}

	// Check against the letters
	if ((sof.componentSpecs[0].componentId == 'R')
	&& (sof.componentSpecs[1].componentId == 'G')
	&& (sof.componentSpecs[2].componentId == 'B')){

	csType.setAttribute("name", "RGB");
	if ((numChannels == 4)
	&& (sof.componentSpecs[3].componentId == 'A')) {
	hasAlpha = true;
	}
	return chroma;
	}

	if ((sof.componentSpecs[0].componentId == 'Y')
	&& (sof.componentSpecs[1].componentId == 'C')
	&& (sof.componentSpecs[2].componentId == 'c')){

	csType.setAttribute("name", "PhotoYCC");
	if ((numChannels == 4)
	&& (sof.componentSpecs[3].componentId == 'A')) {
	hasAlpha = true;
	}
	return chroma;
	}

	// Finally, 3-channel subsampled are YCbCr, unsubsampled are RGB
	// 4-channel subsampled are YCbCrA, unsubsampled are CMYK

	boolean subsampled = false;

	int hfactor = sof.componentSpecs[0].HsamplingFactor;
	int vfactor = sof.componentSpecs[0].VsamplingFactor;

	for (int i = 1; i<sof.componentSpecs.length; i++) {
	if ((sof.componentSpecs[i].HsamplingFactor != hfactor)
	\|\| (sof.componentSpecs[i].VsamplingFactor != vfactor)){
	subsampled = true;
	break;
	}
	}

	if (subsampled) {
	csType.setAttribute("name", "YCbCr");
	if (numChannels == 4) {
	hasAlpha = true;
	}
	return chroma;
	}

	// Not subsampled. numChannels < 3 is taken care of above
	if (numChannels == 3) {
	csType.setAttribute("name", "RGB");
	} else {
	csType.setAttribute("name", "CMYK");
	}

	return chroma;
	}

	protected IIOMetadataNode getStandardCompressionNode() {

	IIOMetadataNode compression = new IIOMetadataNode("Compression");

	// CompressionTypeName
	IIOMetadataNode name = new IIOMetadataNode("CompressionTypeName");
	name.setAttribute("value", "JPEG");
	compression.appendChild(name);

	// Lossless - false
	IIOMetadataNode lossless = new IIOMetadataNode("Lossless");
	lossless.setAttribute("value", "FALSE");
	compression.appendChild(lossless);

	// NumProgressiveScans - count sos segments
	int sosCount = 0;
	Iterator iter = markerSequence.iterator();
	while (iter.hasNext()) {
	MarkerSegment ms = (MarkerSegment) iter.next();
	if (ms.tag == JPEG.SOS) {
	sosCount++;
	}
	}
	if (sosCount != 0) {
	IIOMetadataNode prog = new IIOMetadataNode("NumProgressiveScans");
	prog.setAttribute("value", Integer.toString(sosCount));
	compression.appendChild(prog);
	}

	return compression;
	}

	protected IIOMetadataNode getStandardDimensionNode() {
	// If we have a JFIF marker segment, we know a little
	// otherwise all we know is the orientation, which is always normal
	IIOMetadataNode dim = new IIOMetadataNode("Dimension");
	IIOMetadataNode orient = new IIOMetadataNode("ImageOrientation");
	orient.setAttribute("value", "normal");
	dim.appendChild(orient);

	JFIFMarkerSegment jfif =
	(JFIFMarkerSegment) findMarkerSegment(JFIFMarkerSegment.class, true);
	if (jfif != null) {

	// Aspect Ratio is width of pixel / height of pixel
	float aspectRatio;
	if (jfif.resUnits == 0) {
	// In this case they just encode aspect ratio directly
	aspectRatio = ((float) jfif.Xdensity)/jfif.Ydensity;
	} else {
	// They are true densities (e.g. dpi) and must be inverted
	aspectRatio = ((float) jfif.Ydensity)/jfif.Xdensity;
	}
	IIOMetadataNode aspect = new IIOMetadataNode("PixelAspectRatio");
	aspect.setAttribute("value", Float.toString(aspectRatio));
	dim.insertBefore(aspect, orient);

	// Pixel size
	if (jfif.resUnits != 0) {
	// 1 == dpi, 2 == dpc
	float scale = (jfif.resUnits == 1) ? 25.4F : 10.0F;

	IIOMetadataNode horiz =
	new IIOMetadataNode("HorizontalPixelSize");
	horiz.setAttribute("value",
	Float.toString(scale/jfif.Xdensity));
	dim.appendChild(horiz);

	IIOMetadataNode vert =
	new IIOMetadataNode("VerticalPixelSize");
	vert.setAttribute("value",
	Float.toString(scale/jfif.Ydensity));
	dim.appendChild(vert);
	}
	}
	return dim;
	}

	protected IIOMetadataNode getStandardTextNode() {
	IIOMetadataNode text = null;
	// Add a text entry for each COM Marker Segment
	if (findMarkerSegment(JPEG.COM) != null) {
	text = new IIOMetadataNode("Text");
	Iterator iter = markerSequence.iterator();
	while (iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment) iter.next();
	if (seg.tag == JPEG.COM) {
	COMMarkerSegment com = (COMMarkerSegment) seg;
	IIOMetadataNode entry = new IIOMetadataNode("TextEntry");
	entry.setAttribute("keyword", "comment");
	entry.setAttribute("value", com.getComment());
	text.appendChild(entry);
	}
	}
	}
	return text;
	}

	protected IIOMetadataNode getStandardTransparencyNode() {
	IIOMetadataNode trans = null;
	if (hasAlpha == true) {
	trans = new IIOMetadataNode("Transparency");
	IIOMetadataNode alpha = new IIOMetadataNode("Alpha");
	alpha.setAttribute("value", "nonpremultiplied"); // Always assume
	trans.appendChild(alpha);
	}
	return trans;
	}

	// Editing

	public boolean isReadOnly() {
	return false;
	}

	public void mergeTree(String formatName, Node root)
	throws IIOInvalidTreeException {
	if (formatName == null) {
	throw new IllegalArgumentException("null formatName!");
	}
	if (root == null) {
	throw new IllegalArgumentException("null root!");
	}
	List copy = null;
	if (resetSequence == null) {
	resetSequence = cloneSequence(); // Deep copy
	copy = resetSequence; // Avoid cloning twice
	} else {
	copy = cloneSequence();
	}
	if (isStream &&
	(formatName.equals(JPEG.nativeStreamMetadataFormatName))) {
	mergeNativeTree(root);
	} else if (!isStream &&
	(formatName.equals(JPEG.nativeImageMetadataFormatName))) {
	mergeNativeTree(root);
	} else if (!isStream &&
	(formatName.equals
	(IIOMetadataFormatImpl.standardMetadataFormatName))) {
	mergeStandardTree(root);
	} else {
	throw new IllegalArgumentException("Unsupported format name: "
	+ formatName);
	}
	if (!isConsistent()) {
	markerSequence = copy;
	throw new IIOInvalidTreeException
	("Merged tree is invalid; original restored", root);
	}
	}

	private void mergeNativeTree(Node root) throws IIOInvalidTreeException {
	String name = root.getNodeName();
	if (name != ((isStream) ? JPEG.nativeStreamMetadataFormatName
	: JPEG.nativeImageMetadataFormatName)) {
	throw new IIOInvalidTreeException("Invalid root node name: " + name,
	root);
	}
	if (root.getChildNodes().getLength() != 2) { // JPEGvariety and markerSequence
	throw new IIOInvalidTreeException(
	"JPEGvariety and markerSequence nodes must be present", root);
	}
	mergeJFIFsubtree(root.getFirstChild());
	mergeSequenceSubtree(root.getLastChild());
	}

	/**
	* Merge a JFIF subtree into the marker sequence, if the subtree
	* is non-empty.
	* If a JFIF marker exists, update it from the subtree.
	* If none exists, create one from the subtree and insert it at the
	* beginning of the marker sequence.
	*/
	private void mergeJFIFsubtree(Node JPEGvariety)
	throws IIOInvalidTreeException {
	if (JPEGvariety.getChildNodes().getLength() != 0) {
	Node jfifNode = JPEGvariety.getFirstChild();
	// is there already a jfif marker segment?
	JFIFMarkerSegment jfifSeg =
	(JFIFMarkerSegment) findMarkerSegment(JFIFMarkerSegment.class, true);
	if (jfifSeg != null) {
	jfifSeg.updateFromNativeNode(jfifNode, false);
	} else {
	// Add it as the first element in the list.
	markerSequence.add(0, new JFIFMarkerSegment(jfifNode));
	}
	}
	}

	private void mergeSequenceSubtree(Node sequenceTree)
	throws IIOInvalidTreeException {
	NodeList children = sequenceTree.getChildNodes();
	for (int i = 0; i < children.getLength(); i++) {
	Node node = children.item(i);
	String name = node.getNodeName();
	if (name.equals("dqt")) {
	mergeDQTNode(node);
	} else if (name.equals("dht")) {
	mergeDHTNode(node);
	} else if (name.equals("dri")) {
	mergeDRINode(node);
	} else if (name.equals("com")) {
	mergeCOMNode(node);
	} else if (name.equals("app14Adobe")) {
	mergeAdobeNode(node);
	} else if (name.equals("unknown")) {
	mergeUnknownNode(node);
	} else if (name.equals("sof")) {
	mergeSOFNode(node);
	} else if (name.equals("sos")) {
	mergeSOSNode(node);
	} else {
	throw new IIOInvalidTreeException("Invalid node: " + name, node);
	}
	}
	}

	/**
	* Merge the given DQT node into the marker sequence. If there already
	* exist DQT marker segments in the sequence, then each table in the
	* node replaces the first table, in any DQT segment, with the same
	* table id. If none of the existing DQT segments contain a table with
	* the same id, then the table is added to the last existing DQT segment.
	* If there are no DQT segments, then a new one is created and added
	* as follows:
	* If there are DHT segments, the new DQT segment is inserted before the
	* first one.
	* If there are no DHT segments, the new DQT segment is inserted before
	* an SOF segment, if there is one.
	* If there is no SOF segment, the new DQT segment is inserted before
	* the first SOS segment, if there is one.
	* If there is no SOS segment, the new DQT segment is added to the end
	* of the sequence.
	*/
	private void mergeDQTNode(Node node) throws IIOInvalidTreeException {
	// First collect any existing DQT nodes into a local list
	ArrayList oldDQTs = new ArrayList();
	Iterator iter = markerSequence.iterator();
	while (iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment) iter.next();
	if (seg instanceof DQTMarkerSegment) {
	oldDQTs.add(seg);
	}
	}
	if (!oldDQTs.isEmpty()) {
	NodeList children = node.getChildNodes();
	for (int i = 0; i < children.getLength(); i++) {
	Node child = children.item(i);
	int childID = MarkerSegment.getAttributeValue(child,
	null,
	"qtableId",
	0, 3,
	true);
	DQTMarkerSegment dqt = null;
	int tableIndex = -1;
	for (int j = 0; j < oldDQTs.size(); j++) {
	DQTMarkerSegment testDQT = (DQTMarkerSegment) oldDQTs.get(j);
	for (int k = 0; k < testDQT.tables.size(); k++) {
	DQTMarkerSegment.Qtable testTable =
	(DQTMarkerSegment.Qtable) testDQT.tables.get(k);
	if (childID == testTable.tableID) {
	dqt = testDQT;
	tableIndex = k;
	break;
	}
	}
	if (dqt != null) break;
	}
	if (dqt != null) {
	dqt.tables.set(tableIndex, dqt.getQtableFromNode(child));
	} else {
	dqt = (DQTMarkerSegment) oldDQTs.get(oldDQTs.size()-1);
	dqt.tables.add(dqt.getQtableFromNode(child));
	}
	}
	} else {
	DQTMarkerSegment newGuy = new DQTMarkerSegment(node);
	int firstDHT = findMarkerSegmentPosition(DHTMarkerSegment.class, true);
	int firstSOF = findMarkerSegmentPosition(SOFMarkerSegment.class, true);
	int firstSOS = findMarkerSegmentPosition(SOSMarkerSegment.class, true);
	if (firstDHT != -1) {
	markerSequence.add(firstDHT, newGuy);
	} else if (firstSOF != -1) {
	markerSequence.add(firstSOF, newGuy);
	} else if (firstSOS != -1) {
	markerSequence.add(firstSOS, newGuy);
	} else {
	markerSequence.add(newGuy);
	}
	}
	}

	/**
	* Merge the given DHT node into the marker sequence. If there already
	* exist DHT marker segments in the sequence, then each table in the
	* node replaces the first table, in any DHT segment, with the same
	* table class and table id. If none of the existing DHT segments contain
	* a table with the same class and id, then the table is added to the last
	* existing DHT segment.
	* If there are no DHT segments, then a new one is created and added
	* as follows:
	* If there are DQT segments, the new DHT segment is inserted immediately
	* following the last DQT segment.
	* If there are no DQT segments, the new DHT segment is inserted before
	* an SOF segment, if there is one.
	* If there is no SOF segment, the new DHT segment is inserted before
	* the first SOS segment, if there is one.
	* If there is no SOS segment, the new DHT segment is added to the end
	* of the sequence.
	*/
	private void mergeDHTNode(Node node) throws IIOInvalidTreeException {
	// First collect any existing DQT nodes into a local list
	ArrayList oldDHTs = new ArrayList();
	Iterator iter = markerSequence.iterator();
	while (iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment) iter.next();
	if (seg instanceof DHTMarkerSegment) {
	oldDHTs.add(seg);
	}
	}
	if (!oldDHTs.isEmpty()) {
	NodeList children = node.getChildNodes();
	for (int i = 0; i < children.getLength(); i++) {
	Node child = children.item(i);
	NamedNodeMap attrs = child.getAttributes();
	int childID = MarkerSegment.getAttributeValue(child,
	attrs,
	"htableId",
	0, 3,
	true);
	int childClass = MarkerSegment.getAttributeValue(child,
	attrs,
	"class",
	0, 1,
	true);
	DHTMarkerSegment dht = null;
	int tableIndex = -1;
	for (int j = 0; j < oldDHTs.size(); j++) {
	DHTMarkerSegment testDHT = (DHTMarkerSegment) oldDHTs.get(j);
	for (int k = 0; k < testDHT.tables.size(); k++) {
	DHTMarkerSegment.Htable testTable =
	(DHTMarkerSegment.Htable) testDHT.tables.get(k);
	if ((childID == testTable.tableID) &&
	(childClass == testTable.tableClass)) {
	dht = testDHT;
	tableIndex = k;
	break;
	}
	}
	if (dht != null) break;
	}
	if (dht != null) {
	dht.tables.set(tableIndex, dht.getHtableFromNode(child));
	} else {
	dht = (DHTMarkerSegment) oldDHTs.get(oldDHTs.size()-1);
	dht.tables.add(dht.getHtableFromNode(child));
	}
	}
	} else {
	DHTMarkerSegment newGuy = new DHTMarkerSegment(node);
	int lastDQT = findMarkerSegmentPosition(DQTMarkerSegment.class, false);
	int firstSOF = findMarkerSegmentPosition(SOFMarkerSegment.class, true);
	int firstSOS = findMarkerSegmentPosition(SOSMarkerSegment.class, true);
	if (lastDQT != -1) {
	markerSequence.add(lastDQT+1, newGuy);
	} else if (firstSOF != -1) {
	markerSequence.add(firstSOF, newGuy);
	} else if (firstSOS != -1) {
	markerSequence.add(firstSOS, newGuy);
	} else {
	markerSequence.add(newGuy);
	}
	}
	}

	/**
	* Merge the given DRI node into the marker sequence.
	* If there already exists a DRI marker segment, the restart interval
	* value is updated.
	* If there is no DRI segment, then a new one is created and added as
	* follows:
	* If there is an SOF segment, the new DRI segment is inserted before
	* it.
	* If there is no SOF segment, the new DRI segment is inserted before
	* the first SOS segment, if there is one.
	* If there is no SOS segment, the new DRI segment is added to the end
	* of the sequence.
	*/
	private void mergeDRINode(Node node) throws IIOInvalidTreeException {
	DRIMarkerSegment dri =
	(DRIMarkerSegment) findMarkerSegment(DRIMarkerSegment.class, true);
	if (dri != null) {
	dri.updateFromNativeNode(node, false);
	} else {
	DRIMarkerSegment newGuy = new DRIMarkerSegment(node);
	int firstSOF = findMarkerSegmentPosition(SOFMarkerSegment.class, true);
	int firstSOS = findMarkerSegmentPosition(SOSMarkerSegment.class, true);
	if (firstSOF != -1) {
	markerSequence.add(firstSOF, newGuy);
	} else if (firstSOS != -1) {
	markerSequence.add(firstSOS, newGuy);
	} else {
	markerSequence.add(newGuy);
	}
	}
	}

	/**
	* Merge the given COM node into the marker sequence.
	* A new COM marker segment is created and added to the sequence
	* using insertCOMMarkerSegment.
	*/
	private void mergeCOMNode(Node node) throws IIOInvalidTreeException {
	COMMarkerSegment newGuy = new COMMarkerSegment(node);
	insertCOMMarkerSegment(newGuy);
	}

	/**
	* Insert a new COM marker segment into an appropriate place in the
	* marker sequence, as follows:
	* If there already exist COM marker segments, the new one is inserted
	* after the last one.
	* If there are no COM segments, the new COM segment is inserted after the
	* JFIF segment, if there is one.
	* If there is no JFIF segment, the new COM segment is inserted after the
	* Adobe marker segment, if there is one.
	* If there is no Adobe segment, the new COM segment is inserted
	* at the beginning of the sequence.
	*/
	private void insertCOMMarkerSegment(COMMarkerSegment newGuy) {
	int lastCOM = findMarkerSegmentPosition(COMMarkerSegment.class, false);
	boolean hasJFIF = (findMarkerSegment(JFIFMarkerSegment.class, true) != null);
	int firstAdobe = findMarkerSegmentPosition(AdobeMarkerSegment.class, true);
	if (lastCOM != -1) {
	markerSequence.add(lastCOM+1, newGuy);
	} else if (hasJFIF) {
	markerSequence.add(1, newGuy); // JFIF is always 0
	} else if (firstAdobe != -1) {
	markerSequence.add(firstAdobe+1, newGuy);
	} else {
	markerSequence.add(0, newGuy);
	}
	}

	/**
	* Merge the given Adobe APP14 node into the marker sequence.
	* If there already exists an Adobe marker segment, then its attributes
	* are updated from the node.
	* If there is no Adobe segment, then a new one is created and added
	* using insertAdobeMarkerSegment.
	*/
	private void mergeAdobeNode(Node node) throws IIOInvalidTreeException {
	AdobeMarkerSegment adobe =
	(AdobeMarkerSegment) findMarkerSegment(AdobeMarkerSegment.class, true);
	if (adobe != null) {
	adobe.updateFromNativeNode(node, false);
	} else {
	AdobeMarkerSegment newGuy = new AdobeMarkerSegment(node);
	insertAdobeMarkerSegment(newGuy);
	}
	}

	/**
	* Insert the given AdobeMarkerSegment into the marker sequence, as
	* follows (we assume there is no Adobe segment yet):
	* If there is a JFIF segment, then the new Adobe segment is inserted
	* after it.
	* If there is no JFIF segment, the new Adobe segment is inserted after the
	* last Unknown segment, if there are any.
	* If there are no Unknown segments, the new Adobe segment is inserted
	* at the beginning of the sequence.
	*/
	private void insertAdobeMarkerSegment(AdobeMarkerSegment newGuy) {
	boolean hasJFIF =
	(findMarkerSegment(JFIFMarkerSegment.class, true) != null);
	int lastUnknown = findLastUnknownMarkerSegmentPosition();
	if (hasJFIF) {
	markerSequence.add(1, newGuy); // JFIF is always 0
	} else if (lastUnknown != -1) {
	markerSequence.add(lastUnknown+1, newGuy);
	} else {
	markerSequence.add(0, newGuy);
	}
	}

	/**
	* Merge the given Unknown node into the marker sequence.
	* A new Unknown marker segment is created and added to the sequence as
	* follows:
	* If there already exist Unknown marker segments, the new one is inserted
	* after the last one.
	* If there are no Unknown marker segments, the new Unknown marker segment
	* is inserted after the JFIF segment, if there is one.
	* If there is no JFIF segment, the new Unknown segment is inserted before
	* the Adobe marker segment, if there is one.
	* If there is no Adobe segment, the new Unknown segment is inserted
	* at the beginning of the sequence.
	*/
	private void mergeUnknownNode(Node node) throws IIOInvalidTreeException {
	MarkerSegment newGuy = new MarkerSegment(node);
	int lastUnknown = findLastUnknownMarkerSegmentPosition();
	boolean hasJFIF = (findMarkerSegment(JFIFMarkerSegment.class, true) != null);
	int firstAdobe = findMarkerSegmentPosition(AdobeMarkerSegment.class, true);
	if (lastUnknown != -1) {
	markerSequence.add(lastUnknown+1, newGuy);
	} else if (hasJFIF) {
	markerSequence.add(1, newGuy); // JFIF is always 0
	} if (firstAdobe != -1) {
	markerSequence.add(firstAdobe, newGuy);
	} else {
	markerSequence.add(0, newGuy);
	}
	}

	/**
	* Merge the given SOF node into the marker sequence.
	* If there already exists an SOF marker segment in the sequence, then
	* its values are updated from the node.
	* If there is no SOF segment, then a new one is created and added as
	* follows:
	* If there are any SOS segments, the new SOF segment is inserted before
	* the first one.
	* If there is no SOS segment, the new SOF segment is added to the end
	* of the sequence.
	*
	*/
	private void mergeSOFNode(Node node) throws IIOInvalidTreeException {
	SOFMarkerSegment sof =
	(SOFMarkerSegment) findMarkerSegment(SOFMarkerSegment.class, true);
	if (sof != null) {
	sof.updateFromNativeNode(node, false);
	} else {
	SOFMarkerSegment newGuy = new SOFMarkerSegment(node);
	int firstSOS = findMarkerSegmentPosition(SOSMarkerSegment.class, true);
	if (firstSOS != -1) {
	markerSequence.add(firstSOS, newGuy);
	} else {
	markerSequence.add(newGuy);
	}
	}
	}

	/**
	* Merge the given SOS node into the marker sequence.
	* If there already exists a single SOS marker segment, then the values
	* are updated from the node.
	* If there are more than one existing SOS marker segments, then an
	* IIOInvalidTreeException is thrown, as SOS segments cannot be merged
	* into a set of progressive scans.
	* If there are no SOS marker segments, a new one is created and added
	* to the end of the sequence.
	*/
	private void mergeSOSNode(Node node) throws IIOInvalidTreeException {
	SOSMarkerSegment firstSOS =
	(SOSMarkerSegment) findMarkerSegment(SOSMarkerSegment.class, true);
	SOSMarkerSegment lastSOS =
	(SOSMarkerSegment) findMarkerSegment(SOSMarkerSegment.class, false);
	if (firstSOS != null) {
	if (firstSOS != lastSOS) {
	throw new IIOInvalidTreeException
	("Can't merge SOS node into a tree with > 1 SOS node", node);
	}
	firstSOS.updateFromNativeNode(node, false);
	} else {
	markerSequence.add(new SOSMarkerSegment(node));
	}
	}

	private boolean transparencyDone;

	private void mergeStandardTree(Node root) throws IIOInvalidTreeException {
	transparencyDone = false;
	NodeList children = root.getChildNodes();
	for (int i = 0; i < children.getLength(); i++) {
	Node node = children.item(i);
	String name = node.getNodeName();
	if (name.equals("Chroma")) {
	mergeStandardChromaNode(node, children);
	} else if (name.equals("Compression")) {
	mergeStandardCompressionNode(node);
	} else if (name.equals("Data")) {
	mergeStandardDataNode(node);
	} else if (name.equals("Dimension")) {
	mergeStandardDimensionNode(node);
	} else if (name.equals("Document")) {
	mergeStandardDocumentNode(node);
	} else if (name.equals("Text")) {
	mergeStandardTextNode(node);
	} else if (name.equals("Transparency")) {
	mergeStandardTransparencyNode(node);
	} else {
	throw new IIOInvalidTreeException("Invalid node: " + name, node);
	}
	}
	}

	/*
	* In general, it could be possible to convert all non-pixel data to some
	* textual form and include it in comments, but then this would create the
	* expectation that these comment forms be recognized by the reader, thus
	* creating a defacto extension to JPEG metadata capabilities. This is
	* probably best avoided, so the following convert only text nodes to
	* comments, and lose the keywords as well.
	*/

	private void mergeStandardChromaNode(Node node, NodeList siblings)
	throws IIOInvalidTreeException {
	// ColorSpaceType can change the target colorspace for compression
	// This must take any transparency node into account as well, as
	// that affects the number of channels (if alpha is present). If
	// a transparency node is dealt with here, set a flag to indicate
	// this to the transparency processor below. If we discover that
	// the nodes are not in order, throw an exception as the tree is
	// invalid.

	if (transparencyDone) {
	throw new IIOInvalidTreeException
	("Transparency node must follow Chroma node", node);
	}

	Node csType = node.getFirstChild();
	if ((csType == null) \|\| !csType.getNodeName().equals("ColorSpaceType")) {
	// If there is no ColorSpaceType node, we have nothing to do
	return;
	}

	String csName = csType.getAttributes().getNamedItem("name").getNodeValue();

	int numChannels = 0;
	boolean wantJFIF = false;
	boolean wantAdobe = false;
	int transform = 0;
	boolean willSubsample = false;
	byte [] ids = {1, 2, 3, 4}; // JFIF compatible
	if (csName.equals("GRAY")) {
	numChannels = 1;
	wantJFIF = true;
	} else if (csName.equals("YCbCr")) {
	numChannels = 3;
	wantJFIF = true;
	willSubsample = true;
	} else if (csName.equals("PhotoYCC")) {
	numChannels = 3;
	wantAdobe = true;
	transform = JPEG.ADOBE_YCC;
	ids[0] = (byte) 'Y';
	ids[1] = (byte) 'C';
	ids[2] = (byte) 'c';
	} else if (csName.equals("RGB")) {
	numChannels = 3;
	wantAdobe = true;
	transform = JPEG.ADOBE_UNKNOWN;
	ids[0] = (byte) 'R';
	ids[1] = (byte) 'G';
	ids[2] = (byte) 'B';
	} else if ((csName.equals("XYZ"))
	\|\| (csName.equals("Lab"))
	\|\| (csName.equals("Luv"))
	\|\| (csName.equals("YxY"))
	\|\| (csName.equals("HSV"))
	\|\| (csName.equals("HLS"))
	\|\| (csName.equals("CMY"))
	\|\| (csName.equals("3CLR"))) {
	numChannels = 3;
	} else if (csName.equals("YCCK")) {
	numChannels = 4;
	wantAdobe = true;
	transform = JPEG.ADOBE_YCCK;
	willSubsample = true;
	} else if (csName.equals("CMYK")) {
	numChannels = 4;
	wantAdobe = true;
	transform = JPEG.ADOBE_UNKNOWN;
	} else if (csName.equals("4CLR")) {
	numChannels = 4;
	} else { // We can't handle them, so don't modify any metadata
	return;
	}

	boolean wantAlpha = false;
	for (int i = 0; i < siblings.getLength(); i++) {
	Node trans = siblings.item(i);
	if (trans.getNodeName().equals("Transparency")) {
	wantAlpha = wantAlpha(trans);
	break; // out of for
	}
	}

	if (wantAlpha) {
	numChannels++;
	wantJFIF = false;
	if (ids[0] == (byte) 'R') {
	ids[3] = (byte) 'A';
	wantAdobe = false;
	}
	}

	JFIFMarkerSegment jfif =
	(JFIFMarkerSegment) findMarkerSegment(JFIFMarkerSegment.class, true);
	AdobeMarkerSegment adobe =
	(AdobeMarkerSegment) findMarkerSegment(AdobeMarkerSegment.class, true);
	SOFMarkerSegment sof =
	(SOFMarkerSegment) findMarkerSegment(SOFMarkerSegment.class, true);
	SOSMarkerSegment sos =
	(SOSMarkerSegment) findMarkerSegment(SOSMarkerSegment.class, true);

	// If the metadata specifies progressive, then the number of channels
	// must match, so that we can modify all the existing SOS marker segments.
	// If they don't match, we don't know what to do with SOS so we can't do
	// the merge. We then just return silently.
	// An exception would not be appropriate. A warning might, but we have
	// nowhere to send it to.
	if ((sof != null) && (sof.tag == JPEG.SOF2)) { // Progressive
	if ((sof.componentSpecs.length != numChannels) && (sos != null)) {
	return;
	}
	}

	// JFIF header might be removed
	if (!wantJFIF && (jfif != null)) {
	markerSequence.remove(jfif);
	}

	// Now add a JFIF if we do want one, but only if it isn't stream metadata
	if (wantJFIF && !isStream) {
	markerSequence.add(0, new JFIFMarkerSegment());
	}

	// Adobe header might be removed or the transform modified, if it isn't
	// stream metadata
	if (wantAdobe) {
	if ((adobe == null) && !isStream) {
	adobe = new AdobeMarkerSegment(transform);
	insertAdobeMarkerSegment(adobe);
	} else {
	adobe.transform = transform;
	}
	} else if (adobe != null) {
	markerSequence.remove(adobe);
	}

	boolean updateQtables = false;
	boolean updateHtables = false;

	boolean progressive = false;

	int [] subsampledSelectors = {0, 1, 1, 0 } ;
	int [] nonSubsampledSelectors = { 0, 0, 0, 0};

	int [] newTableSelectors = willSubsample
	? subsampledSelectors
	: nonSubsampledSelectors;

	// Keep the old componentSpecs array
	SOFMarkerSegment.ComponentSpec [] oldCompSpecs = null;
	// SOF might be modified
	if (sof != null) {
	oldCompSpecs = sof.componentSpecs;
	progressive = (sof.tag == JPEG.SOF2);
	// Now replace the SOF with a new one; it might be the same, but
	// this is easier.
	markerSequence.set(markerSequence.indexOf(sof),
	new SOFMarkerSegment(progressive,
	false, // we never need extended
	willSubsample,
	ids,
	numChannels));

	// Now suss out if subsampling changed and set the boolean for
	// updating the q tables
	// if the old componentSpec q table selectors don't match
	// the new ones, update the qtables. The new selectors are already
	// in place in the new SOF segment above.
	for (int i = 0; i < oldCompSpecs.length; i++) {
	if (oldCompSpecs[i].QtableSelector != newTableSelectors[i]) {
	updateQtables = true;
	}
	}

	if (progressive) {
	// if the component ids are different, update all the existing scans
	// ignore Huffman tables
	boolean idsDiffer = false;
	for (int i = 0; i < oldCompSpecs.length; i++) {
	if (ids[i] != oldCompSpecs[i].componentId) {
	idsDiffer = true;
	}
	}
	if (idsDiffer) {
	// update the ids in each SOS marker segment
	for (Iterator iter = markerSequence.iterator(); iter.hasNext();) {
	MarkerSegment seg = (MarkerSegment) iter.next();
	if (seg instanceof SOSMarkerSegment) {
	SOSMarkerSegment target = (SOSMarkerSegment) seg;
	for (int i = 0; i < target.componentSpecs.length; i++) {
	int oldSelector =
	target.componentSpecs[i].componentSelector;
	// Find the position in the old componentSpecs array
	// of the old component with the old selector
	// and replace the component selector with the
	// new id at the same position, as these match
	// the new component specs array in the SOF created
	// above.
	for (int j = 0; j < oldCompSpecs.length; j++) {
	if (oldCompSpecs[j].componentId == oldSelector) {
	target.componentSpecs[i].componentSelector =
	ids[j];
	}
	}
	}
	}
	}
	}
	} else {
	if (sos != null) {
	// htables - if the old htable selectors don't match the new ones,
	// update the tables.
	for (int i = 0; i < sos.componentSpecs.length; i++) {
	if ((sos.componentSpecs[i].dcHuffTable
	!= newTableSelectors[i])
	\|\| (sos.componentSpecs[i].acHuffTable
	!= newTableSelectors[i])) {
	updateHtables = true;
	}
	}

	// Might be the same as the old one, but this is easier.
	markerSequence.set(markerSequence.indexOf(sos),
	new SOSMarkerSegment(willSubsample,
	ids,
	numChannels));
	}
	}
	} else {
	// should be stream metadata if there isn't an SOF, but check it anyway
	if (isStream) {
	// update tables - routines below check if it's really necessary
	updateQtables = true;
	updateHtables = true;
	}
	}

	if (updateQtables) {
	List tableSegments = new ArrayList();
	for (Iterator iter = markerSequence.iterator(); iter.hasNext();) {
	MarkerSegment seg = (MarkerSegment) iter.next();
	if (seg instanceof DQTMarkerSegment) {
	tableSegments.add(seg);
	}
	}
	// If there are no tables, don't add them, as the metadata encodes an
	// abbreviated stream.
	// If we are not subsampling, we just need one, so don't do anything
	if (!tableSegments.isEmpty() && willSubsample) {
	// Is it really necessary? There should be at least 2 tables.
	// If there is only one, assume it's a scaled "standard"
	// luminance table, extract the scaling factor, and generate a
	// scaled "standard" chrominance table.

	// Find the table with selector 1.
	boolean found = false;
	for (Iterator iter = tableSegments.iterator(); iter.hasNext();) {
	DQTMarkerSegment testdqt = (DQTMarkerSegment) iter.next();
	for (Iterator tabiter = testdqt.tables.iterator();
	tabiter.hasNext();) {
	DQTMarkerSegment.Qtable tab =
	(DQTMarkerSegment.Qtable) tabiter.next();
	if (tab.tableID == 1) {
	found = true;
	}
	}
	}
	if (!found) {
	// find the table with selector 0. There should be one.
	DQTMarkerSegment.Qtable table0 = null;
	for (Iterator iter = tableSegments.iterator(); iter.hasNext();) {
	DQTMarkerSegment testdqt = (DQTMarkerSegment) iter.next();
	for (Iterator tabiter = testdqt.tables.iterator();
	tabiter.hasNext();) {
	DQTMarkerSegment.Qtable tab =
	(DQTMarkerSegment.Qtable) tabiter.next();
	if (tab.tableID == 0) {
	table0 = tab;
	}
	}
	}

	// Assuming that the table with id 0 is a luminance table,
	// compute a new chrominance table of the same quality and
	// add it to the last DQT segment
	DQTMarkerSegment dqt =
	(DQTMarkerSegment) tableSegments.get(tableSegments.size()-1);
	dqt.tables.add(dqt.getChromaForLuma(table0));
	}
	}
	}

	if (updateHtables) {
	List tableSegments = new ArrayList();
	for (Iterator iter = markerSequence.iterator(); iter.hasNext();) {
	MarkerSegment seg = (MarkerSegment) iter.next();
	if (seg instanceof DHTMarkerSegment) {
	tableSegments.add(seg);
	}
	}
	// If there are no tables, don't add them, as the metadata encodes an
	// abbreviated stream.
	// If we are not subsampling, we just need one, so don't do anything
	if (!tableSegments.isEmpty() && willSubsample) {
	// Is it really necessary? There should be at least 2 dc and 2 ac
	// tables. If there is only one, add a
	// "standard " chrominance table.

	// find a table with selector 1. AC/DC is irrelevant
	boolean found = false;
	for (Iterator iter = tableSegments.iterator(); iter.hasNext();) {
	DHTMarkerSegment testdht = (DHTMarkerSegment) iter.next();
	for (Iterator tabiter = testdht.tables.iterator();
	tabiter.hasNext();) {
	DHTMarkerSegment.Htable tab =
	(DHTMarkerSegment.Htable) tabiter.next();
	if (tab.tableID == 1) {
	found = true;
	}
	}
	}
	if (!found) {
	// Create new standard dc and ac chrominance tables and add them
	// to the last DHT segment
	DHTMarkerSegment lastDHT =
	(DHTMarkerSegment) tableSegments.get(tableSegments.size()-1);
	lastDHT.addHtable(JPEGHuffmanTable.StdDCLuminance, true, 1);
	lastDHT.addHtable(JPEGHuffmanTable.StdACLuminance, true, 1);
	}
	}
	}
	}

	private boolean wantAlpha(Node transparency) {
	boolean returnValue = false;
	Node alpha = transparency.getFirstChild(); // Alpha must be first if present
	if (alpha.getNodeName().equals("Alpha")) {
	if (alpha.hasAttributes()) {
	String value =
	alpha.getAttributes().getNamedItem("value").getNodeValue();
	if (!value.equals("none")) {
	returnValue = true;
	}
	}
	}
	transparencyDone = true;
	return returnValue;
	}

	private void mergeStandardCompressionNode(Node node)
	throws IIOInvalidTreeException {
	// NumProgressiveScans is ignored. Progression must be enabled on the
	// ImageWriteParam.
	// No-op
	}

	private void mergeStandardDataNode(Node node)
	throws IIOInvalidTreeException {
	// No-op
	}

	private void mergeStandardDimensionNode(Node node)
	throws IIOInvalidTreeException {
	// Pixel Aspect Ratio or pixel size can be incorporated if there is,
	// or can be, a JFIF segment
	JFIFMarkerSegment jfif =
	(JFIFMarkerSegment) findMarkerSegment(JFIFMarkerSegment.class, true);
	if (jfif == null) {
	// Can there be one?
	// Criteria:
	// SOF must be present with 1 or 3 channels, (stream metadata fails this)
	// Component ids must be JFIF compatible.
	boolean canHaveJFIF = false;
	SOFMarkerSegment sof =
	(SOFMarkerSegment) findMarkerSegment(SOFMarkerSegment.class, true);
	if (sof != null) {
	int numChannels = sof.componentSpecs.length;
	if ((numChannels == 1) \|\| (numChannels == 3)) {
	canHaveJFIF = true; // remaining tests are negative
	for (int i = 0; i < sof.componentSpecs.length; i++) {
	if (sof.componentSpecs[i].componentId != i+1)
	canHaveJFIF = false;
	}
	// if Adobe present, transform = ADOBE_UNKNOWN for 1-channel,
	// ADOBE_YCC for 3-channel.
	AdobeMarkerSegment adobe =
	(AdobeMarkerSegment) findMarkerSegment(AdobeMarkerSegment.class,
	true);
	if (adobe != null) {
	if (adobe.transform != ((numChannels == 1)
	? JPEG.ADOBE_UNKNOWN
	: JPEG.ADOBE_YCC)) {
	canHaveJFIF = false;
	}
	}
	}
	}
	// If so, create one and insert it into the sequence. Note that
	// default is just pixel ratio at 1:1
	if (canHaveJFIF) {
	jfif = new JFIFMarkerSegment();
	markerSequence.add(0, jfif);
	}
	}
	if (jfif != null) {
	NodeList children = node.getChildNodes();
	for (int i = 0; i < children.getLength(); i++) {
	Node child = children.item(i);
	NamedNodeMap attrs = child.getAttributes();
	String name = child.getNodeName();
	if (name.equals("PixelAspectRatio")) {
	String valueString = attrs.getNamedItem("value").getNodeValue();
	float value = Float.parseFloat(valueString);
	Point p = findIntegerRatio(value);
	jfif.resUnits = JPEG.DENSITY_UNIT_ASPECT_RATIO;
	jfif.Xdensity = p.x;
	jfif.Xdensity = p.y;
	} else if (name.equals("HorizontalPixelSize")) {
	String valueString = attrs.getNamedItem("value").getNodeValue();
	float value = Float.parseFloat(valueString);
	// Convert from mm/dot to dots/cm
	int dpcm = (int) Math.round(1.0/(value*10.0));
	jfif.resUnits = JPEG.DENSITY_UNIT_DOTS_CM;
	jfif.Xdensity = dpcm;
	} else if (name.equals("VerticalPixelSize")) {
	String valueString = attrs.getNamedItem("value").getNodeValue();
	float value = Float.parseFloat(valueString);
	// Convert from mm/dot to dots/cm
	int dpcm = (int) Math.round(1.0/(value*10.0));
	jfif.resUnits = JPEG.DENSITY_UNIT_DOTS_CM;
	jfif.Ydensity = dpcm;
	}

	}
	}
	}

	/*
	* Return a pair of integers whose ratio (x/y) approximates the given
	* float value.
	*/
	private static Point findIntegerRatio(float value) {
	float epsilon = 0.005F;

	// Normalize
	value = Math.abs(value);

	// Deal with min case
	if (value <= epsilon) {
	return new Point(1, 255);
	}

	// Deal with max case
	if (value >= 255) {
	return new Point(255, 1);
	}

	// Remember if we invert
	boolean inverted = false;
	if (value < 1.0) {
	value = 1.0F/value;
	inverted = true;
	}

	// First approximation
	int y = 1;
	int x = (int) Math.round(value);

	float ratio = (float) x;
	float delta = Math.abs(value - ratio);
	while (delta > epsilon) { // not close enough
	// Increment y and compute a new x
	y++;
	x = (int) Math.round(y*value);
	ratio = (float)x/(float)y;
	delta = Math.abs(value - ratio);
	}
	return inverted ? new Point(y, x) : new Point(x, y);
	}

	private void mergeStandardDocumentNode(Node node)
	throws IIOInvalidTreeException {
	// No-op
	}

	private void mergeStandardTextNode(Node node)
	throws IIOInvalidTreeException {
	// Convert to comments. For the moment ignore the encoding issue.
	// Ignore keywords, language, and encoding (for the moment).
	// If compression tag is present, use only entries with "none".
	NodeList children = node.getChildNodes();
	for (int i = 0; i < children.getLength(); i++) {
	Node child = children.item(i);
	NamedNodeMap attrs = child.getAttributes();
	Node comp = attrs.getNamedItem("compression");
	boolean copyIt = true;
	if (comp != null) {
	String compString = comp.getNodeValue();
	if (!compString.equals("none")) {
	copyIt = false;
	}
	}
	if (copyIt) {
	String value = attrs.getNamedItem("value").getNodeValue();
	COMMarkerSegment com = new COMMarkerSegment(value);
	insertCOMMarkerSegment(com);
	}
	}
	}

	private void mergeStandardTransparencyNode(Node node)
	throws IIOInvalidTreeException {
	// This might indicate that an alpha channel is being added or removed.
	// The nodes must appear in order, and a Chroma node will process any
	// transparency, so process it here only if there was no Chroma node
	// Do nothing for stream metadata
	if (!transparencyDone && !isStream) {
	boolean wantAlpha = wantAlpha(node);
	// do we have alpha already? If the number of channels is 2 or 4,
	// we do, as we don't support CMYK, nor can we add alpha to it
	// The number of channels can be determined from the SOF
	JFIFMarkerSegment jfif = (JFIFMarkerSegment) findMarkerSegment
	(JFIFMarkerSegment.class, true);
	AdobeMarkerSegment adobe = (AdobeMarkerSegment) findMarkerSegment
	(AdobeMarkerSegment.class, true);
	SOFMarkerSegment sof = (SOFMarkerSegment) findMarkerSegment
	(SOFMarkerSegment.class, true);
	SOSMarkerSegment sos = (SOSMarkerSegment) findMarkerSegment
	(SOSMarkerSegment.class, true);

	// We can do nothing for progressive, as we don't know how to
	// modify the scans.
	if ((sof != null) && (sof.tag == JPEG.SOF2)) { // Progressive
	return;
	}

	// Do we already have alpha? We can tell by the number of channels
	// We must have an sof, or we can't do anything further
	if (sof != null) {
	int numChannels = sof.componentSpecs.length;
	boolean hadAlpha = (numChannels == 2) \|\| (numChannels == 4);
	// proceed only if the old state and the new state differ
	if (hadAlpha != wantAlpha) {
	if (wantAlpha) { // Adding alpha
	numChannels++;
	if (jfif != null) {
	markerSequence.remove(jfif);
	}

	// If an adobe marker is present, transform must be UNKNOWN
	if (adobe != null) {
	adobe.transform = JPEG.ADOBE_UNKNOWN;
	}

	// Add a component spec with appropriate parameters to SOF
	SOFMarkerSegment.ComponentSpec [] newSpecs =
	new SOFMarkerSegment.ComponentSpec[numChannels];
	for (int i = 0; i < sof.componentSpecs.length; i++) {
	newSpecs[i] = sof.componentSpecs[i];
	}
	byte oldFirstID = (byte) sof.componentSpecs[0].componentId;
	byte newID = (byte) ((oldFirstID > 1) ? 'A' : 4);
	newSpecs[numChannels-1] =
	sof.getComponentSpec(newID,
	sof.componentSpecs[0].HsamplingFactor,
	sof.componentSpecs[0].QtableSelector);

	sof.componentSpecs = newSpecs;

	// Add a component spec with appropriate parameters to SOS
	SOSMarkerSegment.ScanComponentSpec [] newScanSpecs =
	new SOSMarkerSegment.ScanComponentSpec [numChannels];
	for (int i = 0; i < sos.componentSpecs.length; i++) {
	newScanSpecs[i] = sos.componentSpecs[i];
	}
	newScanSpecs[numChannels-1] =
	sos.getScanComponentSpec (newID, 0);
	sos.componentSpecs = newScanSpecs;
	} else { // Removing alpha
	numChannels--;
	// Remove a component spec from SOF
	SOFMarkerSegment.ComponentSpec [] newSpecs =
	new SOFMarkerSegment.ComponentSpec[numChannels];
	for (int i = 0; i < numChannels; i++) {
	newSpecs[i] = sof.componentSpecs[i];
	}
	sof.componentSpecs = newSpecs;

	// Remove a component spec from SOS
	SOSMarkerSegment.ScanComponentSpec [] newScanSpecs =
	new SOSMarkerSegment.ScanComponentSpec [numChannels];
	for (int i = 0; i < numChannels; i++) {
	newScanSpecs[i] = sos.componentSpecs[i];
	}
	sos.componentSpecs = newScanSpecs;
	}
	}
	}
	}
	}


	public void setFromTree(String formatName, Node root)
	throws IIOInvalidTreeException {
	if (formatName == null) {
	throw new IllegalArgumentException("null formatName!");
	}
	if (root == null) {
	throw new IllegalArgumentException("null root!");
	}
	if (isStream &&
	(formatName.equals(JPEG.nativeStreamMetadataFormatName))) {
	setFromNativeTree(root);
	} else if (!isStream &&
	(formatName.equals(JPEG.nativeImageMetadataFormatName))) {
	setFromNativeTree(root);
	} else if (!isStream &&
	(formatName.equals
	(IIOMetadataFormatImpl.standardMetadataFormatName))) {
	// In this case a reset followed by a merge is correct
	super.setFromTree(formatName, root);
	} else {
	throw new IllegalArgumentException("Unsupported format name: "
	+ formatName);
	}
	}

	private void setFromNativeTree(Node root) throws IIOInvalidTreeException {
	if (resetSequence == null) {
	resetSequence = markerSequence;
	}
	markerSequence = new ArrayList();

	// Build a whole new marker sequence from the tree

	String name = root.getNodeName();
	if (name != ((isStream) ? JPEG.nativeStreamMetadataFormatName
	: JPEG.nativeImageMetadataFormatName)) {
	throw new IIOInvalidTreeException("Invalid root node name: " + name,
	root);
	}
	if (!isStream) {
	if (root.getChildNodes().getLength() != 2) { // JPEGvariety and markerSequence
	throw new IIOInvalidTreeException(
	"JPEGvariety and markerSequence nodes must be present", root);
	}

	Node JPEGvariety = root.getFirstChild();

	if (JPEGvariety.getChildNodes().getLength() != 0) {
	markerSequence.add(new JFIFMarkerSegment(JPEGvariety.getFirstChild()));
	}
	}

	Node markerSequenceNode = isStream ? root : root.getLastChild();
	setFromMarkerSequenceNode(markerSequenceNode);

	}

	void setFromMarkerSequenceNode(Node markerSequenceNode)
	throws IIOInvalidTreeException{

	NodeList children = markerSequenceNode.getChildNodes();
	// for all the children, add a marker segment
	for (int i = 0; i < children.getLength(); i++) {
	Node node = children.item(i);
	String childName = node.getNodeName();
	if (childName.equals("dqt")) {
	markerSequence.add(new DQTMarkerSegment(node));
	} else if (childName.equals("dht")) {
	markerSequence.add(new DHTMarkerSegment(node));
	} else if (childName.equals("dri")) {
	markerSequence.add(new DRIMarkerSegment(node));
	} else if (childName.equals("com")) {
	markerSequence.add(new COMMarkerSegment(node));
	} else if (childName.equals("app14Adobe")) {
	markerSequence.add(new AdobeMarkerSegment(node));
	} else if (childName.equals("unknown")) {
	markerSequence.add(new MarkerSegment(node));
	} else if (childName.equals("sof")) {
	markerSequence.add(new SOFMarkerSegment(node));
	} else if (childName.equals("sos")) {
	markerSequence.add(new SOSMarkerSegment(node));
	} else {
	throw new IIOInvalidTreeException("Invalid "
	+ (isStream ? "stream " : "image ") + "child: "
	+ childName, node);
	}
	}
	}

	/**
	* Check that this metadata object is in a consistent state and
	* return <code>true</code> if it is or <code>false</code>
	* otherwise. All the constructors and modifiers should call
	* this method at the end to guarantee that the data is always
	* consistent, as the writer relies on this.
	*/
	private boolean isConsistent() {
	SOFMarkerSegment sof =
	(SOFMarkerSegment) findMarkerSegment(SOFMarkerSegment.class,
	true);
	JFIFMarkerSegment jfif =
	(JFIFMarkerSegment) findMarkerSegment(JFIFMarkerSegment.class,
	true);
	AdobeMarkerSegment adobe =
	(AdobeMarkerSegment) findMarkerSegment(AdobeMarkerSegment.class,
	true);
	boolean retval = true;
	if (!isStream) {
	if (sof != null) {
	// SOF numBands = total scan bands
	int numSOFBands = sof.componentSpecs.length;
	int numScanBands = countScanBands();
	if (numScanBands != 0) { // No SOS is OK
	if (numScanBands != numSOFBands) {
	retval = false;
	}
	}
	// If JFIF is present, component ids are 1-3, bands are 1 or 3
	if (jfif != null) {
	if ((numSOFBands != 1) && (numSOFBands != 3)) {
	retval = false;
	}
	for (int i = 0; i < numSOFBands; i++) {
	if (sof.componentSpecs[i].componentId != i+1) {
	retval = false;
	}
	}

	// If both JFIF and Adobe are present,
	// Adobe transform == unknown for gray,
	// YCC for 3-chan.
	if ((adobe != null)
	&& (((numSOFBands == 1)
	&& (adobe.transform != JPEG.ADOBE_UNKNOWN))
	\|\| ((numSOFBands == 3)
	&& (adobe.transform != JPEG.ADOBE_YCC)))) {
	retval = false;
	}
	}
	} else {
	// stream can't have jfif, adobe, sof, or sos
	SOSMarkerSegment sos =
	(SOSMarkerSegment) findMarkerSegment(SOSMarkerSegment.class,
	true);
	if ((jfif != null) \|\| (adobe != null)
	\|\| (sof != null) \|\| (sos != null)) {
	retval = false;
	}
	}
	}
	return retval;
	}

	/**
	* Returns the total number of bands referenced in all SOS marker
	* segments, including 0 if there are no SOS marker segments.
	*/
	private int countScanBands() {
	List ids = new ArrayList();
	Iterator iter = markerSequence.iterator();
	while(iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment)iter.next();
	if (seg instanceof SOSMarkerSegment) {
	SOSMarkerSegment sos = (SOSMarkerSegment) seg;
	SOSMarkerSegment.ScanComponentSpec [] specs = sos.componentSpecs;
	for (int i = 0; i < specs.length; i++) {
	Integer id = new Integer(specs[i].componentSelector);
	if (!ids.contains(id)) {
	ids.add(id);
	}
	}
	}
	}

	return ids.size();
	}

	///// Writer support

	void writeToStream(ImageOutputStream ios,
	boolean ignoreJFIF,
	boolean forceJFIF,
	List thumbnails,
	ICC_Profile iccProfile,
	boolean ignoreAdobe,
	int newAdobeTransform,
	JPEGImageWriter writer)
	throws IOException {
	if (forceJFIF) {
	// Write a default JFIF segment, including thumbnails
	// This won't be duplicated below because forceJFIF will be
	// set only if there is no JFIF present already.
	JFIFMarkerSegment.writeDefaultJFIF(ios,
	thumbnails,
	iccProfile,
	writer);
	if ((ignoreAdobe == false)
	&& (newAdobeTransform != JPEG.ADOBE_IMPOSSIBLE)) {
	if ((newAdobeTransform != JPEG.ADOBE_UNKNOWN)
	&& (newAdobeTransform != JPEG.ADOBE_YCC)) {
	// Not compatible, so ignore Adobe.
	ignoreAdobe = true;
	writer.warningOccurred
	(JPEGImageWriter.WARNING_METADATA_ADJUSTED_FOR_THUMB);
	}
	}
	}
	// Iterate over each MarkerSegment
	Iterator iter = markerSequence.iterator();
	while(iter.hasNext()) {
	MarkerSegment seg = (MarkerSegment)iter.next();
	if (seg instanceof JFIFMarkerSegment) {
	if (ignoreJFIF == false) {
	JFIFMarkerSegment jfif = (JFIFMarkerSegment) seg;
	jfif.writeWithThumbs(ios, thumbnails, writer);
	if (iccProfile != null) {
	JFIFMarkerSegment.writeICC(iccProfile, ios);
	}
	} // Otherwise ignore it, as requested
	} else if (seg instanceof AdobeMarkerSegment) {
	if (ignoreAdobe == false) {
	if (newAdobeTransform != JPEG.ADOBE_IMPOSSIBLE) {
	AdobeMarkerSegment newAdobe =
	(AdobeMarkerSegment) seg.clone();
	newAdobe.transform = newAdobeTransform;
	newAdobe.write(ios);
	} else if (forceJFIF) {
	// If adobe isn't JFIF compatible, ignore it
	AdobeMarkerSegment adobe = (AdobeMarkerSegment) seg;
	if ((adobe.transform == JPEG.ADOBE_UNKNOWN)
	\|\| (adobe.transform == JPEG.ADOBE_YCC)) {
	adobe.write(ios);
	} else {
	writer.warningOccurred
	(JPEGImageWriter.WARNING_METADATA_ADJUSTED_FOR_THUMB);
	}
	} else {
	seg.write(ios);
	}
	} // Otherwise ignore it, as requested
	} else {
	seg.write(ios);
	}
	}
	}

	//// End of writer support

	public void reset() {
	if (resetSequence != null) { // Otherwise no need to reset
	markerSequence = resetSequence;
	resetSequence = null;
	}
	}

	public void print() {
	for (int i = 0; i < markerSequence.size(); i++) {
	MarkerSegment seg = (MarkerSegment) markerSequence.get(i);
	seg.print();
	}
	}

	}

Back to index...