1 /*
2  * Copyright 2003-2008 by Paulo Soares.
3  *
4  * The contents of this file are subject to the Mozilla Public License Version 1.1
5  * (the "License"); you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at http://www.mozilla.org/MPL/
7  *
8  * Software distributed under the License is distributed on an "AS IS" basis,
9  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
10  * for the specific language governing rights and limitations under the License.
11  *
12  * The Original Code is 'iText, a free JAVA-PDF library'.
13  *
14  * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
15  * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
16  * All Rights Reserved.
17  * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
18  * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
19  *
20  * Contributor(s): all the names of the contributors are added in the source code
21  * where applicable.
22  *
23  * Alternatively, the contents of this file may be used under the terms of the
24  * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
25  * provisions of LGPL are applicable instead of those above.  If you wish to
26  * allow use of your version of this file only under the terms of the LGPL
27  * License and not to allow others to use your version of this file under
28  * the MPL, indicate your decision by deleting the provisions above and
29  * replace them with the notice and other provisions required by the LGPL.
30  * If you do not delete the provisions above, a recipient may use your version
31  * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
32  *
33  * This library is free software; you can redistribute it and/or modify it
34  * under the terms of the MPL as stated above or under the terms of the GNU
35  * Library General Public License as published by the Free Software Foundation;
36  * either version 2 of the License, or any later version.
37  *
38  * This library is distributed in the hope that it will be useful, but WITHOUT
39  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
40  * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
41  * details.
42  *
43  * If you didn't download this code from the following link, you should check if
44  * you aren't using an obsolete version:
45  * http://www.lowagie.com/iText/
46  *
47  * This code is based on a series of source files originally released
48  * by SUN in the context of the JAI project. The original code was released 
49  * under the BSD license in a specific wording. In a mail dating from
50  * January 23, 2008, Brian Burkhalter (@sun.com) gave us permission
51  * to use the code under the following version of the BSD license:
52  *
53  * Copyright (c) 2005 Sun Microsystems, Inc. All  Rights Reserved.
54  * 
55  * Redistribution and use in source and binary forms, with or without
56  * modification, are permitted provided that the following conditions
57  * are met: 
58  * 
59  * - Redistribution of source code must retain the above copyright 
60  *   notice, this  list of conditions and the following disclaimer.
61  * 
62  * - Redistribution in binary form must reproduce the above copyright
63  *   notice, this list of conditions and the following disclaimer in 
64  *   the documentation and/or other materials provided with the
65  *   distribution.
66  * 
67  * Neither the name of Sun Microsystems, Inc. or the names of 
68  * contributors may be used to endorse or promote products derived 
69  * from this software without specific prior written permission.
70  * 
71  * This software is provided "AS IS," without a warranty of any 
72  * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND 
73  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, 
74  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
75  * EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL 
76  * NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF 
77  * USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
78  * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR 
79  * ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL,
80  * CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND
81  * REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR
82  * INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
83  * POSSIBILITY OF SUCH DAMAGES. 
84  * 
85  * You acknowledge that this software is not designed or intended for 
86  * use in the design, construction, operation or maintenance of any 
87  * nuclear facility.
88  */
89
90 package com.lowagie.text.pdf.codec;
91
92 import java.awt.color.ICC_Profile;
93 import java.io.ByteArrayInputStream;
94 import java.io.ByteArrayOutputStream;
95 import java.io.DataInputStream;
96 import java.io.IOException;
97 import java.io.InputStream;
98 import java.net.URL;
99 import java.util.zip.Inflater;
100 import java.util.zip.InflaterInputStream;
101
102 import com.lowagie.text.ExceptionConverter;
103 import com.lowagie.text.Image;
104 import com.lowagie.text.ImgRaw;
105 import com.lowagie.text.Utilities;
106 import com.lowagie.text.pdf.ByteBuffer;
107 import com.lowagie.text.pdf.PdfArray;
108 import com.lowagie.text.pdf.PdfDictionary;
109 import com.lowagie.text.pdf.PdfLiteral;
110 import com.lowagie.text.pdf.PdfName;
111 import com.lowagie.text.pdf.PdfNumber;
112 import com.lowagie.text.pdf.PdfObject;
113 import com.lowagie.text.pdf.PdfReader;
114 import com.lowagie.text.pdf.PdfString;
115
116 /** Reads a PNG image. All types of PNG can be read.
117  * <p>
118  * It is based in part in the JAI codec.
119  *
120  * @author  Paulo Soares (psoares@consiste.pt)
121  */
122 public class PngImage {
123 /** Some PNG specific values. */
124     public static final int[] PNGID = {137, 80, 78, 71, 13, 10, 26, 10};
125     
126 /** A PNG marker. */
127     public static final String IHDR = "IHDR";
128     
129 /** A PNG marker. */
130     public static final String PLTE = "PLTE";
131     
132 /** A PNG marker. */
133     public static final String IDAT = "IDAT";
134     
135 /** A PNG marker. */
136     public static final String IEND = "IEND";
137     
138 /** A PNG marker. */
139     public static final String tRNS = "tRNS";
140     
141 /** A PNG marker. */
142     public static final String pHYs = "pHYs";
143     
144 /** A PNG marker. */
145     public static final String gAMA = "gAMA";
146     
147 /** A PNG marker. */
148     public static final String cHRM = "cHRM";
149     
150 /** A PNG marker. */
151     public static final String sRGB = "sRGB";
152     
153 /** A PNG marker. */
154     public static final String iCCP = "iCCP";
155     
156     private static final int TRANSFERSIZE = 4096;
157     private static final int PNG_FILTER_NONE = 0;
158     private static final int PNG_FILTER_SUB = 1;
159     private static final int PNG_FILTER_UP = 2;
160     private static final int PNG_FILTER_AVERAGE = 3;
161     private static final int PNG_FILTER_PAETH = 4;
162     private static final PdfName intents[] = {PdfName.PERCEPTUAL,
163         PdfName.RELATIVECOLORIMETRIC,PdfName.SATURATION,PdfName.ABSOLUTECOLORIMETRIC};
164     
165     InputStream is;
166     DataInputStream dataStream;
167     int width;
168     int height;
169     int bitDepth;
170     int colorType;
171     int compressionMethod;
172     int filterMethod;
173     int interlaceMethod;
174     PdfDictionary additional = new PdfDictionary();
175     byte image[];
176     byte smask[];
177     byte trans[];
178     NewByteArrayOutputStream idat = new NewByteArrayOutputStream();
179     int dpiX;
180     int dpiY;
181     float XYRatio;
182     boolean genBWMask;
183     boolean palShades;
184     int transRedGray = -1;
185     int transGreen = -1;
186     int transBlue = -1;
187     int inputBands;
188     int bytesPerPixel; // number of bytes per input pixel
189     byte colorTable[];
190     float gamma = 1f;
191     boolean hasCHRM = false;
192     float xW, yW, xR, yR, xG, yG, xB, yB;
193     PdfName intent;
194     ICC_Profile icc_profile;
195
196     
197     
198     /** Creates a new instance of PngImage */
199     PngImage(InputStream is) {
200         this.is = is;
201     }
202     
203     /** Reads a PNG from an url.
204      * @param url the url
205      * @throws IOException on error
206      * @return the image
207      */    
208     public static Image getImage(URL url) throws IOException {
209         InputStream is = null;
210         try {
211             is = url.openStream();
212             Image img = getImage(is);
213             img.setUrl(url);
214             return img;
215         }
216         finally {
217             if (is != null) {
218                 is.close();
219             }
220         }
221     }
222     
223     /** Reads a PNG from a stream.
224      * @param is the stream
225      * @throws IOException on error
226      * @return the image
227      */    
228     public static Image getImage(InputStream is) throws IOException {
229         PngImage png = new PngImage(is);
230         return png.getImage();
231     }
232     
233     /** Reads a PNG from a file.
234      * @param file the file
235      * @throws IOException on error
236      * @return the image
237      */    
238     public static Image getImage(String file) throws IOException {
239         return getImage(Utilities.toURL(file));
240     }
241     
242     /** Reads a PNG from a byte array.
243      * @param data the byte array
244      * @throws IOException on error
245      * @return the image
246      */    
247     public static Image getImage(byte data[]) throws IOException {
248         ByteArrayInputStream is = new ByteArrayInputStream(data);
249         Image img = getImage(is);
250         img.setOriginalData(data);
251         return img;
252     }
253     
254     boolean checkMarker(String s) {
255         if (s.length() != 4)
256             return false;
257         for (int k = 0; k < 4; ++k) {
258             char c = s.charAt(k);
259             if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z'))
260                 return false;
261         }
262         return true;
263     }
264     
265     void readPng() throws IOException {
266         for (int i = 0; i < PNGID.length; i++) {
267             if (PNGID[i] != is.read())    {
268                 throw new IOException("File is not a valid PNG.");
269             }
270         }
271         byte buffer[] = new byte[TRANSFERSIZE];
272         while (true) {
273             int len = getInt(is);
274             String marker = getString(is);
275             if (len < 0 || !checkMarker(marker))
276                 throw new IOException("Corrupted PNG file.");
277             if (IDAT.equals(marker)) {
278                 int size;
279                 while (len != 0) {
280                     size = is.read(buffer, 0, Math.min(len, TRANSFERSIZE));
281                     if (size < 0)
282                         return;
283                     idat.write(buffer, 0, size);
284                     len -= size;
285                 }
286             }
287             else if (tRNS.equals(marker)) {
288                 switch (colorType) {
289                     case 0:
290                         if (len >= 2) {
291                             len -= 2;
292                             int gray = getWord(is);
293                             if (bitDepth == 16)
294                                 transRedGray = gray;
295                             else
296                                 additional.put(PdfName.MASK, new PdfLiteral("["+gray+" "+gray+"]"));
297                         }
298                         break;
299                     case 2:
300                         if (len >= 6) {
301                             len -= 6;
302                             int red = getWord(is);
303                             int green = getWord(is);
304                             int blue = getWord(is);
305                             if (bitDepth == 16) {
306                                 transRedGray = red;
307                                 transGreen = green;
308                                 transBlue = blue;
309                             }
310                             else
311                                 additional.put(PdfName.MASK, new PdfLiteral("["+red+" "+red+" "+green+" "+green+" "+blue+" "+blue+"]"));
312                         }
313                         break;
314                     case 3:
315                         if (len > 0) {
316                             trans = new byte[len];
317                             for (int k = 0; k < len; ++k)
318                                 trans[k] = (byte)is.read();
319                             len = 0;
320                         }
321                         break;
322                 }
323                 Utilities.skip(is, len);
324             }
325             else if (IHDR.equals(marker)) {
326                 width = getInt(is);
327                 height = getInt(is);
328                 
329                 bitDepth = is.read();
330                 colorType = is.read();
331                 compressionMethod = is.read();
332                 filterMethod = is.read();
333                 interlaceMethod = is.read();
334             }
335             else if (PLTE.equals(marker)) {
336                 if (colorType == 3) {
337                     PdfArray colorspace = new PdfArray();
338                     colorspace.add(PdfName.INDEXED);
339                     colorspace.add(getColorspace());
340                     colorspace.add(new PdfNumber(len / 3 - 1));
341                     ByteBuffer colortable = new ByteBuffer();
342                     while ((len--) > 0) {
343                         colortable.append_i(is.read());
344                     }
345                     colorspace.add(new PdfString(colorTable = colortable.toByteArray()));
346                     additional.put(PdfName.COLORSPACE, colorspace);
347                 }
348                 else {
349                     Utilities.skip(is, len);
350                 }
351             }
352             else if (pHYs.equals(marker)) {
353                 int dx = getInt(is);
354                 int dy = getInt(is);
355                 int unit = is.read();
356                 if (unit == 1) {
357                     dpiX = (int)(dx * 0.0254f + 0.5f);
358                     dpiY = (int)(dy * 0.0254f + 0.5f);
359                 }
360                 else {
361                     if (dy != 0)
362                         XYRatio = (float)dx / (float)dy;
363                 }
364             }
365             else if (cHRM.equals(marker)) {
366                 xW = getInt(is) / 100000f;
367                 yW = getInt(is) / 100000f;
368                 xR = getInt(is) / 100000f;
369                 yR = getInt(is) / 100000f;
370                 xG = getInt(is) / 100000f;
371                 yG = getInt(is) / 100000f;
372                 xB = getInt(is) / 100000f;
373                 yB = getInt(is) / 100000f;
374                 hasCHRM = !(Math.abs(xW)<0.0001f||Math.abs(yW)<0.0001f||Math.abs(xR)<0.0001f||Math.abs(yR)<0.0001f||Math.abs(xG)<0.0001f||Math.abs(yG)<0.0001f||Math.abs(xB)<0.0001f||Math.abs(yB)<0.0001f);
375             }
376             else if (sRGB.equals(marker)) {
377                 int ri = is.read();
378                 intent = intents[ri];
379                 gamma = 2.2f;
380                 xW = 0.3127f;
381                 yW = 0.329f;
382                 xR = 0.64f;
383                 yR = 0.33f;
384                 xG = 0.3f;
385                 yG = 0.6f;
386                 xB = 0.15f;
387                 yB = 0.06f;
388                 hasCHRM = true;
389             }
390             else if (gAMA.equals(marker)) {
391                 int gm = getInt(is);
392                 if (gm != 0) {
393                     gamma = 100000f / gm;
394                     if (!hasCHRM) {
395                         xW = 0.3127f;
396                         yW = 0.329f;
397                         xR = 0.64f;
398                         yR = 0.33f;
399                         xG = 0.3f;
400                         yG = 0.6f;
401                         xB = 0.15f;
402                         yB = 0.06f;
403                         hasCHRM = true;
404                     }
405                 }
406             }
407             else if (iCCP.equals(marker)) {
408                 do {
409                     --len;
410                 } while (is.read() != 0);
411                 is.read();
412                 --len;
413                 byte icccom[] = new byte[len];
414                 int p = 0;
415                 while (len > 0) {
416                     int r = is.read(icccom, p, len);
417                     if (r < 0)
418                         throw new IOException("Premature end of file.");
419                     p += r;
420                     len -= r;
421                 }
422                 byte iccp[] = PdfReader.FlateDecode(icccom, true);
423                 icccom = null;
424                 try {
425                     icc_profile = ICC_Profile.getInstance(iccp);
426                 }
427                 catch (RuntimeException e) {
428                     icc_profile = null;
429                 }
430             }
431             else if (IEND.equals(marker)) {
432                 break;
433             }
434             else {
435                 Utilities.skip(is, len);
436             }
437             Utilities.skip(is, 4);
438         }
439     }
440     
441     PdfObject getColorspace() {
442         if (icc_profile != null) {
443             if ((colorType & 2) == 0)
444                 return PdfName.DEVICEGRAY;
445             else
446                 return PdfName.DEVICERGB;
447         }
448         if (gamma == 1f && !hasCHRM) {
449             if ((colorType & 2) == 0)
450                 return PdfName.DEVICEGRAY;
451             else
452                 return PdfName.DEVICERGB;
453         }
454         else {
455             PdfArray array = new PdfArray();
456             PdfDictionary dic = new PdfDictionary();
457             if ((colorType & 2) == 0) {
458                 if (gamma == 1f)
459                     return PdfName.DEVICEGRAY;
460                 array.add(PdfName.CALGRAY);
461                 dic.put(PdfName.GAMMA, new PdfNumber(gamma));
462                 dic.put(PdfName.WHITEPOINT, new PdfLiteral("[1 1 1]"));
463                 array.add(dic);
464             }
465             else {
466                 PdfObject wp = new PdfLiteral("[1 1 1]");
467                 array.add(PdfName.CALRGB);
468                 if (gamma != 1f) {
469                     PdfArray gm = new PdfArray();
470                     PdfNumber n = new PdfNumber(gamma);
471                     gm.add(n);
472                     gm.add(n);
473                     gm.add(n);
474                     dic.put(PdfName.GAMMA, gm);
475                 }
476                 if (hasCHRM) {
477                     float z = yW*((xG-xB)*yR-(xR-xB)*yG+(xR-xG)*yB);
478                     float YA = yR*((xG-xB)*yW-(xW-xB)*yG+(xW-xG)*yB)/z;
479                     float XA = YA*xR/yR;
480                     float ZA = YA*((1-xR)/yR-1);
481                     float YB = -yG*((xR-xB)*yW-(xW-xB)*yR+(xW-xR)*yB)/z;
482                     float XB = YB*xG/yG;
483                     float ZB = YB*((1-xG)/yG-1);
484                     float YC = yB*((xR-xG)*yW-(xW-xG)*yW+(xW-xR)*yG)/z;
485                     float XC = YC*xB/yB;
486                     float ZC = YC*((1-xB)/yB-1);
487                     float XW = XA+XB+XC;
488                     float YW = 1;//YA+YB+YC;
489                     float ZW = ZA+ZB+ZC;
490                     PdfArray wpa = new PdfArray();
491                     wpa.add(new PdfNumber(XW));
492                     wpa.add(new PdfNumber(YW));
493                     wpa.add(new PdfNumber(ZW));
494                     wp = wpa;
495                     PdfArray matrix = new PdfArray();
496                     matrix.add(new PdfNumber(XA));
497                     matrix.add(new PdfNumber(YA));
498                     matrix.add(new PdfNumber(ZA));
499                     matrix.add(new PdfNumber(XB));
500                     matrix.add(new PdfNumber(YB));
501                     matrix.add(new PdfNumber(ZB));
502                     matrix.add(new PdfNumber(XC));
503                     matrix.add(new PdfNumber(YC));
504                     matrix.add(new PdfNumber(ZC));
505                     dic.put(PdfName.MATRIX, matrix);
506                 }
507                 dic.put(PdfName.WHITEPOINT, wp);
508                 array.add(dic);
509             }
510             return array;
511         }
512     }
513     
514     Image getImage() throws IOException {
515         readPng();
516         try {
517             int pal0 = 0;
518             int palIdx = 0;
519             palShades = false;
520             if (trans != null) {
521                 for (int k = 0; k < trans.length; ++k) {
522                     int n = trans[k] & 0xff;
523                     if (n == 0) {
524                         ++pal0;
525                         palIdx = k;
526                     }
527                     if (n != 0 && n != 255) {
528                         palShades = true;
529                         break;
530                     }
531                 }
532             }
533             if ((colorType & 4) != 0)
534                 palShades = true;
535             genBWMask = (!palShades && (pal0 > 1 || transRedGray >= 0));
536             if (!palShades && !genBWMask && pal0 == 1) {
537                 additional.put(PdfName.MASK, new PdfLiteral("["+palIdx+" "+palIdx+"]"));
538             }
539             boolean needDecode = (interlaceMethod == 1) || (bitDepth == 16) || ((colorType & 4) != 0) || palShades || genBWMask;
540             switch (colorType) {
541                 case 0:
542                     inputBands = 1;
543                     break;
544                 case 2:
545                     inputBands = 3;
546                     break;
547                 case 3:
548                     inputBands = 1;
549                     break;
550                 case 4:
551                     inputBands = 2;
552                     break;
553                 case 6:
554                     inputBands = 4;
555                     break;
556             }
557             if (needDecode)
558                 decodeIdat();
559             int components = inputBands;
560             if ((colorType & 4) != 0)
561                 --components;
562             int bpc = bitDepth;
563             if (bpc == 16)
564                 bpc = 8;
565             Image img;
566             if (image != null) {
567                 if (colorType == 3)
568                     img = new ImgRaw(width, height, components, bpc, image);
569                 else
570                     img = Image.getInstance(width, height, components, bpc, image);
571             }
572             else {
573                 img = new ImgRaw(width, height, components, bpc, idat.toByteArray());
574                 img.setDeflated(true);
575                 PdfDictionary decodeparms = new PdfDictionary();
576                 decodeparms.put(PdfName.BITSPERCOMPONENT, new PdfNumber(bitDepth));
577                 decodeparms.put(PdfName.PREDICTOR, new PdfNumber(15));
578                 decodeparms.put(PdfName.COLUMNS, new PdfNumber(width));
579                 decodeparms.put(PdfName.COLORS, new PdfNumber((colorType == 3 || (colorType & 2) == 0) ? 1 : 3));
580                 additional.put(PdfName.DECODEPARMS, decodeparms);
581             }
582             if (additional.get(PdfName.COLORSPACE) == null)
583                 additional.put(PdfName.COLORSPACE, getColorspace());
584             if (intent != null)
585                 additional.put(PdfName.INTENT, intent);
586             if (additional.size() > 0)
587                 img.setAdditional(additional);
588             if (icc_profile != null)
589                 img.tagICC(icc_profile);
590             if (palShades) {
591                 Image im2 = Image.getInstance(width, height, 1, 8, smask);
592                 im2.makeMask();
593                 img.setImageMask(im2);
594             }
595             if (genBWMask) {
596                 Image im2 = Image.getInstance(width, height, 1, 1, smask);
597                 im2.makeMask();
598                 img.setImageMask(im2);
599             }
600             img.setDpi(dpiX, dpiY);
601             img.setXYRatio(XYRatio);
602             img.setOriginalType(Image.ORIGINAL_PNG);
603             return img;
604         }
605         catch (Exception e) {
606             throw new ExceptionConverter(e);
607         }
608     }
609     
610     void decodeIdat() {
611         int nbitDepth = bitDepth;
612         if (nbitDepth == 16)
613             nbitDepth = 8;
614         int size = -1;
615         bytesPerPixel = (bitDepth == 16) ? 2 : 1;
616         switch (colorType) {
617             case 0:
618                 size = (nbitDepth * width + 7) / 8 * height;
619                 break;
620             case 2:
621                 size = width * 3 * height;
622                 bytesPerPixel *= 3;
623                 break;
624             case 3:
625                 if (interlaceMethod == 1)
626                     size = (nbitDepth * width + 7) / 8 * height;
627                 bytesPerPixel = 1;
628                 break;
629             case 4:
630                 size = width * height;
631                 bytesPerPixel *= 2;
632                 break;
633             case 6:
634                 size = width * 3 * height;
635                 bytesPerPixel *= 4;
636                 break;
637         }
638         if (size >= 0)
639             image = new byte[size];
640         if (palShades)
641             smask = new byte[width * height];
642         else if (genBWMask)
643             smask = new byte[(width + 7) / 8 * height];
644         ByteArrayInputStream bai = new ByteArrayInputStream(idat.getBuf(), 0, idat.size());
645         InputStream infStream = new InflaterInputStream(bai, new Inflater());
646         dataStream = new DataInputStream(infStream);
647         
648         if (interlaceMethod != 1) {
649             decodePass(0, 0, 1, 1, width, height);
650         }
651         else {
652             decodePass(0, 0, 8, 8, (width + 7)/8, (height + 7)/8);
653             decodePass(4, 0, 8, 8, (width + 3)/8, (height + 7)/8);
654             decodePass(0, 4, 4, 8, (width + 3)/4, (height + 3)/8);
655             decodePass(2, 0, 4, 4, (width + 1)/4, (height + 3)/4);
656             decodePass(0, 2, 2, 4, (width + 1)/2, (height + 1)/4);
657             decodePass(1, 0, 2, 2, width/2, (height + 1)/2);
658             decodePass(0, 1, 1, 2, width, height/2);
659         }
660         
661     }
662     
663     void decodePass( int xOffset, int yOffset,
664     int xStep, int yStep,
665     int passWidth, int passHeight) {
666         if ((passWidth == 0) || (passHeight == 0)) {
667             return;
668         }
669         
670         int bytesPerRow = (inputBands*passWidth*bitDepth + 7)/8;
671         byte[] curr = new byte[bytesPerRow];
672         byte[] prior = new byte[bytesPerRow];
673         
674         // Decode the (sub)image row-by-row
675         int srcY, dstY;
676         for (srcY = 0, dstY = yOffset;
677         srcY < passHeight;
678         srcY++, dstY += yStep) {
679             // Read the filter type byte and a row of data
680             int filter = 0;
681             try {
682                 filter = dataStream.read();
683                 dataStream.readFully(curr, 0, bytesPerRow);
684             } catch (Exception e) {
685                 // empty on purpose
686             }
687             
688             switch (filter) {
689                 case PNG_FILTER_NONE:
690                     break;
691                 case PNG_FILTER_SUB:
692                     decodeSubFilter(curr, bytesPerRow, bytesPerPixel);
693                     break;
694                 case PNG_FILTER_UP:
695                     decodeUpFilter(curr, prior, bytesPerRow);
696                     break;
697                 case PNG_FILTER_AVERAGE:
698                     decodeAverageFilter(curr, prior, bytesPerRow, bytesPerPixel);
699                     break;
700                 case PNG_FILTER_PAETH:
701                     decodePaethFilter(curr, prior, bytesPerRow, bytesPerPixel);
702                     break;
703                 default:
704                     // Error -- uknown filter type
705                     throw new RuntimeException("PNG filter unknown.");
706             }
707             
708             processPixels(curr, xOffset, xStep, dstY, passWidth);
709             
710             // Swap curr and prior
711             byte[] tmp = prior;
712             prior = curr;
713             curr = tmp;
714         }
715     }
716     
717     void processPixels(byte curr[], int xOffset, int step, int y, int width) {
718         int srcX, dstX;
719
720         int out[] = getPixel(curr);
721         int sizes = 0;
722         switch (colorType) {
723             case 0:
724             case 3:
725             case 4:
726                 sizes = 1;
727                 break;
728             case 2:
729             case 6:
730                 sizes = 3;
731                 break;
732         }
733         if (image != null) {
734             dstX = xOffset;
735             int yStride = (sizes*this.width*(bitDepth == 16 ? 8 : bitDepth)+ 7)/8;
736             for (srcX = 0; srcX < width; srcX++) {
737                 setPixel(image, out, inputBands * srcX, sizes, dstX, y, bitDepth, yStride);
738                 dstX += step;
739             }
740         }
741         if (palShades) {
742             if ((colorType & 4) != 0) {
743                 if (bitDepth == 16) {
744                     for (int k = 0; k < width; ++k)
745                         out[k * inputBands + sizes] >>>= 8;
746                 }
747                 int yStride = this.width;
748                 dstX = xOffset;
749                 for (srcX = 0; srcX < width; srcX++) {
750                     setPixel(smask, out, inputBands * srcX + sizes, 1, dstX, y, 8, yStride);
751                     dstX += step;
752                 }
753             }
754             else { //colorType 3
755                 int yStride = this.width;
756                 int v[] = new int[1];
757                 dstX = xOffset;
758                 for (srcX = 0; srcX < width; srcX++) {
759                     int idx = out[srcX];
760                     if (idx < trans.length)
761                         v[0] = trans[idx];
762                     else
763                         v[0] = 255; // Patrick Valsecchi
764                     setPixel(smask, v, 0, 1, dstX, y, 8, yStride);
765                     dstX += step;
766                 }
767             }
768         }
769         else if (genBWMask) {
770             switch (colorType) {
771                 case 3: {
772                     int yStride = (this.width + 7) / 8;
773                     int v[] = new int[1];
774                     dstX = xOffset;
775                     for (srcX = 0; srcX < width; srcX++) {
776                         int idx = out[srcX];
777                         v[0] = ((idx < trans.length && trans[idx] == 0) ? 1 : 0);
778                         setPixel(smask, v, 0, 1, dstX, y, 1, yStride);
779                         dstX += step;
780                     }
781                     break;
782                 }
783                 case 0: {
784                     int yStride = (this.width + 7) / 8;
785                     int v[] = new int[1];
786                     dstX = xOffset;
787                     for (srcX = 0; srcX < width; srcX++) {
788                         int g = out[srcX];
789                         v[0] = (g == transRedGray ? 1 : 0);
790                         setPixel(smask, v, 0, 1, dstX, y, 1, yStride);
791                         dstX += step;
792                     }
793                     break;
794                 }
795                 case 2: {
796                     int yStride = (this.width + 7) / 8;
797                     int v[] = new int[1];
798                     dstX = xOffset;
799                     for (srcX = 0; srcX < width; srcX++) {
800                         int markRed = inputBands * srcX;
801                         v[0] = (out[markRed] == transRedGray && out[markRed + 1] == transGreen 
802                             && out[markRed + 2] == transBlue ? 1 : 0);
803                         setPixel(smask, v, 0, 1, dstX, y, 1, yStride);
804                         dstX += step;
805                     }
806                     break;
807                 }
808             }
809         }
810     }
811     
812     static int getPixel(byte image[], int x, int y, int bitDepth, int bytesPerRow) {
813         if (bitDepth == 8) {
814             int pos = bytesPerRow * y + x;
815             return image[pos] & 0xff;
816         }
817         else {
818             int pos = bytesPerRow * y + x / (8 / bitDepth);
819             int v = image[pos] >> (8 - bitDepth * (x % (8 / bitDepth))- bitDepth);
820             return v & ((1 << bitDepth) - 1);
821         }
822     }
823     
824     static void setPixel(byte image[], int data[], int offset, int size, int x, int y, int bitDepth, int bytesPerRow) {
825         if (bitDepth == 8) {
826             int pos = bytesPerRow * y + size * x;
827             for (int k = 0; k < size; ++k)
828                 image[pos + k] = (byte)data[k + offset];
829         }
830         else if (bitDepth == 16) {
831             int pos = bytesPerRow * y + size * x;
832             for (int k = 0; k < size; ++k)
833                 image[pos + k] = (byte)(data[k + offset] >>> 8);
834         }
835         else {
836             int pos = bytesPerRow * y + x / (8 / bitDepth);
837             int v = data[offset] << (8 - bitDepth * (x % (8 / bitDepth))- bitDepth);
838             image[pos] |= v;
839         }
840     }
841     
842     int[] getPixel(byte curr[]) {
843         switch (bitDepth) {
844             case 8: {
845                 int out[] = new int[curr.length];
846                 for (int k = 0; k < out.length; ++k)
847                     out[k] = curr[k] & 0xff;
848                 return out;
849             }
850             case 16: {
851                 int out[] = new int[curr.length / 2];
852                 for (int k = 0; k < out.length; ++k)
853                     out[k] = ((curr[k * 2] & 0xff) << 8) + (curr[k * 2 + 1] & 0xff);
854                 return out;
855             }
856             default: {
857                 int out[] = new int[curr.length * 8 / bitDepth];
858                 int idx = 0;
859                 int passes = 8 / bitDepth;
860                 int mask = (1 << bitDepth) - 1;
861                 for (int k = 0; k < curr.length; ++k) {
862                     for (int j = passes - 1; j >= 0; --j) {
863                         out[idx++] = (curr[k] >>> (bitDepth * j)) & mask; 
864                     }
865                 }
866                 return out;
867             }
868         }
869     }
870     
871     private static void decodeSubFilter(byte[] curr, int count, int bpp) {
872         for (int i = bpp; i < count; i++) {
873             int val;
874             
875             val = curr[i] & 0xff;
876             val += curr[i - bpp] & 0xff;
877             
878             curr[i] = (byte)val;
879         }
880     }
881     
882     private static void decodeUpFilter(byte[] curr, byte[] prev,
883     int count) {
884         for (int i = 0; i < count; i++) {
885             int raw = curr[i] & 0xff;
886             int prior = prev[i] & 0xff;
887             
888             curr[i] = (byte)(raw + prior);
889         }
890     }
891     
892     private static void decodeAverageFilter(byte[] curr, byte[] prev,
893     int count, int bpp) {
894         int raw, priorPixel, priorRow;
895         
896         for (int i = 0; i < bpp; i++) {
897             raw = curr[i] & 0xff;
898             priorRow = prev[i] & 0xff;
899             
900             curr[i] = (byte)(raw + priorRow/2);
901         }
902         
903         for (int i = bpp; i < count; i++) {
904             raw = curr[i] & 0xff;
905             priorPixel = curr[i - bpp] & 0xff;
906             priorRow = prev[i] & 0xff;
907             
908             curr[i] = (byte)(raw + (priorPixel + priorRow)/2);
909         }
910     }
911     
912     private static int paethPredictor(int a, int b, int c) {
913         int p = a + b - c;
914         int pa = Math.abs(p - a);
915         int pb = Math.abs(p - b);
916         int pc = Math.abs(p - c);
917         
918         if ((pa <= pb) && (pa <= pc)) {
919             return a;
920         } else if (pb <= pc) {
921             return b;
922         } else {
923             return c;
924         }
925     }
926     
927     private static void decodePaethFilter(byte[] curr, byte[] prev,
928     int count, int bpp) {
929         int raw, priorPixel, priorRow, priorRowPixel;
930         
931         for (int i = 0; i < bpp; i++) {
932             raw = curr[i] & 0xff;
933             priorRow = prev[i] & 0xff;
934             
935             curr[i] = (byte)(raw + priorRow);
936         }
937         
938         for (int i = bpp; i < count; i++) {
939             raw = curr[i] & 0xff;
940             priorPixel = curr[i - bpp] & 0xff;
941             priorRow = prev[i] & 0xff;
942             priorRowPixel = prev[i - bpp] & 0xff;
943             
944             curr[i] = (byte)(raw + paethPredictor(priorPixel,
945             priorRow,
946             priorRowPixel));
947         }
948     }
949     
950     static class NewByteArrayOutputStream extends ByteArrayOutputStream {
951         public byte[] getBuf() {
952             return buf;
953         }
954     }
955
956 /**
957  * Gets an <CODE>int</CODE> from an <CODE>InputStream</CODE>.
958  *
959  * @param        is      an <CODE>InputStream</CODE>
960  * @return        the value of an <CODE>int</CODE>
961  */
962     
963     public static final int getInt(InputStream is) throws IOException {
964         return (is.read() << 24) + (is.read() << 16) + (is.read() << 8) + is.read();
965     }
966     
967 /**
968  * Gets a <CODE>word</CODE> from an <CODE>InputStream</CODE>.
969  *
970  * @param        is      an <CODE>InputStream</CODE>
971  * @return        the value of an <CODE>int</CODE>
972  */
973     
974     public static final int getWord(InputStream is) throws IOException {
975         return (is.read() << 8) + is.read();
976     }
977     
978 /**
979  * Gets a <CODE>String</CODE> from an <CODE>InputStream</CODE>.
980  *
981  * @param        is      an <CODE>InputStream</CODE>
982  * @return        the value of an <CODE>int</CODE>
983  */
984     
985     public static final String getString(InputStream is) throws IOException {
986         StringBuffer buf = new StringBuffer();
987         for (int i = 0; i < 4; i++) {
988             buf.append((char)is.read());
989         }
990         return buf.toString();
991     }
992
993 }
994