Java example source code file (JFIFMarkerSegment.java)
The JFIFMarkerSegment.java Java example source code/*
* 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 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 is not
Other Java examples (source code examples)Here is a short list of links related to this Java JFIFMarkerSegment.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
