Mega Code Archive
Encodes a java awt Image into PNG format
<![CDATA[
/*
* This file is part of the Echo Web Application Framework (hereinafter "Echo").
* Copyright (C) 2002-2009 NextApp, Inc.
*
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*/
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import java.awt.image.IndexColorModel;
import java.awt.image.PixelGrabber;
import java.awt.image.Raster;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.zip.CheckedOutputStream;
import java.util.zip.Checksum;
import java.util.zip.CRC32;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import javax.swing.ImageIcon;
/**
* Encodes a java.awt.Image into PNG format.
* For more information on the PNG specification, see the W3C PNG page at
* <a href="http://www.w3.org/TR/REC-png.html">http://www.w3.org/TR/REC-png.html</a>.
*/
public class PngEncoder {
/**
* Utility class for converting <code>Image</code>s to <code>BufferedImage</code>s.
*/
private static class ImageToBufferedImage {
/**
* Converts an <code>Image</code> to a <code>BufferedImage</code>.
* If the image is already a <code>BufferedImage</code>, the original is returned.
*
* @param image the image to convert
* @return the image as a <code>BufferedImage</code>
*/
static BufferedImage toBufferedImage(Image image) {
if (image instanceof BufferedImage) {
// Return image unchanged if it is already a BufferedImage.
return (BufferedImage) image;
}
// Ensure image is loaded.
image = new ImageIcon(image).getImage();
int type = hasAlpha(image) ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
BufferedImage bufferedImage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
Graphics g = bufferedImage.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
return bufferedImage;
}
/**
* Determines if an image has an alpha channel.
*
* @param image the <code>Image</code>
* @return true if the image has an alpha channel
*/
static boolean hasAlpha(Image image) {
PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
try {
pg.grabPixels();
} catch (InterruptedException ex) { }
return pg.getColorModel().hasAlpha();
}
}
/** <code>SubFilter</code> singleton. */
public static final Filter SUB_FILTER = new SubFilter();
/** <code>UpFilter</code> singleton. */
public static final Filter UP_FILTER = new UpFilter();
/** <code>AverageFilter</code> singleton. */
public static final Filter AVERAGE_FILTER = new AverageFilter();
/** <code>PaethFilter</code> singleton. */
public static final Filter PAETH_FILTER = new PaethFilter();
/** PNG signature bytes. */
private static final byte[] SIGNATURE = { (byte)0x89, (byte)0x50, (byte)0x4e, (byte)0x47,
(byte)0x0d, (byte)0x0a, (byte)0x1a, (byte)0x0a };
/** Image header (IHDR) chunk header. */
private static final byte[] IHDR = { (byte) 'I', (byte) 'H', (byte) 'D', (byte) 'R' };
/** Palate (PLTE) chunk header. */
private static final byte[] PLTE = { (byte) 'P', (byte) 'L', (byte) 'T', (byte) 'E' };
/** Image Data (IDAT) chunk header. */
private static final byte[] IDAT = { (byte) 'I', (byte) 'D', (byte) 'A', (byte) 'T' };
/** End-of-file (IEND) chunk header. */
private static final byte[] IEND = { (byte) 'I', (byte) 'E', (byte) 'N', (byte) 'D' };
/** Sub filter type constant. */
private static final int SUB_FILTER_TYPE = 1;
/** Up filter type constant. */
private static final int UP_FILTER_TYPE = 2;
/** Average filter type constant. */
private static final int AVERAGE_FILTER_TYPE = 3;
/** Paeth filter type constant. */
private static final int PAETH_FILTER_TYPE = 4;
/** Image bit depth. */
private static final byte BIT_DEPTH = (byte) 8;
/** Indexed color type rendered value. */
private static final byte COLOR_TYPE_INDEXED = (byte) 3;
/** RGB color type rendered value. */
private static final byte COLOR_TYPE_RGB = (byte) 2;
/** RGBA color type rendered value. */
private static final byte COLOR_TYPE_RGBA = (byte) 6;
/** Integer-to-integer map used for RGBA/ARGB conversion. */
private static final int[] INT_TRANSLATOR_CHANNEL_MAP = new int[]{2, 1, 0, 3};
/**
* Writes an 32-bit integer value to the output stream.
*
* @param out the stream
* @param i the value
*/
private static void writeInt(OutputStream out, int i)
throws IOException {
out.write(new byte[]{(byte) (i >> 24),
(byte) ((i >> 16) & 0xff),
(byte) ((i >> 8) & 0xff),
(byte) (i & 0xff)});
}
/**
* An interface for PNG filters. Filters are used to modify the method in
* which pixels of the image are stored in ways that will achieve better
* compression.
*/
public interface Filter {
/**
* Filters the data in a given row of the image.
*
* @param currentRow a byte array containing the data of the row of the
* image to be filtered
* @param previousRow a byte array containing the data of the previous
* row of the image to be filtered
* @param filterOutput a byte array into which the filtered data will
* be placed
*/
public void filter(byte[] filterOutput, byte[] currentRow, byte[] previousRow, int outputBpp);
/**
* Returns the PNG type code for the filter.
*/
public int getType();
}
/**
* An implementation of a "Sub" filter.
*/
private static class SubFilter
implements Filter {
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#filter(byte[], byte[], byte[], int)
*/
public void filter(byte[] filterOutput, byte[] currentRow, byte[] previousRow, int outputBpp) {
for (int index = 0; index < filterOutput.length; ++index) {
if (index < outputBpp) {
filterOutput[index] = currentRow[index];
} else {
filterOutput[index] = (byte) (currentRow[index] - currentRow[index - outputBpp]);
}
}
}
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#getType()
*/
public int getType() {
return SUB_FILTER_TYPE;
}
}
/**
* An implementation of an "Up" filter.
*/
private static class UpFilter
implements Filter {
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#filter(byte[], byte[], byte[], int)
*/
public void filter(byte[] filterOutput, byte[] currentRow, byte[] previousRow, int outputBpp) {
for (int index = 0; index < currentRow.length; ++index) {
filterOutput[index] = (byte) (currentRow[index] - previousRow[index]);
}
}
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#getType()
*/
public int getType() {
return UP_FILTER_TYPE;
}
}
/**
* An implementation of an "Average" filter.
*/
private static class AverageFilter
implements Filter {
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#filter(byte[], byte[], byte[], int)
*/
public void filter(byte[] filterOutput, byte[] currentRow, byte[] previousRow, int outputBpp) {
int w, n;
for (int index = 0; index < filterOutput.length; ++index) {
n = (previousRow[index] + 0x100) & 0xff;
if (index < outputBpp) {
w = 0;
} else {
w = (currentRow[index - outputBpp] + 0x100) & 0xff;
}
filterOutput[index] = (byte) (currentRow[index] - (byte) ((w + n) / 2));
}
}
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#getType()
*/
public int getType() {
return AVERAGE_FILTER_TYPE;
}
}
/**
* An implementation of a "Paeth" filter.
*/
private static class PaethFilter
implements Filter {
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#filter(byte[], byte[], byte[], int)
*/
public void filter(byte[] filterOutput, byte[] currentRow, byte[] previousRow, int outputBpp) {
byte pv;
int n, w, nw, p, pn, pw, pnw;
for (int index = 0; index < filterOutput.length; ++index) {
n = (previousRow[index] + 0x100) & 0xff;
if (index < outputBpp) {
w = 0;
nw = 0;
} else {
w = (currentRow[index - outputBpp] + 0x100) & 0xff;
nw = (previousRow[index - outputBpp] + 0x100) & 0xff;
}
p = w + n - nw;
pw = Math.abs(p - w);
pn = Math.abs(p - n);
pnw = Math.abs(p - w);
if (pw <= pn && pw <= pnw) {
pv = (byte) w;
} else if (pn <= pnw) {
pv = (byte) n;
} else {
pv = (byte) nw;
}
filterOutput[index] = (byte) (currentRow[index] - pv);
}
}
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Filter#getType()
*/
public int getType() {
return PAETH_FILTER_TYPE;
}
}
/**
* An interface for translators, which translate pixel data from a
* writable raster into an R/G/B/A ordering required by the PNG
* specification. Pixel data in the raster might be available
* in three bytes per pixel, four bytes per pixel, or as integers.
*/
interface Translator {
/**
* Translates a row of the image into a byte array ordered
* properly for a PNG image.
*
* @param outputPixelQueue the byte array in which to store the
* translated pixels
* @param row the row index of the image to translate
*/
public void translate(byte[] outputPixelQueue, int row);
}
/**
* Translates byte-based rasters.
*/
private class ByteTranslator
implements Translator {
int rowWidth = width * outputBpp; // size of image data in a row in bytes.
byte[] inputPixelQueue = new byte[rowWidth + outputBpp];
int column;
int channel;
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Translator#translate(byte[], int)
*/
public void translate(byte[] outputPixelQueue, int row) {
raster.getDataElements(0, row, width, 1, inputPixelQueue);
for (column = 0; column < width; ++column) {
for (channel = 0; channel < outputBpp; ++channel) {
outputPixelQueue[column * outputBpp + channel]
= inputPixelQueue[column * inputBpp + channel];
}
}
}
}
/**
* Translates integer-based rasters.
*/
private class IntTranslator
implements Translator {
int[] inputPixelQueue = new int[width];
int column;
int channel;
/**
* @see nextapp.echo.webcontainer.util.PngEncoder.Translator#translate(byte[], int)
*/
public void translate(byte[] outputPixelQueue, int row) {
image.getRGB(0, row, width, 1, inputPixelQueue, 0, width);
// Line below (commented out) replaces line above, almost halving time to encode, but doesn't work with certain pixel
// arrangements. Need to find method of determining pixel order (BGR vs RGB, ARGB, etc)
//
// raster.getDataElements(0, row, width, 1, inputPixelQueue);
for (column = 0; column < width; ++column) {
for (channel = 0; channel < outputBpp; ++channel) {
outputPixelQueue[column * outputBpp + channel]
= (byte) (inputPixelQueue[column] >> (INT_TRANSLATOR_CHANNEL_MAP[channel] * 8));
}
}
}
}
/** The image being encoded. */
private BufferedImage image;
/** The PNG encoding filter to be used. */
private Filter filter;
/** The the deflater compression level. */
private int compressionLevel;
/** The pixel width of the image. */
private int width;
/** The pixel height of the image. */
private int height;
/** The image <code>Raster</code> transfer type. */
private int transferType;
/** The image <code>Raster</code> data. */
private Raster raster;
/** The source image bits-per-pixel. */
private int inputBpp;
/** The encoded image bits-per-pixel. */
private int outputBpp;
/** The <code>Translator</code> being used for encoding. */
private Translator translator;
/**
* Creates a PNG encoder for an image.
*
* @param image the image to be encoded
* @param encodeAlpha true if the image's alpha channel should be encoded
* @param filter The filter to be applied to the image data, one of the
* following values:
* <ul>
* <li>SUB_FILTER</li>
* <li>UP_FILTER</li>
* <li>AVERAGE_FILTER</li>
* <li>PAETH_FILTER</li>
* </ul>
* If a null value is specified, no filtering will be performed.
* @param compressionLevel the deflater compression level that will be used
* for compressing the image data: Valid values range from 0 to 9.
* Higher values result in smaller files and therefore decrease
* network traffic, but require more CPU time to encode. The normal
* compromise value is 3.
*/
public PngEncoder(Image image, boolean encodeAlpha, Filter filter, int compressionLevel) {
super();
this.image = ImageToBufferedImage.toBufferedImage(image);
this.filter = filter;
this.compressionLevel = compressionLevel;
width = this.image.getWidth(null);
height = this.image.getHeight(null);
raster = this.image.getRaster();
transferType = raster.getTransferType();
// Establish storage information
int dataBytes = raster.getNumDataElements();
if (transferType == DataBuffer.TYPE_BYTE && dataBytes == 4) {
outputBpp = encodeAlpha ? 4 : 3;
inputBpp = 4;
translator = new ByteTranslator();
} else if (transferType == DataBuffer.TYPE_BYTE && dataBytes == 3) {
outputBpp = 3;
inputBpp = 3;
encodeAlpha = false;
translator = new ByteTranslator();
} else if (transferType == DataBuffer.TYPE_INT && dataBytes == 1) {
outputBpp = encodeAlpha ? 4 : 3;
inputBpp = 4;
translator = new IntTranslator();
} else if (transferType == DataBuffer.TYPE_BYTE && dataBytes == 1) {
throw new UnsupportedOperationException("Encoding indexed-color images not yet supported.");
} else {
throw new IllegalArgumentException(
"Cannot determine appropriate bits-per-pixel for provided image.");
}
}
/**
* Encodes the image.
*
* @param out an OutputStream to which the encoded image will be
* written
* @throws IOException if a problem is encountered writing the output
*/
public synchronized void encode(OutputStream out)
throws IOException {
Checksum csum = new CRC32();
out = new CheckedOutputStream(out, csum);
out.write(SIGNATURE);
writeIhdrChunk(out, csum);
if (outputBpp == 1) {
writePlteChunk(out, csum);
}
writeIdatChunks(out, csum);
writeIendChunk(out, csum);
}
/**
* Writes the IDAT (Image data) chunks to the output stream.
*
* @param out the OutputStream to write the chunk to
* @param csum the Checksum that is updated as data is written
* to the passed-in OutputStream
* @throws IOException if a problem is encountered writing the output
*/
private void writeIdatChunks(OutputStream out, Checksum csum)
throws IOException {
int rowWidth = width * outputBpp; // size of image data in a row in bytes.
int row = 0;
Deflater deflater = new Deflater(compressionLevel);
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
DeflaterOutputStream defOut = new DeflaterOutputStream(byteOut, deflater);
byte[] filteredPixelQueue = new byte[rowWidth];
// Output Pixel Queues
byte[][] outputPixelQueue = new byte[2][rowWidth];
Arrays.fill(outputPixelQueue[1], (byte) 0);
int outputPixelQueueRow = 0;
int outputPixelQueuePrevRow = 1;
while (row < height) {
if (filter == null) {
defOut.write(0);
translator.translate(outputPixelQueue[outputPixelQueueRow], row);
defOut.write(outputPixelQueue[outputPixelQueueRow], 0, rowWidth);
} else {
defOut.write(filter.getType());
translator.translate(outputPixelQueue[outputPixelQueueRow], row);
filter.filter(filteredPixelQueue, outputPixelQueue[outputPixelQueueRow],
outputPixelQueue[outputPixelQueuePrevRow], outputBpp);
defOut.write(filteredPixelQueue, 0, rowWidth);
}
++row;
outputPixelQueueRow = row & 1;
outputPixelQueuePrevRow = outputPixelQueueRow ^ 1;
}
defOut.finish();
byteOut.close();
writeInt(out, byteOut.size());
csum.reset();
out.write(IDAT);
byteOut.writeTo(out);
writeInt(out, (int) csum.getValue());
}
/**
* Writes the IEND (End-of-file) chunk to the output stream.
*
* @param out the OutputStream to write the chunk to
* @param csum the Checksum that is updated as data is written
* to the passed-in OutputStream
* @throws IOException if a problem is encountered writing the output
*/
private void writeIendChunk(OutputStream out, Checksum csum)
throws IOException {
writeInt(out, 0);
csum.reset();
out.write(IEND);
writeInt(out, (int) csum.getValue());
}
/**
* writes the IHDR (Image Header) chunk to the output stream
*
* @param out the OutputStream to write the chunk to
* @param csum the Checksum that is updated as data is written
* to the passed-in OutputStream
* @throws IOException if a problem is encountered writing the output
*/
private void writeIhdrChunk(OutputStream out, Checksum csum)
throws IOException {
writeInt(out, 13); // Chunk Size
csum.reset();
out.write(IHDR);
writeInt(out, width);
writeInt(out, height);
out.write(BIT_DEPTH);
switch (outputBpp) {
case 1:
out.write(COLOR_TYPE_INDEXED);
break;
case 3:
out.write(COLOR_TYPE_RGB);
break;
case 4:
out.write(COLOR_TYPE_RGBA);
break;
default:
throw new IllegalStateException("Invalid bytes per pixel");
}
out.write(0); // Compression Method
out.write(0); // Filter Method
out.write(0); // Interlace
writeInt(out, (int) csum.getValue());
}
/**
* Writes the PLTE (Palate) chunk to the output stream.
*
* @param out the OutputStream to write the chunk to
* @param csum the Checksum that is updated as data is written
* to the passed-in OutputStream
* @throws IOException if a problem is encountered writing the output
*/
private void writePlteChunk(OutputStream out, Checksum csum)
throws IOException {
IndexColorModel icm = (IndexColorModel) image.getColorModel();
writeInt(out, 768); // Chunk Size
csum.reset();
out.write(PLTE);
byte[] reds = new byte[256];
icm.getReds(reds);
byte[] greens = new byte[256];
icm.getGreens(greens);
byte[] blues = new byte[256];
icm.getBlues(blues);
for (int index = 0; index < 256; ++index) {
out.write(reds[index]);
out.write(greens[index]);
out.write(blues[index]);
}
writeInt(out, (int) csum.getValue());
}
}
]]>