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
14 package org.xwt.translators;
17 import org.xwt.util.*;
19 import java.util.Hashtable;
20 import java.util.Vector;
21 import java.util.Enumeration;
22 import java.util.zip.*;
24 /** Converts an InputStream carrying a PNG image into an ARGB int[] */
29 private static Queue instances = new Queue(10);
32 public static void load(InputStream is, Picture p) {
33 PNG g = (PNG)instances.remove(false);
34 if (g == null) g = new PNG();
38 } catch (Exception e) {
39 if (Log.on) Log.info(PNG.class, e);
42 // FIXME: must reset fields
43 // if (instances.size() < 10) instances.append(g);
46 // Public Methods ///////////////////////////////////////////////////////////////////////////////
48 /** process a PNG as an inputstream; returns null if there is an error
49 @param name A string describing the image, to be used when logging errors
51 private void _load(InputStream is, Picture pic) throws IOException {
53 if (is instanceof BufferedInputStream) underlyingStream = (BufferedInputStream)is;
54 else underlyingStream = new BufferedInputStream(is);
56 inputStream = new DataInputStream(underlyingStream);
59 if ((inputStream.read() != 137) || (inputStream.read() != 80) || (inputStream.read() != 78) || (inputStream.read() != 71) ||
60 (inputStream.read() != 13) || (inputStream.read() != 10) || (inputStream.read() != 26) || (inputStream.read() != 10)) {
61 Log.info(this, "PNG: error: input file is not a PNG file");
62 data = p.data = new int[] { };
63 p.width = p.height = 0;
70 chunkLength = inputStream.readInt();
71 chunkType = inputStream.readInt();
72 needChunkInfo = false;
75 // I rewrote this as an if/else to work around a JODE bug with switch() blocks
76 if (chunkType == CHUNK_bKGD) inputStream.skip(chunkLength);
77 else if (chunkType == CHUNK_cHRM) inputStream.skip(chunkLength);
78 else if (chunkType == CHUNK_gAMA) inputStream.skip(chunkLength);
79 else if (chunkType == CHUNK_hIST) inputStream.skip(chunkLength);
80 else if (chunkType == CHUNK_pHYs) inputStream.skip(chunkLength);
81 else if (chunkType == CHUNK_sBIT) inputStream.skip(chunkLength);
82 else if (chunkType == CHUNK_tEXt) inputStream.skip(chunkLength);
83 else if (chunkType == CHUNK_zTXt) inputStream.skip(chunkLength);
84 else if (chunkType == CHUNK_tIME) inputStream.skip(chunkLength);
85 else if (chunkType == CHUNK_IHDR) handleIHDR();
86 else if (chunkType == CHUNK_PLTE) handlePLTE();
87 else if (chunkType == CHUNK_tRNS) handletRNS();
88 else if (chunkType == CHUNK_IDAT) handleIDAT();
89 else if (chunkType == CHUNK_IEND) break;
91 System.err.println("unrecognized chunk type " + Integer.toHexString(chunkType) + ". skipping");
92 inputStream.skip(chunkLength);
95 int crc = inputStream.readInt();
101 // Chunk Handlers ///////////////////////////////////////////////////////////////////////
103 /** handle data chunk */
104 private void handleIDAT() throws IOException {
105 if (p.width == -1 || p.height == -1) throw new IOException("never got image width/height");
107 case 1: mask = 0x1; break;
108 case 2: mask = 0x3; break;
109 case 4: mask = 0xf; break;
110 case 8: case 16: mask = 0xff; break;
111 default: mask = 0x0; break;
113 if (depth < 8) smask = mask << depth;
114 else smask = mask << 8;
116 int count = p.width * p.height;
123 ipixels = new int[count];
127 bpixels = new byte[count];
131 throw new IOException("Image has unknown color type");
133 if (interlaceMethod != 0) multipass = true;
137 /** handle header chunk */
138 private void handleIHDR() throws IOException {
139 if (headerFound) throw new IOException("Extraneous IHDR chunk encountered.");
140 if (chunkLength != 13) throw new IOException("IHDR chunk length wrong: " + chunkLength);
141 p.width = inputStream.readInt();
142 p.height = inputStream.readInt();
143 depth = inputStream.read();
144 colorType = inputStream.read();
145 compressionMethod = inputStream.read();
146 filterMethod = inputStream.read();
147 interlaceMethod = inputStream.read();
150 /** handle pallette chunk */
151 private void handlePLTE() throws IOException {
152 if (colorType == 3) {
153 palette = new byte[chunkLength];
154 inputStream.readFully(palette);
156 // Ignore suggested palette
157 inputStream.skip(chunkLength);
161 /** handle transparency chunk; modifies palette */
162 private void handletRNS() throws IOException {
163 int chunkLen = chunkLength;
164 if (palette == null) {
165 if (Log.on) Log.info(this, "warning: tRNS chunk encountered before pLTE; ignoring alpha channel");
166 inputStream.skip(chunkLength);
169 int len = palette.length;
170 if (colorType == 3) {
173 int transLength = len/3;
174 byte[] trans = new byte[transLength];
175 for (int i = 0; i < transLength; i++) trans[i] = (byte) 0xff;
176 inputStream.readFully(trans, 0, chunkLength);
178 byte[] newPalette = new byte[len + transLength];
179 for (int i = newPalette.length; i > 0;) {
180 newPalette[--i] = trans[--transLength];
181 newPalette[--i] = palette[--len];
182 newPalette[--i] = palette[--len];
183 newPalette[--i] = palette[--len];
185 palette = newPalette;
188 inputStream.skip(chunkLength);
192 /// Helper functions for IDAT ///////////////////////////////////////////////////////////////////////////////////////////
194 /** Read Image data in off of a compression stream */
195 private void readImageData() throws IOException {
196 InputStream dataStream = new SequenceInputStream(new IDATEnumeration(this));
197 DataInputStream dis = new DataInputStream(new BufferedInputStream(new InflaterInputStream(dataStream, new Inflater())));
198 int bps, filterOffset;
200 case 0: case 3: bps = depth; break;
201 case 2: bps = 3 * depth; break;
202 case 4: bps = depth<<1; break;
203 case 6: bps = depth<<2; break;
204 default: throw new IOException("Unknown color type encountered.");
207 filterOffset = (bps + 7) >> 3;
209 for (pass = (multipass ? 1 : 0); pass < 8; pass++) {
210 int pass = this.pass;
211 int rInc = rowInc[pass];
212 int cInc = colInc[pass];
213 int sCol = startingCol[pass];
214 int val = (p.width - sCol + cInc - 1) / cInc;
215 int samples = val * filterOffset;
216 int rowSize = (val * bps)>>3;
217 int sRow = startingRow[pass];
218 if (p.height <= sRow || rowSize == 0) continue;
219 int sInc = rInc * p.width;
220 byte inbuf[] = new byte[rowSize];
221 int pix[] = new int[rowSize];
223 int temp[] = new int[rowSize];
224 int nextY = sRow; // next Y value and number of rows to report to sendPixels
226 int rowStart = sRow * p.width;
228 for (int y = sRow; y < p.height; y += rInc, rowStart += sInc) {
230 int rowFilter = dis.read();
231 dis.readFully(inbuf);
232 if (!filterRow(inbuf, pix, upix, rowFilter, filterOffset)) throw new IOException("Unknown filter type: " + rowFilter);
233 insertPixels(pix, rowStart + sCol, samples);
234 if (multipass && (pass < 6)) blockFill(rowStart);
239 if (!multipass) break;
241 while(dis.read() != -1) System.err.println("Leftover data encountered.");
243 // 24-bit color is our native format
244 if (colorType == 2 || colorType == 6) {
245 data = (int[])pixels;
246 if (colorType == 2) {
247 for(int i=0; i<data.length; i++)
248 data[i] |= 0xFF000000;
251 } else if (colorType == 3) {
252 byte[] pix = (byte[])pixels;
253 data = new int[pix.length];
254 for(int i=0; i<pix.length; i++) {
257 ((palette[4 * (pix[i] & 0xff) + 3] & 0xff) << 24) |
258 ((palette[4 * (pix[i] & 0xff) + 0] & 0xff) << 16) |
259 ((palette[4 * (pix[i] & 0xff) + 1] & 0xff) << 8) |
260 (palette[4 * (pix[i] & 0xff) + 2] & 0xff);
264 ((palette[3 * (pix[i] & 0xff) + 0] & 0xff) << 16) |
265 ((palette[3 * (pix[i] & 0xff) + 1] & 0xff) << 8) |
266 (palette[3 * (pix[i] & 0xff) + 2] & 0xff);
270 } else if (colorType == 0 || colorType == 4) {
271 if (depth == 16) depth = 8;
272 int[] pix = (int[])pixels;
273 data = new int[pix.length];
274 for(int i=0; i<pix.length; i ++) {
275 if (colorType == 0) {
276 int val = (pix[i] & 0xff) << (8 - depth);
283 int alpha = (pix[i] & mask) << (8 - depth);
284 int val = ((pix[i] & smask) >> depth) << (8 - depth);
296 private void insertGreyPixels(int pix[], int offset, int samples) {
298 int ipix[] = ipixels;
299 int cInc = colInc[pass];
302 if (colorType == 0) {
305 for (int j = 0; j < samples; j++, offset += cInc) {
307 else { rs = 7; p = pix[j>>3]; }
308 ipix[offset] = (p>>rs) & 0x1;
312 for (int j = 0; j < samples; j++, offset += cInc) {
313 if (rs != 0) rs -= 2;
314 else { rs = 6; p = pix[j>>2]; }
315 ipix[offset] = (p>>rs) & 0x3;
319 for (int j = 0; j < samples; j++, offset += cInc) {
321 else { rs = 4; p = pix[j>>1]; }
322 ipix[offset] = (p>>rs) & 0xf;
326 for (int j = 0; j < samples; offset += cInc) ipix[offset] = (byte) pix[j++];
329 samples = samples<<1;
330 for (int j = 0; j < samples; j += 2, offset += cInc) ipix[offset] = pix[j];
334 } else if (colorType == 4) {
336 for (int j = 0; j < samples; offset += cInc) ipix[offset] = (pix[j++]<<8) | pix[j++];
338 samples = samples<<1;
339 for (int j = 0; j < samples; j += 2, offset += cInc) ipix[offset] = (pix[j]<<8) | pix[j+=2];
344 private void insertPalettedPixels(int pix[], int offset, int samples) {
347 byte bpix[] = bpixels;
348 int cInc = colInc[pass];
352 for (int j = 0; j < samples; j++, offset += cInc) {
354 else { rs = 7; p = pix[j>>3]; }
355 bpix[offset] = (byte) ((p>>rs) & 0x1);
359 for (int j = 0; j < samples; j++, offset += cInc) {
360 if (rs != 0) rs -= 2;
361 else { rs = 6; p = pix[j>>2]; }
362 bpix[offset] = (byte) ((p>>rs) & 0x3);
366 for (int j = 0; j < samples; j++, offset += cInc) {
368 else { rs = 4; p = pix[j>>1]; }
369 bpix[offset] = (byte) ((p>>rs) & 0xf);
373 for (int j = 0; j < samples; j++, offset += cInc) bpix[offset] = (byte) pix[j];
378 private void insertPixels(int pix[], int offset, int samples) {
382 insertGreyPixels(pix, offset, samples);
386 int ipix[] = ipixels;
387 int cInc = colInc[pass];
389 for (j = 0; j < samples; offset += cInc)
390 ipix[offset] = (pix[j++]<<16) | (pix[j++]<<8) | pix[j++];
392 samples = samples<<1;
393 for (j = 0; j < samples; j += 2, offset += cInc)
394 ipix[offset] = (pix[j]<<16) | (pix[j+=2]<<8) | pix[j+=2];
398 insertPalettedPixels(pix, offset, samples);
402 int ipix[] = ipixels;
403 int cInc = colInc[pass];
405 for (j = 0; j < samples; offset += cInc) {
406 ipix[offset] = (pix[j++]<<16) | (pix[j++]<<8) | pix[j++] |
410 samples = samples<<1;
411 for (j = 0; j < samples; j += 2, offset += cInc) {
412 ipix[offset] = (pix[j]<<16) | (pix[j+=2]<<8) | pix[j+=2] |
422 private void blockFill(int rowStart) {
425 int pass = this.pass;
426 int w = blockWidth[pass];
427 int sCol = startingCol[pass];
428 int cInc = colInc[pass];
430 int maxW = rowStart + dw - w;
432 int h = blockHeight[pass];
433 int maxH = rowStart + (dw * h);
434 int startPos = rowStart + sCol;
437 if (colorType == 3) {
438 byte bpix[] = bpixels;
441 for (; counter <= maxW;) {
442 int end = counter + w;
443 pixel = bpix[counter++];
444 for (; counter < end; counter++) bpix[counter] = pixel;
449 for (pixel = bpix[counter++]; counter < maxW; counter++)
450 bpix[counter] = pixel;
451 if (len < maxH) maxH = len;
452 for (counter = startPos + dw; counter < maxH; counter += dw)
453 System.arraycopy(bpix, startPos, bpix, counter, dw - sCol);
455 int ipix[] = ipixels;
458 for (; counter <= maxW;) {
459 int end = counter + w;
460 pixel = ipix[counter++];
461 for (; counter < end; counter++)
462 ipix[counter] = pixel;
467 for (pixel = ipix[counter++]; counter < maxW; counter++)
468 ipix[counter] = pixel;
469 if (len < maxH) maxH = len;
470 for (counter = startPos + dw; counter < maxH; counter += dw)
471 System.arraycopy(ipix, startPos, ipix, counter, dw - sCol);
475 private boolean filterRow(byte inbuf[], int pix[], int upix[], int rowFilter, int boff) {
476 int rowWidth = pix.length;
479 for (int x = 0; x < rowWidth; x++) pix[x] = 0xff & inbuf[x];
483 for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
484 for ( ; x < rowWidth; x++) pix[x] = 0xff & (inbuf[x] + pix[x - boff]);
488 for (int x = 0; x < rowWidth; x++)
489 pix[x] = 0xff & (upix[x] + inbuf[x]);
491 for (int x = 0; x < rowWidth; x++)
492 pix[x] = 0xff & inbuf[x];
498 for ( ; x < boff; x++) {
500 pix[x] = 0xff & ((rval>>1) + inbuf[x]);
502 for ( ; x < rowWidth; x++) {
503 int rval = upix[x] + pix[x - boff];
504 pix[x] = 0xff & ((rval>>1) + inbuf[x]);
508 for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
509 for ( ; x < rowWidth; x++) {
510 int rval = pix[x - boff];
511 pix[x] = 0xff & ((rval>>1) + inbuf[x]);
518 for ( ; x < boff; x++) pix[x] = 0xff & (upix[x] + inbuf[x]);
519 for ( ; x < rowWidth; x++) {
520 int a, b, c, p, pa, pb, pc, rval;
525 pa = p > a ? p - a : a - p;
526 pb = p > b ? p - b : b - p;
527 pc = p > c ? p - c : c - p;
528 if ((pa <= pb) && (pa <= pc)) rval = a;
529 else if (pb <= pc) rval = b;
531 pix[x] = 0xff & (rval + inbuf[x]);
535 for ( ; x < boff; x++) pix[x] = 0xff & inbuf[x];
536 for ( ; x < rowWidth; x++) {
537 int rval = pix[x - boff];
538 pix[x] = 0xff & (rval + inbuf[x]);
542 default: return false;
547 // Private Data ///////////////////////////////////////////////////////////////////////////////////////
549 private int target_offset = 0;
550 private int sigmask = 0xffff;
551 private Object pixels = null;
552 private int ipixels[] = null;
553 private byte bpixels[] = null;
554 private boolean multipass = false;
555 private boolean complete = false;
556 private boolean error = false;
560 private InputStream underlyingStream = null;
561 private DataInputStream inputStream = null;
562 private Thread controlThread = null;
563 private boolean infoAvailable = false;
564 private int updateDelay = 750;
566 // Image decoding state variables
567 private boolean headerFound = false;
568 private int compressionMethod = -1;
569 private int depth = -1;
570 private int colorType = -1;
571 private int filterMethod = -1;
572 private int interlaceMethod = -1;
573 private int pass = 0;
574 private byte palette[] = null;
575 private int mask = 0x0;
576 private int smask = 0x0;
577 private boolean transparency = false;
579 private int chunkLength = 0;
580 private int chunkType = 0;
581 private boolean needChunkInfo = true;
583 private static final int CHUNK_bKGD = 0x624B4744; // "bKGD"
584 private static final int CHUNK_cHRM = 0x6348524D; // "cHRM"
585 private static final int CHUNK_gAMA = 0x67414D41; // "gAMA"
586 private static final int CHUNK_hIST = 0x68495354; // "hIST"
587 private static final int CHUNK_IDAT = 0x49444154; // "IDAT"
588 private static final int CHUNK_IEND = 0x49454E44; // "IEND"
589 private static final int CHUNK_IHDR = 0x49484452; // "IHDR"
590 private static final int CHUNK_PLTE = 0x504C5445; // "PLTE"
591 private static final int CHUNK_pHYs = 0x70485973; // "pHYs"
592 private static final int CHUNK_sBIT = 0x73424954; // "sBIT"
593 private static final int CHUNK_tEXt = 0x74455874; // "tEXt"
594 private static final int CHUNK_tIME = 0x74494D45; // "tIME"
595 private static final int CHUNK_tRNS = 0x74524E53; // "tIME"
596 private static final int CHUNK_zTXt = 0x7A545874; // "zTXt"
598 private static final int startingRow[] = { 0, 0, 0, 4, 0, 2, 0, 1 };
599 private static final int startingCol[] = { 0, 0, 4, 0, 2, 0, 1, 0 };
600 private static final int rowInc[] = { 1, 8, 8, 8, 4, 4, 2, 2 };
601 private static final int colInc[] = { 1, 8, 8, 4, 4, 2, 2, 1 };
602 private static final int blockHeight[] = { 1, 8, 8, 4, 4, 2, 2, 1 };
603 private static final int blockWidth[] = { 1, 8, 4, 4, 2, 2, 1, 1 };
605 // Helper Classes ////////////////////////////////////////////////////////////////////
607 private static class MeteredInputStream extends FilterInputStream {
611 public MeteredInputStream(InputStream in, int size) {
616 public final int read() throws IOException {
619 if (val != -1) bytesLeft--;
625 public final int read(byte b[]) throws IOException {
626 return read(b, 0, b.length);
629 public final int read(byte b[], int off, int len) throws IOException {
631 len = (len > bytesLeft ? bytesLeft : len);
632 int read = in.read(b, off, len);
633 if (read > 0) bytesLeft -= read;
639 public final long skip(long n) throws IOException {
640 n = (n > bytesLeft ? bytesLeft : n);
641 long skipped = in.skip(n);
642 if (skipped > 0) bytesLeft -= skipped;
646 public final int available() throws IOException {
647 int n = in.available();
648 return (n > bytesLeft ? bytesLeft : n);
651 public final void close() throws IOException { /* Eat this */ }
653 public final void mark(int readlimit) {
658 public final void reset() throws IOException {
663 public final boolean markSupported() { return in.markSupported(); }
666 /** Support class, used to eat the IDAT headers dividing up the deflated stream */
667 private static class IDATEnumeration implements Enumeration {
668 InputStream underlyingStream;
670 boolean firstStream = true;
672 public IDATEnumeration(PNG owner) {
674 this.underlyingStream = owner.underlyingStream;
677 public Object nextElement() {
679 return new MeteredInputStream(underlyingStream, owner.chunkLength);
682 public boolean hasMoreElements() {
683 DataInputStream dis = new DataInputStream(underlyingStream);
686 int crc = dis.readInt();
687 owner.needChunkInfo = false;
688 owner.chunkLength = dis.readInt();
689 owner.chunkType = dis.readInt();
690 } catch (IOException ioe) {
694 if (owner.chunkType == PNG.CHUNK_IDAT) return true;