2 * This file was adapted from Jason Marshall's PNGImageProducer.java
4 * Copyright (c) 1997, Jason Marshall. All Rights Reserved
6 * The author makes no representations or warranties regarding the suitability,
7 * reliability or stability of this code. This code is provided AS IS. The
8 * author shall not be liable for any damages suffered as a result of using,
9 * modifying or redistributing this software or any derivitives thereof.
10 * Permission to use, reproduce, modify and/or (re)distribute this software is
16 import org.xwt.util.*;
18 import java.util.Hashtable;
19 import java.util.Vector;
20 import java.util.Enumeration;
21 import java.util.zip.*;
23 /** Converts an InputStream carrying a PNG image into an ARGB int[] */
24 public class PNG implements ImageDecoder {
26 // Public Methods ///////////////////////////////////////////////////////////////////////////////
28 /** returns the ARGB int[] representing the last image processed */
29 public final int[] getData() { return data; }
31 /** returns the width of the last image processed */
32 public final int getWidth() { return width; }
34 /** returns the height of the last image processed */
35 public final int getHeight() { return height; }
37 /** process a PNG as an inputstream; returns null if there is an error
38 @param name A string describing the image, to be used when logging errors
40 public static PNG decode(InputStream is, String name) {
42 return new PNG(is, name);
43 } catch (Exception e) {
44 if (Log.on) Log.log(PNG.class, e);
49 private PNG(InputStream is, String name) throws IOException {
50 underlyingStream = is;
52 inputStream = new DataInputStream(underlyingStream);
55 if ((inputStream.read() != 137) || (inputStream.read() != 80) || (inputStream.read() != 78) || (inputStream.read() != 71) ||
56 (inputStream.read() != 13) || (inputStream.read() != 10) || (inputStream.read() != 26) || (inputStream.read() != 10)) {
57 System.out.println("PNG: error: input file " + name + " is not a PNG file");
63 DONE: while (!error) {
65 chunkLength = inputStream.readInt();
66 chunkType = inputStream.readInt();
67 needChunkInfo = false;
71 case CHUNK_bKGD: inputStream.skip(chunkLength); break;
72 case CHUNK_cHRM: inputStream.skip(chunkLength); break;
73 case CHUNK_gAMA: inputStream.skip(chunkLength); break;
74 case CHUNK_hIST: inputStream.skip(chunkLength); break;
75 case CHUNK_pHYs: inputStream.skip(chunkLength); break;
76 case CHUNK_sBIT: inputStream.skip(chunkLength); break;
77 case CHUNK_tEXt: inputStream.skip(chunkLength); break;
78 case CHUNK_zTXt: inputStream.skip(chunkLength); break;
79 case CHUNK_tIME: inputStream.skip(chunkLength); break;
81 case CHUNK_IHDR: handleIHDR(); break;
82 case CHUNK_PLTE: handlePLTE(); break;
83 case CHUNK_tRNS: handletRNS(); break;
85 case CHUNK_IDAT: handleIDAT(); break;
87 case CHUNK_IEND: break DONE;
89 System.err.println("unrecognized chunk type " +
90 Integer.toHexString(chunkType) + ". skipping");
91 inputStream.skip(chunkLength);
94 int crc = inputStream.readInt();
99 // Chunk Handlers ///////////////////////////////////////////////////////////////////////
101 /** handle data chunk */
102 private void handleIDAT() throws IOException {
103 if (width == -1 || height == -1) throw new IOException("never got image width/height");
105 case 1: mask = 0x1; break;
106 case 2: mask = 0x3; break;
107 case 4: mask = 0xf; break;
108 case 8: case 16: mask = 0xff; break;
109 default: mask = 0x0; break;
111 if (depth < 8) smask = mask << depth;
112 else smask = mask << 8;
114 int count = width * height;
121 ipixels = new int[count];
125 bpixels = new byte[count];
129 throw new IOException("Image has unknown color type");
131 if (interlaceMethod != 0) multipass = true;
135 /** handle header chunk */
136 private void handleIHDR() throws IOException {
137 if (headerFound) throw new IOException("Extraneous IHDR chunk encountered.");
138 if (chunkLength != 13) throw new IOException("IHDR chunk length wrong: " + chunkLength);
139 width = inputStream.readInt();
140 height = inputStream.readInt();
141 depth = inputStream.read();
142 colorType = inputStream.read();
143 compressionMethod = inputStream.read();
144 filterMethod = inputStream.read();
145 interlaceMethod = inputStream.read();
148 /** handle pallette chunk */
149 private void handlePLTE() throws IOException {
150 if (colorType == 3) {
151 palette = new byte[chunkLength];
152 inputStream.readFully(palette);
154 // Ignore suggested palette
155 inputStream.skip(chunkLength);
159 /** handle transparency chunk; modifies palette */
160 private void handletRNS() throws IOException {
161 int chunkLen = chunkLength;
162 if (palette == null) throw new IOException("tRNS chunk encountered before pLTE");
163 int len = palette.length;
164 if (colorType == 3) {
167 int transLength = len/3;
168 byte[] trans = new byte[transLength];
169 for (int i = 0; i < transLength; i++) trans[i] = (byte) 0xff;
170 inputStream.readFully(trans, 0, chunkLength);
172 byte[] newPalette = new byte[len + transLength];
173 for (int i = newPalette.length; i > 0;) {
174 newPalette[--i] = trans[--transLength];
175 newPalette[--i] = palette[--len];
176 newPalette[--i] = palette[--len];
177 newPalette[--i] = palette[--len];
179 palette = newPalette;
182 inputStream.skip(chunkLength);
186 /// Helper functions for IDAT ///////////////////////////////////////////////////////////////////////////////////////////
188 /** Read Image data in off of a compression stream */
189 private void readImageData() throws IOException {
190 InputStream dataStream = new SequenceInputStream(new IDATEnumeration(this));
191 DataInputStream dis = new DataInputStream(new BufferedInputStream(new InflaterInputStream(dataStream, new Inflater())));
192 int bps, filterOffset;
194 case 0: case 3: bps = depth; break;
195 case 2: bps = 3 * depth; break;
196 case 4: bps = depth<<1; break;
197 case 6: bps = depth<<2; break;
198 default: throw new IOException("Unknown color type encountered.");
201 filterOffset = (bps + 7) >> 3;
203 for (pass = (multipass ? 1 : 0); pass < 8; pass++) {
204 int pass = this.pass;
205 int rInc = rowInc[pass];
206 int cInc = colInc[pass];
207 int sCol = startingCol[pass];
208 int val = (width - sCol + cInc - 1) / cInc;
209 int samples = val * filterOffset;
210 int rowSize = (val * bps)>>3;
211 int sRow = startingRow[pass];
212 if (height <= sRow || rowSize == 0) continue;
213 int sInc = rInc * width;
214 byte inbuf[] = new byte[rowSize];
215 int pix[] = new int[rowSize];
217 int temp[] = new int[rowSize];
218 int nextY = sRow; // next Y value and number of rows to report to sendPixels
220 int rowStart = sRow * width;
222 for (int y = sRow; y < height; y += rInc, rowStart += sInc) {
224 int rowFilter = dis.read();
225 dis.readFully(inbuf);
226 if (!filterRow(inbuf, pix, upix, rowFilter, filterOffset)) throw new IOException("Unknown filter type: " + rowFilter);
227 insertPixels(pix, rowStart + sCol, samples);
228 if (multipass && (pass < 6)) blockFill(rowStart);
233 if (!multipass) break;
235 while(dis.read() != -1) System.err.println("Leftover data encountered.");
237 // 24-bit color is our native format
238 if (colorType == 2 || colorType == 6) {
239 data = (int[])pixels;
240 if (colorType == 2) {
241 for(int i=0; i<data.length; i++)
242 data[i] |= 0xFF000000;
245 } else if (colorType == 3) {
246 byte[] pix = (byte[])pixels;
247 data = new int[pix.length];
248 for(int i=0; i<pix.length; i++) {
251 ((palette[4 * (pix[i] & 0xff) + 3] & 0xff) << 24) |
252 ((palette[4 * (pix[i] & 0xff) + 0] & 0xff) << 16) |
253 ((palette[4 * (pix[i] & 0xff) + 1] & 0xff) << 8) |
254 (palette[4 * (pix[i] & 0xff) + 2] & 0xff);
258 ((palette[3 * pix[i] + 0] & 0xff) << 16) |
259 ((palette[3 * pix[i] + 1] & 0xff) << 8) |
260 (palette[3 * pix[i] + 2] & 0xff);
264 } else if (colorType == 0 || colorType == 4) {
265 if (depth == 16) depth = 8;
266 int[] pix = (int[])pixels;
267 data = new int[pix.length];
268 for(int i=0; i<pix.length; i ++) {
269 if (colorType == 0) {
270 int val = (pix[i] & 0xff) << (8 - depth);
277 int alpha = (pix[i] & mask) << (8 - depth);
278 int val = ((pix[i] & smask) >> depth) << (8 - depth);
290 private void insertGreyPixels(int pix[], int offset, int samples) {
292 int ipix[] = ipixels;
293 int cInc = colInc[pass];
296 if (colorType == 0) {
299 for (int j = 0; j < samples; j++, offset += cInc) {
301 else { rs = 7; p = pix[j>>3]; }
302 ipix[offset] = (p>>rs) & 0x1;
306 for (int j = 0; j < samples; j++, offset += cInc) {
307 if (rs != 0) rs -= 2;
308 else { rs = 6; p = pix[j>>2]; }
309 ipix[offset] = (p>>rs) & 0x3;
313 for (int j = 0; j < samples; j++, offset += cInc) {
315 else { rs = 4; p = pix[j>>1]; }
316 ipix[offset] = (p>>rs) & 0xf;
320 for (int j = 0; j < samples; offset += cInc) ipix[offset] = (byte) pix[j++];
323 samples = samples<<1;
324 for (int j = 0; j < samples; j += 2, offset += cInc) ipix[offset] = pix[j];
328 } else if (colorType == 4) {
330 for (int j = 0; j < samples; offset += cInc) ipix[offset] = (pix[j++]<<8) | pix[j++];
332 samples = samples<<1;
333 for (int j = 0; j < samples; j += 2, offset += cInc) ipix[offset] = (pix[j]<<8) | pix[j+=2];
338 private void insertPalettedPixels(int pix[], int offset, int samples) {
341 byte bpix[] = bpixels;
342 int cInc = colInc[pass];
346 for (int j = 0; j < samples; j++, offset += cInc) {
348 else { rs = 7; p = pix[j>>3]; }
349 bpix[offset] = (byte) ((p>>rs) & 0x1);
353 for (int j = 0; j < samples; j++, offset += cInc) {
354 if (rs != 0) rs -= 2;
355 else { rs = 6; p = pix[j>>2]; }
356 bpix[offset] = (byte) ((p>>rs) & 0x3);
360 for (int j = 0; j < samples; j++, offset += cInc) {
362 else { rs = 4; p = pix[j>>1]; }
363 bpix[offset] = (byte) ((p>>rs) & 0xf);
367 for (int j = 0; j < samples; j++, offset += cInc) bpix[offset] = (byte) pix[j];
372 private void insertPixels(int pix[], int offset, int samples) {
376 insertGreyPixels(pix, offset, samples);
380 int ipix[] = ipixels;
381 int cInc = colInc[pass];
383 for (j = 0; j < samples; offset += cInc)
384 ipix[offset] = (pix[j++]<<16) | (pix[j++]<<8) | pix[j++];
386 samples = samples<<1;
387 for (j = 0; j < samples; j += 2, offset += cInc)
388 ipix[offset] = (pix[j]<<16) | (pix[j+=2]<<8) | pix[j+=2];
392 insertPalettedPixels(pix, offset, samples);
396 int ipix[] = ipixels;
397 int cInc = colInc[pass];
399 for (j = 0; j < samples; offset += cInc) {
400 ipix[offset] = (pix[j++]<<16) | (pix[j++]<<8) | pix[j++] |
404 samples = samples<<1;
405 for (j = 0; j < samples; j += 2, offset += cInc) {
406 ipix[offset] = (pix[j]<<16) | (pix[j+=2]<<8) | pix[j+=2] |
416 private void blockFill(int rowStart) {
419 int pass = this.pass;
420 int w = blockWidth[pass];
421 int sCol = startingCol[pass];
422 int cInc = colInc[pass];
424 int maxW = rowStart + dw - w;
426 int h = blockHeight[pass];
427 int maxH = rowStart + (dw * h);
428 int startPos = rowStart + sCol;
431 if (colorType == 3) {
432 byte bpix[] = bpixels;
435 for (; counter <= maxW;) {
436 int end = counter + w;
437 pixel = bpix[counter++];
438 for (; counter < end; counter++) bpix[counter] = pixel;
443 for (pixel = bpix[counter++]; counter < maxW; counter++)
444 bpix[counter] = pixel;
445 if (len < maxH) maxH = len;
446 for (counter = startPos + dw; counter < maxH; counter += dw)
447 System.arraycopy(bpix, startPos, bpix, counter, dw - sCol);
449 int ipix[] = ipixels;
452 for (; counter <= maxW;) {
453 int end = counter + w;
454 pixel = ipix[counter++];
455 for (; counter < end; counter++)
456 ipix[counter] = pixel;
461 for (pixel = ipix[counter++]; counter < maxW; counter++)
462 ipix[counter] = pixel;
463 if (len < maxH) maxH = len;
464 for (counter = startPos + dw; counter < maxH; counter += dw)
465 System.arraycopy(ipix, startPos, ipix, counter, dw - sCol);
469 private boolean filterRow(byte inbuf[], int pix[], int upix[], int rowFilter, int boff) {
470 int rowWidth = pix.length;
473 for (int x = 0; x < rowWidth; x++) pix[x] = 0xff & inbuf[x];
477 for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
478 for ( ; x < rowWidth; x++) pix[x] = 0xff & (inbuf[x] + pix[x - boff]);
482 for (int x = 0; x < rowWidth; x++)
483 pix[x] = 0xff & (upix[x] + inbuf[x]);
485 for (int x = 0; x < rowWidth; x++)
486 pix[x] = 0xff & inbuf[x];
492 for ( ; x < boff; x++) {
494 pix[x] = 0xff & ((rval>>1) + inbuf[x]);
496 for ( ; x < rowWidth; x++) {
497 int rval = upix[x] + pix[x - boff];
498 pix[x] = 0xff & ((rval>>1) + inbuf[x]);
502 for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
503 for ( ; x < rowWidth; x++) {
504 int rval = pix[x - boff];
505 pix[x] = 0xff & ((rval>>1) + inbuf[x]);
512 for ( ; x < boff; x++) pix[x] = 0xff & (upix[x] + inbuf[x]);
513 for ( ; x < rowWidth; x++) {
514 int a, b, c, p, pa, pb, pc, rval;
519 pa = p > a ? p - a : a - p;
520 pb = p > b ? p - b : b - p;
521 pc = p > c ? p - c : c - p;
522 if ((pa <= pb) && (pa <= pc)) rval = a;
523 else if (pb <= pc) rval = b;
525 pix[x] = 0xff & (rval + inbuf[x]);
529 for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
530 for ( ; x < rowWidth; x++) {
531 int rval = pix[x - boff];
532 pix[x] = 0xff & (rval + inbuf[x]);
536 default: return false;
541 // Private Data ///////////////////////////////////////////////////////////////////////////////////////
543 private int target_offset = 0;
544 private int width = -1;
545 private int height = -1;
546 private int sigmask = 0xffff;
547 private Object pixels = null;
548 private int ipixels[] = null;
549 private byte bpixels[] = null;
550 private boolean multipass = false;
551 private boolean complete = false;
552 private boolean error = false;
554 private int[] data = null;
556 private InputStream underlyingStream = null;
557 private DataInputStream inputStream = null;
558 private Thread controlThread = null;
559 private boolean infoAvailable = false;
560 private int updateDelay = 750;
562 // Image decoding state variables
563 private boolean headerFound = false;
564 private int compressionMethod = -1;
565 private int depth = -1;
566 private int colorType = -1;
567 private int filterMethod = -1;
568 private int interlaceMethod = -1;
569 private int pass = 0;
570 private byte palette[] = null;
571 private int mask = 0x0;
572 private int smask = 0x0;
573 private boolean transparency = false;
575 private int chunkLength = 0;
576 private int chunkType = 0;
577 private boolean needChunkInfo = true;
579 private static final int CHUNK_bKGD = 0x624B4744; // "bKGD"
580 private static final int CHUNK_cHRM = 0x6348524D; // "cHRM"
581 private static final int CHUNK_gAMA = 0x67414D41; // "gAMA"
582 private static final int CHUNK_hIST = 0x68495354; // "hIST"
583 private static final int CHUNK_IDAT = 0x49444154; // "IDAT"
584 private static final int CHUNK_IEND = 0x49454E44; // "IEND"
585 private static final int CHUNK_IHDR = 0x49484452; // "IHDR"
586 private static final int CHUNK_PLTE = 0x504C5445; // "PLTE"
587 private static final int CHUNK_pHYs = 0x70485973; // "pHYs"
588 private static final int CHUNK_sBIT = 0x73424954; // "sBIT"
589 private static final int CHUNK_tEXt = 0x74455874; // "tEXt"
590 private static final int CHUNK_tIME = 0x74494D45; // "tIME"
591 private static final int CHUNK_tRNS = 0x74524E53; // "tIME"
592 private static final int CHUNK_zTXt = 0x7A545874; // "zTXt"
594 private static final int startingRow[] = { 0, 0, 0, 4, 0, 2, 0, 1 };
595 private static final int startingCol[] = { 0, 0, 4, 0, 2, 0, 1, 0 };
596 private static final int rowInc[] = { 1, 8, 8, 8, 4, 4, 2, 2 };
597 private static final int colInc[] = { 1, 8, 8, 4, 4, 2, 2, 1 };
598 private static final int blockHeight[] = { 1, 8, 8, 4, 4, 2, 2, 1 };
599 private static final int blockWidth[] = { 1, 8, 4, 4, 2, 2, 1, 1 };
601 // Helper Classes ////////////////////////////////////////////////////////////////////
603 private static class MeteredInputStream extends FilterInputStream {
607 public MeteredInputStream(InputStream in, int size) {
612 public final int read() throws IOException {
615 if (val != -1) bytesLeft--;
621 public final int read(byte b[]) throws IOException {
622 return read(b, 0, b.length);
625 public final int read(byte b[], int off, int len) throws IOException {
627 len = (len > bytesLeft ? bytesLeft : len);
628 int read = in.read(b, off, len);
629 if (read > 0) bytesLeft -= read;
635 public final long skip(long n) throws IOException {
636 n = (n > bytesLeft ? bytesLeft : n);
637 long skipped = in.skip(n);
638 if (skipped > 0) bytesLeft -= skipped;
642 public final int available() throws IOException {
643 int n = in.available();
644 return (n > bytesLeft ? bytesLeft : n);
647 public final void close() throws IOException { /* Eat this */ }
649 public final void mark(int readlimit) {
654 public final void reset() throws IOException {
659 public final boolean markSupported() { return in.markSupported(); }
662 /** Support class, used to eat the IDAT headers dividing up the deflated stream */
663 private static class IDATEnumeration implements Enumeration {
664 InputStream underlyingStream;
666 boolean firstStream = true;
668 public IDATEnumeration(PNG owner) {
670 this.underlyingStream = owner.underlyingStream;
673 public Object nextElement() {
675 return new MeteredInputStream(underlyingStream, owner.chunkLength);
678 public boolean hasMoreElements() {
679 DataInputStream dis = new DataInputStream(underlyingStream);
682 int crc = dis.readInt();
683 owner.needChunkInfo = false;
684 owner.chunkLength = dis.readInt();
685 owner.chunkType = dis.readInt();
686 } catch (IOException ioe) {
690 if (owner.chunkType == PNG.CHUNK_IDAT) return true;