1 /*
   2  * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.imageio.plugins.png;
  27 
  28 import java.awt.Point;
  29 import java.awt.Rectangle;
  30 import java.awt.color.ColorSpace;
  31 import java.awt.image.BufferedImage;
  32 import java.awt.image.DataBuffer;
  33 import java.awt.image.DataBufferByte;
  34 import java.awt.image.DataBufferUShort;
  35 import java.awt.image.Raster;
  36 import java.awt.image.WritableRaster;
  37 import java.io.BufferedInputStream;
  38 import java.io.ByteArrayInputStream;
  39 import java.io.DataInputStream;
  40 import java.io.EOFException;
  41 import java.io.InputStream;
  42 import java.io.IOException;
  43 import java.io.SequenceInputStream;
  44 import java.util.ArrayList;
  45 import java.util.Arrays;
  46 import java.util.Enumeration;
  47 import java.util.Iterator;
  48 import java.util.zip.Inflater;
  49 import java.util.zip.InflaterInputStream;
  50 import javax.imageio.IIOException;
  51 import javax.imageio.ImageReader;
  52 import javax.imageio.ImageReadParam;
  53 import javax.imageio.ImageTypeSpecifier;
  54 import javax.imageio.metadata.IIOMetadata;
  55 import javax.imageio.spi.ImageReaderSpi;
  56 import javax.imageio.stream.ImageInputStream;
  57 import com.sun.imageio.plugins.common.InputStreamAdapter;
  58 import com.sun.imageio.plugins.common.ReaderUtil;
  59 import com.sun.imageio.plugins.common.SubImageInputStream;
  60 import java.io.ByteArrayOutputStream;
  61 import sun.awt.image.ByteInterleavedRaster;
  62 
  63 class PNGImageDataEnumeration implements Enumeration<InputStream> {
  64 
  65     boolean firstTime = true;
  66     ImageInputStream stream;
  67     int length;
  68 
  69     public PNGImageDataEnumeration(ImageInputStream stream)
  70         throws IOException {
  71         this.stream = stream;
  72         this.length = stream.readInt();
  73         int type = stream.readInt(); // skip chunk type
  74     }
  75 
  76     public InputStream nextElement() {
  77         try {
  78             firstTime = false;
  79             ImageInputStream iis = new SubImageInputStream(stream, length);
  80             return new InputStreamAdapter(iis);
  81         } catch (IOException e) {
  82             return null;
  83         }
  84     }
  85 
  86     public boolean hasMoreElements() {
  87         if (firstTime) {
  88             return true;
  89         }
  90 
  91         try {
  92             int crc = stream.readInt();
  93             this.length = stream.readInt();
  94             int type = stream.readInt();
  95             if (type == PNGImageReader.IDAT_TYPE) {
  96                 return true;
  97             } else {
  98                 return false;
  99             }
 100         } catch (IOException e) {
 101             return false;
 102         }
 103     }
 104 }
 105 
 106 public class PNGImageReader extends ImageReader {
 107 
 108     /*
 109      * Note: The following chunk type constants are autogenerated.  Each
 110      * one is derived from the ASCII values of its 4-character name.  For
 111      * example, IHDR_TYPE is calculated as follows:
 112      *            ('I' << 24) | ('H' << 16) | ('D' << 8) | 'R'
 113      */
 114 
 115     // Critical chunks
 116     static final int IHDR_TYPE = 0x49484452;
 117     static final int PLTE_TYPE = 0x504c5445;
 118     static final int IDAT_TYPE = 0x49444154;
 119     static final int IEND_TYPE = 0x49454e44;
 120 
 121     // Ancillary chunks
 122     static final int bKGD_TYPE = 0x624b4744;
 123     static final int cHRM_TYPE = 0x6348524d;
 124     static final int gAMA_TYPE = 0x67414d41;
 125     static final int hIST_TYPE = 0x68495354;
 126     static final int iCCP_TYPE = 0x69434350;
 127     static final int iTXt_TYPE = 0x69545874;
 128     static final int pHYs_TYPE = 0x70485973;
 129     static final int sBIT_TYPE = 0x73424954;
 130     static final int sPLT_TYPE = 0x73504c54;
 131     static final int sRGB_TYPE = 0x73524742;
 132     static final int tEXt_TYPE = 0x74455874;
 133     static final int tIME_TYPE = 0x74494d45;
 134     static final int tRNS_TYPE = 0x74524e53;
 135     static final int zTXt_TYPE = 0x7a545874;
 136 
 137     static final int PNG_COLOR_GRAY = 0;
 138     static final int PNG_COLOR_RGB = 2;
 139     static final int PNG_COLOR_PALETTE = 3;
 140     static final int PNG_COLOR_GRAY_ALPHA = 4;
 141     static final int PNG_COLOR_RGB_ALPHA = 6;
 142 
 143     // The number of bands by PNG color type
 144     static final int[] inputBandsForColorType = {
 145          1, // gray
 146         -1, // unused
 147          3, // rgb
 148          1, // palette
 149          2, // gray + alpha
 150         -1, // unused
 151          4  // rgb + alpha
 152     };
 153 
 154     static final int PNG_FILTER_NONE = 0;
 155     static final int PNG_FILTER_SUB = 1;
 156     static final int PNG_FILTER_UP = 2;
 157     static final int PNG_FILTER_AVERAGE = 3;
 158     static final int PNG_FILTER_PAETH = 4;
 159 
 160     static final int[] adam7XOffset = { 0, 4, 0, 2, 0, 1, 0 };
 161     static final int[] adam7YOffset = { 0, 0, 4, 0, 2, 0, 1 };
 162     static final int[] adam7XSubsampling = { 8, 8, 4, 4, 2, 2, 1, 1 };
 163     static final int[] adam7YSubsampling = { 8, 8, 8, 4, 4, 2, 2, 1 };
 164 
 165     private static final boolean debug = true;
 166 
 167     ImageInputStream stream = null;
 168 
 169     boolean gotHeader = false;
 170     boolean gotMetadata = false;
 171 
 172     ImageReadParam lastParam = null;
 173 
 174     long imageStartPosition = -1L;
 175 
 176     Rectangle sourceRegion = null;
 177     int sourceXSubsampling = -1;
 178     int sourceYSubsampling = -1;
 179     int sourceMinProgressivePass = 0;
 180     int sourceMaxProgressivePass = 6;
 181     int[] sourceBands = null;
 182     int[] destinationBands = null;
 183     Point destinationOffset = new Point(0, 0);
 184 
 185     PNGMetadata metadata = new PNGMetadata();
 186 
 187     DataInputStream pixelStream = null;
 188 
 189     BufferedImage theImage = null;
 190 
 191     // The number of source pixels processed
 192     int pixelsDone = 0;
 193 
 194     // The total number of pixels in the source image
 195     int totalPixels;
 196 
 197     public PNGImageReader(ImageReaderSpi originatingProvider) {
 198         super(originatingProvider);
 199     }
 200 
 201     public void setInput(Object input,
 202                          boolean seekForwardOnly,
 203                          boolean ignoreMetadata) {
 204         super.setInput(input, seekForwardOnly, ignoreMetadata);
 205         this.stream = (ImageInputStream)input; // Always works
 206 
 207         // Clear all values based on the previous stream contents
 208         resetStreamSettings();
 209     }
 210 
 211     private String readNullTerminatedString(String charset, int maxLen) throws IOException {
 212         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 213         int b;
 214         int count = 0;
 215         while ((maxLen > count++) && ((b = stream.read()) != 0)) {
 216             if (b == -1) throw new EOFException();
 217             baos.write(b);
 218         }
 219         return new String(baos.toByteArray(), charset);
 220     }
 221 
 222     private void readHeader() throws IIOException {
 223         if (gotHeader) {
 224             return;
 225         }
 226         if (stream == null) {
 227             throw new IllegalStateException("Input source not set!");
 228         }
 229 
 230         try {
 231             byte[] signature = new byte[8];
 232             stream.readFully(signature);
 233 
 234             if (signature[0] != (byte)137 ||
 235                 signature[1] != (byte)80 ||
 236                 signature[2] != (byte)78 ||
 237                 signature[3] != (byte)71 ||
 238                 signature[4] != (byte)13 ||
 239                 signature[5] != (byte)10 ||
 240                 signature[6] != (byte)26 ||
 241                 signature[7] != (byte)10) {
 242                 throw new IIOException("Bad PNG signature!");
 243             }
 244 
 245             int IHDR_length = stream.readInt();
 246             if (IHDR_length != 13) {
 247                 throw new IIOException("Bad length for IHDR chunk!");
 248             }
 249             int IHDR_type = stream.readInt();
 250             if (IHDR_type != IHDR_TYPE) {
 251                 throw new IIOException("Bad type for IHDR chunk!");
 252             }
 253 
 254             this.metadata = new PNGMetadata();
 255 
 256             int width = stream.readInt();
 257             int height = stream.readInt();
 258 
 259             // Re-use signature array to bulk-read these unsigned byte values
 260             stream.readFully(signature, 0, 5);
 261             int bitDepth          = signature[0] & 0xff;
 262             int colorType         = signature[1] & 0xff;
 263             int compressionMethod = signature[2] & 0xff;
 264             int filterMethod      = signature[3] & 0xff;
 265             int interlaceMethod   = signature[4] & 0xff;
 266 
 267             // Skip IHDR CRC
 268             stream.skipBytes(4);
 269 
 270             stream.flushBefore(stream.getStreamPosition());
 271 
 272             if (width <= 0) {
 273                 throw new IIOException("Image width <= 0!");
 274             }
 275             if (height <= 0) {
 276                 throw new IIOException("Image height <= 0!");
 277             }
 278             if (bitDepth != 1 && bitDepth != 2 && bitDepth != 4 &&
 279                 bitDepth != 8 && bitDepth != 16) {
 280                 throw new IIOException("Bit depth must be 1, 2, 4, 8, or 16!");
 281             }
 282             if (colorType != 0 && colorType != 2 && colorType != 3 &&
 283                 colorType != 4 && colorType != 6) {
 284                 throw new IIOException("Color type must be 0, 2, 3, 4, or 6!");
 285             }
 286             if (colorType == PNG_COLOR_PALETTE && bitDepth == 16) {
 287                 throw new IIOException("Bad color type/bit depth combination!");
 288             }
 289             if ((colorType == PNG_COLOR_RGB ||
 290                  colorType == PNG_COLOR_RGB_ALPHA ||
 291                  colorType == PNG_COLOR_GRAY_ALPHA) &&
 292                 (bitDepth != 8 && bitDepth != 16)) {
 293                 throw new IIOException("Bad color type/bit depth combination!");
 294             }
 295             if (compressionMethod != 0) {
 296                 throw new IIOException("Unknown compression method (not 0)!");
 297             }
 298             if (filterMethod != 0) {
 299                 throw new IIOException("Unknown filter method (not 0)!");
 300             }
 301             if (interlaceMethod != 0 && interlaceMethod != 1) {
 302                 throw new IIOException("Unknown interlace method (not 0 or 1)!");
 303             }
 304 
 305             metadata.IHDR_present = true;
 306             metadata.IHDR_width = width;
 307             metadata.IHDR_height = height;
 308             metadata.IHDR_bitDepth = bitDepth;
 309             metadata.IHDR_colorType = colorType;
 310             metadata.IHDR_compressionMethod = compressionMethod;
 311             metadata.IHDR_filterMethod = filterMethod;
 312             metadata.IHDR_interlaceMethod = interlaceMethod;
 313             gotHeader = true;
 314         } catch (IOException e) {
 315             throw new IIOException("I/O error reading PNG header!", e);
 316         }
 317     }
 318 
 319     private void parse_PLTE_chunk(int chunkLength) throws IOException {
 320         if (metadata.PLTE_present) {
 321             processWarningOccurred(
 322 "A PNG image may not contain more than one PLTE chunk.\n" +
 323 "The chunk wil be ignored.");
 324             return;
 325         } else if (metadata.IHDR_colorType == PNG_COLOR_GRAY ||
 326                    metadata.IHDR_colorType == PNG_COLOR_GRAY_ALPHA) {
 327             processWarningOccurred(
 328 "A PNG gray or gray alpha image cannot have a PLTE chunk.\n" +
 329 "The chunk wil be ignored.");
 330             return;
 331         }
 332 
 333         byte[] palette = new byte[chunkLength];
 334         stream.readFully(palette);
 335 
 336         int numEntries = chunkLength/3;
 337         if (metadata.IHDR_colorType == PNG_COLOR_PALETTE) {
 338             int maxEntries = 1 << metadata.IHDR_bitDepth;
 339             if (numEntries > maxEntries) {
 340                 processWarningOccurred(
 341 "PLTE chunk contains too many entries for bit depth, ignoring extras.");
 342                 numEntries = maxEntries;
 343             }
 344             numEntries = Math.min(numEntries, maxEntries);
 345         }
 346 
 347         // Round array sizes up to 2^2^n
 348         int paletteEntries;
 349         if (numEntries > 16) {
 350             paletteEntries = 256;
 351         } else if (numEntries > 4) {
 352             paletteEntries = 16;
 353         } else if (numEntries > 2) {
 354             paletteEntries = 4;
 355         } else {
 356             paletteEntries = 2;
 357         }
 358 
 359         metadata.PLTE_present = true;
 360         metadata.PLTE_red = new byte[paletteEntries];
 361         metadata.PLTE_green = new byte[paletteEntries];
 362         metadata.PLTE_blue = new byte[paletteEntries];
 363 
 364         int index = 0;
 365         for (int i = 0; i < numEntries; i++) {
 366             metadata.PLTE_red[i] = palette[index++];
 367             metadata.PLTE_green[i] = palette[index++];
 368             metadata.PLTE_blue[i] = palette[index++];
 369         }
 370     }
 371 
 372     private void parse_bKGD_chunk() throws IOException {
 373         if (metadata.IHDR_colorType == PNG_COLOR_PALETTE) {
 374             metadata.bKGD_colorType = PNG_COLOR_PALETTE;
 375             metadata.bKGD_index = stream.readUnsignedByte();
 376         } else if (metadata.IHDR_colorType == PNG_COLOR_GRAY ||
 377                    metadata.IHDR_colorType == PNG_COLOR_GRAY_ALPHA) {
 378             metadata.bKGD_colorType = PNG_COLOR_GRAY;
 379             metadata.bKGD_gray = stream.readUnsignedShort();
 380         } else { // RGB or RGB_ALPHA
 381             metadata.bKGD_colorType = PNG_COLOR_RGB;
 382             metadata.bKGD_red = stream.readUnsignedShort();
 383             metadata.bKGD_green = stream.readUnsignedShort();
 384             metadata.bKGD_blue = stream.readUnsignedShort();
 385         }
 386 
 387         metadata.bKGD_present = true;
 388     }
 389 
 390     private void parse_cHRM_chunk() throws IOException {
 391         metadata.cHRM_whitePointX = stream.readInt();
 392         metadata.cHRM_whitePointY = stream.readInt();
 393         metadata.cHRM_redX = stream.readInt();
 394         metadata.cHRM_redY = stream.readInt();
 395         metadata.cHRM_greenX = stream.readInt();
 396         metadata.cHRM_greenY = stream.readInt();
 397         metadata.cHRM_blueX = stream.readInt();
 398         metadata.cHRM_blueY = stream.readInt();
 399 
 400         metadata.cHRM_present = true;
 401     }
 402 
 403     private void parse_gAMA_chunk() throws IOException {
 404         int gamma = stream.readInt();
 405         metadata.gAMA_gamma = gamma;
 406 
 407         metadata.gAMA_present = true;
 408     }
 409 
 410     private void parse_hIST_chunk(int chunkLength) throws IOException,
 411         IIOException
 412     {
 413         if (!metadata.PLTE_present) {
 414             throw new IIOException("hIST chunk without prior PLTE chunk!");
 415         }
 416 
 417         /* According to PNG specification length of
 418          * hIST chunk is specified in bytes and
 419          * hIST chunk consists of 2 byte elements
 420          * (so we expect length is even).
 421          */
 422         metadata.hIST_histogram = new char[chunkLength/2];
 423         stream.readFully(metadata.hIST_histogram,
 424                          0, metadata.hIST_histogram.length);
 425 
 426         metadata.hIST_present = true;
 427     }
 428 
 429     private void parse_iCCP_chunk(int chunkLength) throws IOException {
 430         String keyword = readNullTerminatedString("ISO-8859-1", 80);
 431         int compressedProfileLength = chunkLength - keyword.length() - 2;
 432         if (compressedProfileLength <= 0) {
 433             throw new IIOException("iCCP chunk length is not proper");
 434         }
 435         metadata.iCCP_profileName = keyword;
 436 
 437         metadata.iCCP_compressionMethod = stream.readUnsignedByte();
 438 
 439         byte[] compressedProfile =
 440           new byte[compressedProfileLength];
 441         stream.readFully(compressedProfile);
 442         metadata.iCCP_compressedProfile = compressedProfile;
 443 
 444         metadata.iCCP_present = true;
 445     }
 446 
 447     private void parse_iTXt_chunk(int chunkLength) throws IOException {
 448         long chunkStart = stream.getStreamPosition();
 449 
 450         String keyword = readNullTerminatedString("ISO-8859-1", 80);
 451         metadata.iTXt_keyword.add(keyword);
 452 
 453         int compressionFlag = stream.readUnsignedByte();
 454         metadata.iTXt_compressionFlag.add(Boolean.valueOf(compressionFlag == 1));
 455 
 456         int compressionMethod = stream.readUnsignedByte();
 457         metadata.iTXt_compressionMethod.add(Integer.valueOf(compressionMethod));
 458 
 459         String languageTag = readNullTerminatedString("UTF8", 80);
 460         metadata.iTXt_languageTag.add(languageTag);
 461 
 462         long pos = stream.getStreamPosition();
 463         int maxLen = (int)(chunkStart + chunkLength - pos);
 464         String translatedKeyword =
 465             readNullTerminatedString("UTF8", maxLen);
 466         metadata.iTXt_translatedKeyword.add(translatedKeyword);
 467 
 468         String text;
 469         pos = stream.getStreamPosition();
 470         int textLength = (int)(chunkStart + chunkLength - pos);
 471         if (textLength <= 0) {
 472             throw new IIOException("iTXt chunk length is not proper");
 473         }
 474         byte[] b = new byte[textLength];
 475         stream.readFully(b);
 476 
 477         if (compressionFlag == 1) { // Decompress the text
 478             text = new String(inflate(b), "UTF8");
 479         } else {
 480             text = new String(b, "UTF8");
 481         }
 482         metadata.iTXt_text.add(text);
 483 
 484         // Check if the text chunk contains image creation time
 485         if (keyword.equals(PNGMetadata.tEXt_creationTimeKey)) {
 486             // Update Standard/Document/ImageCreationTime from text chunk
 487             int index = metadata.iTXt_text.size() - 1;
 488             metadata.decodeImageCreationTimeFromTextChunk(
 489                     metadata.iTXt_text.listIterator(index));
 490         }
 491     }
 492 
 493     private void parse_pHYs_chunk() throws IOException {
 494         metadata.pHYs_pixelsPerUnitXAxis = stream.readInt();
 495         metadata.pHYs_pixelsPerUnitYAxis = stream.readInt();
 496         metadata.pHYs_unitSpecifier = stream.readUnsignedByte();
 497 
 498         metadata.pHYs_present = true;
 499     }
 500 
 501     private void parse_sBIT_chunk() throws IOException {
 502         int colorType = metadata.IHDR_colorType;
 503         if (colorType == PNG_COLOR_GRAY ||
 504             colorType == PNG_COLOR_GRAY_ALPHA) {
 505             metadata.sBIT_grayBits = stream.readUnsignedByte();
 506         } else if (colorType == PNG_COLOR_RGB ||
 507                    colorType == PNG_COLOR_PALETTE ||
 508                    colorType == PNG_COLOR_RGB_ALPHA) {
 509             metadata.sBIT_redBits = stream.readUnsignedByte();
 510             metadata.sBIT_greenBits = stream.readUnsignedByte();
 511             metadata.sBIT_blueBits = stream.readUnsignedByte();
 512         }
 513 
 514         if (colorType == PNG_COLOR_GRAY_ALPHA ||
 515             colorType == PNG_COLOR_RGB_ALPHA) {
 516             metadata.sBIT_alphaBits = stream.readUnsignedByte();
 517         }
 518 
 519         metadata.sBIT_colorType = colorType;
 520         metadata.sBIT_present = true;
 521     }
 522 
 523     private void parse_sPLT_chunk(int chunkLength)
 524         throws IOException, IIOException {
 525         metadata.sPLT_paletteName = readNullTerminatedString("ISO-8859-1", 80);
 526         int remainingChunkLength = chunkLength -
 527                 (metadata.sPLT_paletteName.length() + 1);
 528         if (remainingChunkLength <= 0) {
 529             throw new IIOException("sPLT chunk length is not proper");
 530         }
 531 
 532         int sampleDepth = stream.readUnsignedByte();
 533         metadata.sPLT_sampleDepth = sampleDepth;
 534 
 535         int numEntries = remainingChunkLength/(4*(sampleDepth/8) + 2);
 536         metadata.sPLT_red = new int[numEntries];
 537         metadata.sPLT_green = new int[numEntries];
 538         metadata.sPLT_blue = new int[numEntries];
 539         metadata.sPLT_alpha = new int[numEntries];
 540         metadata.sPLT_frequency = new int[numEntries];
 541 
 542         if (sampleDepth == 8) {
 543             for (int i = 0; i < numEntries; i++) {
 544                 metadata.sPLT_red[i] = stream.readUnsignedByte();
 545                 metadata.sPLT_green[i] = stream.readUnsignedByte();
 546                 metadata.sPLT_blue[i] = stream.readUnsignedByte();
 547                 metadata.sPLT_alpha[i] = stream.readUnsignedByte();
 548                 metadata.sPLT_frequency[i] = stream.readUnsignedShort();
 549             }
 550         } else if (sampleDepth == 16) {
 551             for (int i = 0; i < numEntries; i++) {
 552                 metadata.sPLT_red[i] = stream.readUnsignedShort();
 553                 metadata.sPLT_green[i] = stream.readUnsignedShort();
 554                 metadata.sPLT_blue[i] = stream.readUnsignedShort();
 555                 metadata.sPLT_alpha[i] = stream.readUnsignedShort();
 556                 metadata.sPLT_frequency[i] = stream.readUnsignedShort();
 557             }
 558         } else {
 559             throw new IIOException("sPLT sample depth not 8 or 16!");
 560         }
 561 
 562         metadata.sPLT_present = true;
 563     }
 564 
 565     private void parse_sRGB_chunk() throws IOException {
 566         metadata.sRGB_renderingIntent = stream.readUnsignedByte();
 567 
 568         metadata.sRGB_present = true;
 569     }
 570 
 571     private void parse_tEXt_chunk(int chunkLength) throws IOException {
 572         String keyword = readNullTerminatedString("ISO-8859-1", 80);
 573         int textLength = chunkLength - keyword.length() - 1;
 574         if (textLength <= 0) {
 575             throw new IIOException("tEXt chunk length is not proper");
 576         }
 577         metadata.tEXt_keyword.add(keyword);
 578 
 579         byte[] b = new byte[textLength];
 580         stream.readFully(b);
 581         metadata.tEXt_text.add(new String(b, "ISO-8859-1"));
 582 
 583         // Check if the text chunk contains image creation time
 584         if (keyword.equals(PNGMetadata.tEXt_creationTimeKey)) {
 585             // Update Standard/Document/ImageCreationTime from text chunk
 586             int index = metadata.tEXt_text.size() - 1;
 587             metadata.decodeImageCreationTimeFromTextChunk(
 588                     metadata.tEXt_text.listIterator(index));
 589         }
 590     }
 591 
 592     private void parse_tIME_chunk() throws IOException {
 593         metadata.tIME_year = stream.readUnsignedShort();
 594         metadata.tIME_month = stream.readUnsignedByte();
 595         metadata.tIME_day = stream.readUnsignedByte();
 596         metadata.tIME_hour = stream.readUnsignedByte();
 597         metadata.tIME_minute = stream.readUnsignedByte();
 598         metadata.tIME_second = stream.readUnsignedByte();
 599 
 600         metadata.tIME_present = true;
 601     }
 602 
 603     private void parse_tRNS_chunk(int chunkLength) throws IOException {
 604         int colorType = metadata.IHDR_colorType;
 605         if (colorType == PNG_COLOR_PALETTE) {
 606             if (!metadata.PLTE_present) {
 607                 processWarningOccurred(
 608 "tRNS chunk without prior PLTE chunk, ignoring it.");
 609                 return;
 610             }
 611 
 612             // Alpha table may have fewer entries than RGB palette
 613             int maxEntries = metadata.PLTE_red.length;
 614             int numEntries = chunkLength;
 615             if (numEntries > maxEntries && maxEntries > 0) {
 616                 processWarningOccurred(
 617 "tRNS chunk has more entries than prior PLTE chunk, ignoring extras.");
 618                 numEntries = maxEntries;
 619             }
 620             metadata.tRNS_alpha = new byte[numEntries];
 621             metadata.tRNS_colorType = PNG_COLOR_PALETTE;
 622             stream.read(metadata.tRNS_alpha, 0, numEntries);
 623             stream.skipBytes(chunkLength - numEntries);
 624         } else if (colorType == PNG_COLOR_GRAY) {
 625             if (chunkLength != 2) {
 626                 processWarningOccurred(
 627 "tRNS chunk for gray image must have length 2, ignoring chunk.");
 628                 stream.skipBytes(chunkLength);
 629                 return;
 630             }
 631             metadata.tRNS_gray = stream.readUnsignedShort();
 632             metadata.tRNS_colorType = PNG_COLOR_GRAY;
 633         } else if (colorType == PNG_COLOR_RGB) {
 634             if (chunkLength != 6) {
 635                 processWarningOccurred(
 636 "tRNS chunk for RGB image must have length 6, ignoring chunk.");
 637                 stream.skipBytes(chunkLength);
 638                 return;
 639             }
 640             metadata.tRNS_red = stream.readUnsignedShort();
 641             metadata.tRNS_green = stream.readUnsignedShort();
 642             metadata.tRNS_blue = stream.readUnsignedShort();
 643             metadata.tRNS_colorType = PNG_COLOR_RGB;
 644         } else {
 645             processWarningOccurred(
 646 "Gray+Alpha and RGBS images may not have a tRNS chunk, ignoring it.");
 647             return;
 648         }
 649 
 650         metadata.tRNS_present = true;
 651     }
 652 
 653     private static byte[] inflate(byte[] b) throws IOException {
 654         InputStream bais = new ByteArrayInputStream(b);
 655         InputStream iis = new InflaterInputStream(bais);
 656         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 657 
 658         int c;
 659         try {
 660             while ((c = iis.read()) != -1) {
 661                 baos.write(c);
 662             }
 663         } finally {
 664             iis.close();
 665         }
 666         return baos.toByteArray();
 667     }
 668 
 669     private void parse_zTXt_chunk(int chunkLength) throws IOException {
 670         String keyword = readNullTerminatedString("ISO-8859-1", 80);
 671         int textLength = chunkLength - keyword.length() - 2;
 672         if (textLength <= 0) {
 673             throw new IIOException("zTXt chunk length is not proper");
 674         }
 675         metadata.zTXt_keyword.add(keyword);
 676 
 677         int method = stream.readUnsignedByte();
 678         metadata.zTXt_compressionMethod.add(method);
 679 
 680         byte[] b = new byte[textLength];
 681         stream.readFully(b);
 682         metadata.zTXt_text.add(new String(inflate(b), "ISO-8859-1"));
 683 
 684         // Check if the text chunk contains image creation time
 685         if (keyword.equals(PNGMetadata.tEXt_creationTimeKey)) {
 686             // Update Standard/Document/ImageCreationTime from text chunk
 687             int index = metadata.zTXt_text.size() - 1;
 688             metadata.decodeImageCreationTimeFromTextChunk(
 689                     metadata.zTXt_text.listIterator(index));
 690         }
 691     }
 692 
 693     private void readMetadata() throws IIOException {
 694         if (gotMetadata) {
 695             return;
 696         }
 697 
 698         readHeader();
 699 
 700         /*
 701          * Optimization: We can skip reading metadata if ignoreMetadata
 702          * flag is set and colorType is not PNG_COLOR_PALETTE. However,
 703          * we parse tRNS chunk to retrieve the transparent color from the
 704          * metadata. Doing so, helps PNGImageReader to appropriately
 705          * identify and set transparent pixels in the decoded image for
 706          * colorType PNG_COLOR_RGB and PNG_COLOR_GRAY.
 707          */
 708         int colorType = metadata.IHDR_colorType;
 709         if (ignoreMetadata && colorType != PNG_COLOR_PALETTE) {
 710             try {
 711                 while (true) {
 712                     int chunkLength = stream.readInt();
 713 
 714                     // verify the chunk length first
 715                     if (chunkLength < 0 || chunkLength + 4 < 0) {
 716                         throw new IIOException("Invalid chunk length " + chunkLength);
 717                     }
 718 
 719                     int chunkType = stream.readInt();
 720 
 721                     if (chunkType == IDAT_TYPE) {
 722                         // We've reached the first IDAT chunk position
 723                         stream.skipBytes(-8);
 724                         imageStartPosition = stream.getStreamPosition();
 725                         /*
 726                          * According to PNG specification tRNS chunk must
 727                          * precede the first IDAT chunk. So we can stop
 728                          * reading metadata.
 729                          */
 730                         break;
 731                     } else if (chunkType == tRNS_TYPE) {
 732                         parse_tRNS_chunk(chunkLength);
 733                         // After parsing tRNS chunk we will skip 4 CRC bytes
 734                         stream.skipBytes(4);
 735                     } else {
 736                         // Skip the chunk plus the 4 CRC bytes that follow
 737                         stream.skipBytes(chunkLength + 4);
 738                     }
 739                 }
 740             } catch (IOException e) {
 741                 throw new IIOException("Error skipping PNG metadata", e);
 742             }
 743 
 744             gotMetadata = true;
 745             return;
 746         }
 747 
 748         try {
 749             loop: while (true) {
 750                 int chunkLength = stream.readInt();
 751                 int chunkType = stream.readInt();
 752                 int chunkCRC;
 753 
 754                 // verify the chunk length
 755                 if (chunkLength < 0) {
 756                     throw new IIOException("Invalid chunk length " + chunkLength);
 757                 };
 758 
 759                 try {
 760                     stream.mark();
 761                     stream.seek(stream.getStreamPosition() + chunkLength);
 762                     chunkCRC = stream.readInt();
 763                     stream.reset();
 764                 } catch (IOException e) {
 765                     throw new IIOException("Invalid chunk length " + chunkLength);
 766                 }
 767 
 768                 switch (chunkType) {
 769                 case IDAT_TYPE:
 770                     // If chunk type is 'IDAT', we've reached the image data.
 771                     if (imageStartPosition == -1L) {
 772                         /*
 773                          * The PNG specification mandates that if colorType is
 774                          * PNG_COLOR_PALETTE then the PLTE chunk should appear
 775                          * before the first IDAT chunk.
 776                          */
 777                         if (colorType == PNG_COLOR_PALETTE &&
 778                             !(metadata.PLTE_present))
 779                         {
 780                             throw new IIOException("Required PLTE chunk"
 781                                     + " missing");
 782                         }
 783                         /*
 784                          * PNGs may contain multiple IDAT chunks containing
 785                          * a portion of image data. We store the position of
 786                          * the first IDAT chunk and continue with iteration
 787                          * of other chunks that follow image data.
 788                          */
 789                         imageStartPosition = stream.getStreamPosition() - 8;
 790                     }
 791                     // Move to the CRC byte location.
 792                     stream.skipBytes(chunkLength);
 793                     break;
 794                 case IEND_TYPE:
 795                     /*
 796                      * If the chunk type is 'IEND', we've reached end of image.
 797                      * Seek to the first IDAT chunk for subsequent decoding.
 798                      */
 799                     stream.seek(imageStartPosition);
 800 
 801                     /*
 802                      * flushBefore discards the portion of the stream before
 803                      * the indicated position. Hence this should be used after
 804                      * we complete iteration over available chunks including
 805                      * those that appear after the IDAT.
 806                      */
 807                     stream.flushBefore(stream.getStreamPosition());
 808                     break loop;
 809                 case PLTE_TYPE:
 810                     parse_PLTE_chunk(chunkLength);
 811                     break;
 812                 case bKGD_TYPE:
 813                     parse_bKGD_chunk();
 814                     break;
 815                 case cHRM_TYPE:
 816                     parse_cHRM_chunk();
 817                     break;
 818                 case gAMA_TYPE:
 819                     parse_gAMA_chunk();
 820                     break;
 821                 case hIST_TYPE:
 822                     parse_hIST_chunk(chunkLength);
 823                     break;
 824                 case iCCP_TYPE:
 825                     parse_iCCP_chunk(chunkLength);
 826                     break;
 827                 case iTXt_TYPE:
 828                     if (ignoreMetadata) {
 829                         stream.skipBytes(chunkLength);
 830                     } else {
 831                         parse_iTXt_chunk(chunkLength);
 832                     }
 833                     break;
 834                 case pHYs_TYPE:
 835                     parse_pHYs_chunk();
 836                     break;
 837                 case sBIT_TYPE:
 838                     parse_sBIT_chunk();
 839                     break;
 840                 case sPLT_TYPE:
 841                     parse_sPLT_chunk(chunkLength);
 842                     break;
 843                 case sRGB_TYPE:
 844                     parse_sRGB_chunk();
 845                     break;
 846                 case tEXt_TYPE:
 847                     parse_tEXt_chunk(chunkLength);
 848                     break;
 849                 case tIME_TYPE:
 850                     parse_tIME_chunk();
 851                     break;
 852                 case tRNS_TYPE:
 853                     parse_tRNS_chunk(chunkLength);
 854                     break;
 855                 case zTXt_TYPE:
 856                     if (ignoreMetadata) {
 857                         stream.skipBytes(chunkLength);
 858                     } else {
 859                         parse_zTXt_chunk(chunkLength);
 860                     }
 861                     break;
 862                 default:
 863                     // Read an unknown chunk
 864                     byte[] b = new byte[chunkLength];
 865                     stream.readFully(b);
 866 
 867                     StringBuilder chunkName = new StringBuilder(4);
 868                     chunkName.append((char)(chunkType >>> 24));
 869                     chunkName.append((char)((chunkType >> 16) & 0xff));
 870                     chunkName.append((char)((chunkType >> 8) & 0xff));
 871                     chunkName.append((char)(chunkType & 0xff));
 872 
 873                     int ancillaryBit = chunkType >>> 28;
 874                     if (ancillaryBit == 0) {
 875                         processWarningOccurred(
 876 "Encountered unknown chunk with critical bit set!");
 877                     }
 878 
 879                     metadata.unknownChunkType.add(chunkName.toString());
 880                     metadata.unknownChunkData.add(b);
 881                     break;
 882                 }
 883 
 884                 // double check whether all chunk data were consumed
 885                 if (chunkCRC != stream.readInt()) {
 886                     throw new IIOException("Failed to read a chunk of type " +
 887                             chunkType);
 888                 }
 889             }
 890         } catch (IOException e) {
 891             throw new IIOException("Error reading PNG metadata", e);
 892         }
 893 
 894         gotMetadata = true;
 895     }
 896 
 897     // Data filtering methods
 898 
 899     private static void decodeSubFilter(byte[] curr, int coff, int count,
 900                                         int bpp) {
 901         for (int i = bpp; i < count; i++) {
 902             int val;
 903 
 904             val = curr[i + coff] & 0xff;
 905             val += curr[i + coff - bpp] & 0xff;
 906 
 907             curr[i + coff] = (byte)val;
 908         }
 909     }
 910 
 911     private static void decodeUpFilter(byte[] curr, int coff,
 912                                        byte[] prev, int poff,
 913                                        int count) {
 914         for (int i = 0; i < count; i++) {
 915             int raw = curr[i + coff] & 0xff;
 916             int prior = prev[i + poff] & 0xff;
 917 
 918             curr[i + coff] = (byte)(raw + prior);
 919         }
 920     }
 921 
 922     private static void decodeAverageFilter(byte[] curr, int coff,
 923                                             byte[] prev, int poff,
 924                                             int count, int bpp) {
 925         int raw, priorPixel, priorRow;
 926 
 927         for (int i = 0; i < bpp; i++) {
 928             raw = curr[i + coff] & 0xff;
 929             priorRow = prev[i + poff] & 0xff;
 930 
 931             curr[i + coff] = (byte)(raw + priorRow/2);
 932         }
 933 
 934         for (int i = bpp; i < count; i++) {
 935             raw = curr[i + coff] & 0xff;
 936             priorPixel = curr[i + coff - bpp] & 0xff;
 937             priorRow = prev[i + poff] & 0xff;
 938 
 939             curr[i + coff] = (byte)(raw + (priorPixel + priorRow)/2);
 940         }
 941     }
 942 
 943     private static int paethPredictor(int a, int b, int c) {
 944         int p = a + b - c;
 945         int pa = Math.abs(p - a);
 946         int pb = Math.abs(p - b);
 947         int pc = Math.abs(p - c);
 948 
 949         if ((pa <= pb) && (pa <= pc)) {
 950             return a;
 951         } else if (pb <= pc) {
 952             return b;
 953         } else {
 954             return c;
 955         }
 956     }
 957 
 958     private static void decodePaethFilter(byte[] curr, int coff,
 959                                           byte[] prev, int poff,
 960                                           int count, int bpp) {
 961         int raw, priorPixel, priorRow, priorRowPixel;
 962 
 963         for (int i = 0; i < bpp; i++) {
 964             raw = curr[i + coff] & 0xff;
 965             priorRow = prev[i + poff] & 0xff;
 966 
 967             curr[i + coff] = (byte)(raw + priorRow);
 968         }
 969 
 970         for (int i = bpp; i < count; i++) {
 971             raw = curr[i + coff] & 0xff;
 972             priorPixel = curr[i + coff - bpp] & 0xff;
 973             priorRow = prev[i + poff] & 0xff;
 974             priorRowPixel = prev[i + poff - bpp] & 0xff;
 975 
 976             curr[i + coff] = (byte)(raw + paethPredictor(priorPixel,
 977                                                          priorRow,
 978                                                          priorRowPixel));
 979         }
 980     }
 981 
 982     private static final int[][] bandOffsets = {
 983         null,
 984         { 0 }, // G
 985         { 0, 1 }, // GA in GA order
 986         { 0, 1, 2 }, // RGB in RGB order
 987         { 0, 1, 2, 3 } // RGBA in RGBA order
 988     };
 989 
 990     private WritableRaster createRaster(int width, int height, int bands,
 991                                         int scanlineStride,
 992                                         int bitDepth) {
 993 
 994         DataBuffer dataBuffer;
 995         WritableRaster ras = null;
 996         Point origin = new Point(0, 0);
 997         if ((bitDepth < 8) && (bands == 1)) {
 998             dataBuffer = new DataBufferByte(height*scanlineStride);
 999             ras = Raster.createPackedRaster(dataBuffer,
1000                                             width, height,
1001                                             bitDepth,
1002                                             origin);
1003         } else if (bitDepth <= 8) {
1004             dataBuffer = new DataBufferByte(height*scanlineStride);
1005             ras = Raster.createInterleavedRaster(dataBuffer,
1006                                                  width, height,
1007                                                  scanlineStride,
1008                                                  bands,
1009                                                  bandOffsets[bands],
1010                                                  origin);
1011         } else {
1012             dataBuffer = new DataBufferUShort(height*scanlineStride);
1013             ras = Raster.createInterleavedRaster(dataBuffer,
1014                                                  width, height,
1015                                                  scanlineStride,
1016                                                  bands,
1017                                                  bandOffsets[bands],
1018                                                  origin);
1019         }
1020 
1021         return ras;
1022     }
1023 
1024     private void skipPass(int passWidth, int passHeight)
1025         throws IOException, IIOException  {
1026         if ((passWidth == 0) || (passHeight == 0)) {
1027             return;
1028         }
1029 
1030         int inputBands = inputBandsForColorType[metadata.IHDR_colorType];
1031         int bitsPerRow = Math.
1032                 multiplyExact((inputBands * metadata.IHDR_bitDepth), passWidth);
1033         int bytesPerRow = (bitsPerRow + 7) / 8;
1034 
1035         // Read the image row-by-row
1036         for (int srcY = 0; srcY < passHeight; srcY++) {
1037             // Skip filter byte and the remaining row bytes
1038             pixelStream.skipBytes(1 + bytesPerRow);
1039         }
1040     }
1041 
1042     private void updateImageProgress(int newPixels) {
1043         pixelsDone += newPixels;
1044         processImageProgress(100.0F*pixelsDone/totalPixels);
1045     }
1046 
1047     private void decodePass(int passNum,
1048                             int xStart, int yStart,
1049                             int xStep, int yStep,
1050                             int passWidth, int passHeight) throws IOException {
1051 
1052         if ((passWidth == 0) || (passHeight == 0)) {
1053             return;
1054         }
1055 
1056         WritableRaster imRas = theImage.getWritableTile(0, 0);
1057         int dstMinX = imRas.getMinX();
1058         int dstMaxX = dstMinX + imRas.getWidth() - 1;
1059         int dstMinY = imRas.getMinY();
1060         int dstMaxY = dstMinY + imRas.getHeight() - 1;
1061 
1062         // Determine which pixels will be updated in this pass
1063         int[] vals =
1064           ReaderUtil.computeUpdatedPixels(sourceRegion,
1065                                           destinationOffset,
1066                                           dstMinX, dstMinY,
1067                                           dstMaxX, dstMaxY,
1068                                           sourceXSubsampling,
1069                                           sourceYSubsampling,
1070                                           xStart, yStart,
1071                                           passWidth, passHeight,
1072                                           xStep, yStep);
1073         int updateMinX = vals[0];
1074         int updateMinY = vals[1];
1075         int updateWidth = vals[2];
1076         int updateXStep = vals[4];
1077         int updateYStep = vals[5];
1078 
1079         int bitDepth = metadata.IHDR_bitDepth;
1080         int inputBands = inputBandsForColorType[metadata.IHDR_colorType];
1081         int bytesPerPixel = (bitDepth == 16) ? 2 : 1;
1082         bytesPerPixel *= inputBands;
1083 
1084         int bitsPerRow = Math.multiplyExact((inputBands * bitDepth), passWidth);
1085         int bytesPerRow = (bitsPerRow + 7) / 8;
1086         int eltsPerRow = (bitDepth == 16) ? bytesPerRow/2 : bytesPerRow;
1087 
1088         // If no pixels need updating, just skip the input data
1089         if (updateWidth == 0) {
1090             for (int srcY = 0; srcY < passHeight; srcY++) {
1091                 // Update count of pixels read
1092                 updateImageProgress(passWidth);
1093                 /*
1094                  * If read has been aborted, just return
1095                  * processReadAborted will be called later
1096                  */
1097                 if (abortRequested()) {
1098                     return;
1099                 }
1100                 // Skip filter byte and the remaining row bytes
1101                 pixelStream.skipBytes(1 + bytesPerRow);
1102             }
1103             return;
1104         }
1105 
1106         // Backwards map from destination pixels
1107         // (dstX = updateMinX + k*updateXStep)
1108         // to source pixels (sourceX), and then
1109         // to offset and skip in passRow (srcX and srcXStep)
1110         int sourceX =
1111             (updateMinX - destinationOffset.x)*sourceXSubsampling +
1112             sourceRegion.x;
1113         int srcX = (sourceX - xStart)/xStep;
1114 
1115         // Compute the step factor in the source
1116         int srcXStep = updateXStep*sourceXSubsampling/xStep;
1117 
1118         byte[] byteData = null;
1119         short[] shortData = null;
1120         byte[] curr = new byte[bytesPerRow];
1121         byte[] prior = new byte[bytesPerRow];
1122 
1123         // Create a 1-row tall Raster to hold the data
1124         WritableRaster passRow = createRaster(passWidth, 1, inputBands,
1125                                               eltsPerRow,
1126                                               bitDepth);
1127 
1128         // Create an array suitable for holding one pixel
1129         int[] ps = passRow.getPixel(0, 0, (int[])null);
1130 
1131         DataBuffer dataBuffer = passRow.getDataBuffer();
1132         int type = dataBuffer.getDataType();
1133         if (type == DataBuffer.TYPE_BYTE) {
1134             byteData = ((DataBufferByte)dataBuffer).getData();
1135         } else {
1136             shortData = ((DataBufferUShort)dataBuffer).getData();
1137         }
1138 
1139         processPassStarted(theImage,
1140                            passNum,
1141                            sourceMinProgressivePass,
1142                            sourceMaxProgressivePass,
1143                            updateMinX, updateMinY,
1144                            updateXStep, updateYStep,
1145                            destinationBands);
1146 
1147         // Handle source and destination bands
1148         if (sourceBands != null) {
1149             passRow = passRow.createWritableChild(0, 0,
1150                                                   passRow.getWidth(), 1,
1151                                                   0, 0,
1152                                                   sourceBands);
1153         }
1154         if (destinationBands != null) {
1155             imRas = imRas.createWritableChild(0, 0,
1156                                               imRas.getWidth(),
1157                                               imRas.getHeight(),
1158                                               0, 0,
1159                                               destinationBands);
1160         }
1161 
1162         boolean tRNSTransparentPixelPresent =
1163                 theImage.getSampleModel().getNumBands() == inputBands + 1 &&
1164                 metadata.hasTransparentColor();
1165         // Determine if all of the relevant output bands have the
1166         // same bit depth as the source data
1167         boolean adjustBitDepths = false;
1168         int[] outputSampleSize = imRas.getSampleModel().getSampleSize();
1169         int numBands;
1170         if (tRNSTransparentPixelPresent) {
1171             numBands = outputSampleSize.length - 1;
1172         } else {
1173             numBands = outputSampleSize.length;
1174         }
1175         for (int b = 0; b < numBands; b++) {
1176             if (outputSampleSize[b] != bitDepth) {
1177                 adjustBitDepths = true;
1178                 break;
1179             }
1180         }
1181 
1182         // If the bit depths differ, create a lookup table per band to perform
1183         // the conversion
1184         int[][] scale = null;
1185         if (adjustBitDepths) {
1186             int maxInSample = (1 << bitDepth) - 1;
1187             int halfMaxInSample = maxInSample/2;
1188             scale = new int[numBands][];
1189             for (int b = 0; b < numBands; b++) {
1190                 int maxOutSample = (1 << outputSampleSize[b]) - 1;
1191                 scale[b] = new int[maxInSample + 1];
1192                 for (int s = 0; s <= maxInSample; s++) {
1193                     scale[b][s] =
1194                         (s*maxOutSample + halfMaxInSample)/maxInSample;
1195                 }
1196             }
1197         }
1198 
1199         // Limit passRow to relevant area for the case where we
1200         // will can setRect to copy a contiguous span
1201         boolean useSetRect = srcXStep == 1 &&
1202             updateXStep == 1 &&
1203             !adjustBitDepths &&
1204             (imRas instanceof ByteInterleavedRaster);
1205 
1206         if (useSetRect) {
1207             passRow = passRow.createWritableChild(srcX, 0,
1208                                                   updateWidth, 1,
1209                                                   0, 0,
1210                                                   null);
1211         }
1212 
1213         // Decode the (sub)image row-by-row
1214         for (int srcY = 0; srcY < passHeight; srcY++) {
1215             // Update count of pixels read
1216             updateImageProgress(passWidth);
1217             /*
1218              * If read has been aborted, just return
1219              * processReadAborted will be called later
1220              */
1221             if (abortRequested()) {
1222                 return;
1223             }
1224             // Read the filter type byte and a row of data
1225             int filter = pixelStream.read();
1226             try {
1227                 // Swap curr and prior
1228                 byte[] tmp = prior;
1229                 prior = curr;
1230                 curr = tmp;
1231 
1232                 pixelStream.readFully(curr, 0, bytesPerRow);
1233             } catch (java.util.zip.ZipException ze) {
1234                 // TODO - throw a more meaningful exception
1235                 throw ze;
1236             }
1237 
1238             switch (filter) {
1239             case PNG_FILTER_NONE:
1240                 break;
1241             case PNG_FILTER_SUB:
1242                 decodeSubFilter(curr, 0, bytesPerRow, bytesPerPixel);
1243                 break;
1244             case PNG_FILTER_UP:
1245                 decodeUpFilter(curr, 0, prior, 0, bytesPerRow);
1246                 break;
1247             case PNG_FILTER_AVERAGE:
1248                 decodeAverageFilter(curr, 0, prior, 0, bytesPerRow,
1249                                     bytesPerPixel);
1250                 break;
1251             case PNG_FILTER_PAETH:
1252                 decodePaethFilter(curr, 0, prior, 0, bytesPerRow,
1253                                   bytesPerPixel);
1254                 break;
1255             default:
1256                 throw new IIOException("Unknown row filter type (= " +
1257                                        filter + ")!");
1258             }
1259 
1260             // Copy data into passRow byte by byte
1261             if (bitDepth < 16) {
1262                 System.arraycopy(curr, 0, byteData, 0, bytesPerRow);
1263             } else {
1264                 int idx = 0;
1265                 for (int j = 0; j < eltsPerRow; j++) {
1266                     shortData[j] =
1267                         (short)((curr[idx] << 8) | (curr[idx + 1] & 0xff));
1268                     idx += 2;
1269                 }
1270             }
1271 
1272             // True Y position in source
1273             int sourceY = srcY*yStep + yStart;
1274             if ((sourceY >= sourceRegion.y) &&
1275                 (sourceY < sourceRegion.y + sourceRegion.height) &&
1276                 (((sourceY - sourceRegion.y) %
1277                   sourceYSubsampling) == 0)) {
1278 
1279                 int dstY = destinationOffset.y +
1280                     (sourceY - sourceRegion.y)/sourceYSubsampling;
1281                 if (dstY < dstMinY) {
1282                     continue;
1283                 }
1284                 if (dstY > dstMaxY) {
1285                     break;
1286                 }
1287 
1288                /*
1289                 * For PNG images of color type PNG_COLOR_RGB or PNG_COLOR_GRAY
1290                 * that contain a specific transparent color (given by tRNS
1291                 * chunk), we compare the decoded pixel color with the color
1292                 * given by tRNS chunk to set the alpha on the destination.
1293                 */



1294                 if (useSetRect &&
1295                     !tRNSTransparentPixelPresent) {
1296                     imRas.setRect(updateMinX, dstY, passRow);
1297                 } else {
1298                     int newSrcX = srcX;
1299 
1300                     /*
1301                      * Create intermediate array to fill the extra alpha
1302                      * channel when tRNSTransparentPixelPresent is true.
1303                      */
1304                     final int[] temp = new int[inputBands + 1];
1305                     final int opaque = (bitDepth < 16) ? 255 : 65535;
1306                     for (int dstX = updateMinX;
1307                          dstX < updateMinX + updateWidth;
1308                          dstX += updateXStep) {
1309 
1310                         passRow.getPixel(newSrcX, 0, ps);
1311                         if (adjustBitDepths) {
1312                             for (int b = 0; b < numBands; b++) {
1313                                 ps[b] = scale[b][ps[b]];
1314                             }
1315                         }
1316                         if (tRNSTransparentPixelPresent) {
1317                             if (metadata.tRNS_colorType == PNG_COLOR_RGB) {
1318                                 temp[0] = ps[0];
1319                                 temp[1] = ps[1];
1320                                 temp[2] = ps[2];
1321                                 if (ps[0] == metadata.tRNS_red &&
1322                                     ps[1] == metadata.tRNS_green &&
1323                                     ps[2] == metadata.tRNS_blue) {
1324                                     temp[3] = 0;
1325                                 } else {
1326                                     temp[3] = opaque;
1327                                 }
1328                             } else {
1329                                 // when tRNS_colorType is PNG_COLOR_GRAY
1330                                 temp[0] = ps[0];
1331                                 if (ps[0] == metadata.tRNS_gray) {
1332                                     temp[1] = 0;
1333                                 } else {
1334                                     temp[1] = opaque;
1335                                 }
1336                             }
1337                             imRas.setPixel(dstX, dstY, temp);
1338                         } else {
1339                             imRas.setPixel(dstX, dstY, ps);
1340                         }
1341                         newSrcX += srcXStep;
1342                     }
1343                 }
1344 
1345                 processImageUpdate(theImage,
1346                                    updateMinX, dstY,
1347                                    updateWidth, 1,
1348                                    updateXStep, updateYStep,
1349                                    destinationBands);
1350             }
1351         }
1352 
1353         processPassComplete(theImage);
1354     }
1355 
1356     private void decodeImage()
1357         throws IOException, IIOException  {
1358         int width = metadata.IHDR_width;
1359         int height = metadata.IHDR_height;
1360 
1361         this.pixelsDone = 0;
1362         this.totalPixels = width*height;
1363 
1364         if (metadata.IHDR_interlaceMethod == 0) {
1365             decodePass(0, 0, 0, 1, 1, width, height);
1366         } else {
1367             for (int i = 0; i <= sourceMaxProgressivePass; i++) {
1368                 int XOffset = adam7XOffset[i];
1369                 int YOffset = adam7YOffset[i];
1370                 int XSubsampling = adam7XSubsampling[i];
1371                 int YSubsampling = adam7YSubsampling[i];
1372                 int xbump = adam7XSubsampling[i + 1] - 1;
1373                 int ybump = adam7YSubsampling[i + 1] - 1;
1374 
1375                 if (i >= sourceMinProgressivePass) {
1376                     decodePass(i,
1377                                XOffset,
1378                                YOffset,
1379                                XSubsampling,
1380                                YSubsampling,
1381                                (width + xbump)/XSubsampling,
1382                                (height + ybump)/YSubsampling);
1383                 } else {
1384                     skipPass((width + xbump)/XSubsampling,
1385                              (height + ybump)/YSubsampling);
1386                 }
1387 
1388                 /*
1389                  * If read has been aborted, just return
1390                  * processReadAborted will be called later
1391                  */
1392                 if (abortRequested()) {
1393                     return;
1394                 }
1395             }
1396         }
1397     }
1398 
1399     private void readImage(ImageReadParam param) throws IIOException {
1400         readMetadata();
1401 
1402         int width = metadata.IHDR_width;
1403         int height = metadata.IHDR_height;
1404 
1405         // Init default values
1406         sourceXSubsampling = 1;
1407         sourceYSubsampling = 1;
1408         sourceMinProgressivePass = 0;
1409         sourceMaxProgressivePass = 6;
1410         sourceBands = null;
1411         destinationBands = null;
1412         destinationOffset = new Point(0, 0);
1413 
1414         // If an ImageReadParam is available, get values from it
1415         if (param != null) {
1416             sourceXSubsampling = param.getSourceXSubsampling();
1417             sourceYSubsampling = param.getSourceYSubsampling();
1418 
1419             sourceMinProgressivePass =
1420                 Math.max(param.getSourceMinProgressivePass(), 0);
1421             sourceMaxProgressivePass =
1422                 Math.min(param.getSourceMaxProgressivePass(), 6);
1423 
1424             sourceBands = param.getSourceBands();
1425             destinationBands = param.getDestinationBands();
1426             destinationOffset = param.getDestinationOffset();
1427         }
1428         Inflater inf = null;
1429         try {
1430             stream.seek(imageStartPosition);
1431 
1432             Enumeration<InputStream> e = new PNGImageDataEnumeration(stream);
1433             InputStream is = new SequenceInputStream(e);
1434 
1435            /* InflaterInputStream uses an Inflater instance which consumes
1436             * native (non-GC visible) resources. This is normally implicitly
1437             * freed when the stream is closed. However since the
1438             * InflaterInputStream wraps a client-supplied input stream,
1439             * we cannot close it.
1440             * But the app may depend on GC finalization to close the stream.
1441             * Therefore to ensure timely freeing of native resources we
1442             * explicitly create the Inflater instance and free its resources
1443             * when we are done with the InflaterInputStream by calling
1444             * inf.end();
1445             */
1446             inf = new Inflater();
1447             is = new InflaterInputStream(is, inf);
1448             is = new BufferedInputStream(is);
1449             this.pixelStream = new DataInputStream(is);
1450 
1451             /*
1452              * PNG spec declares that valid range for width
1453              * and height is [1, 2^31-1], so here we may fail to allocate
1454              * a buffer for destination image due to memory limitation.
1455              *
1456              * If the read operation triggers OutOfMemoryError, the same
1457              * will be wrapped in an IIOException at PNGImageReader.read
1458              * method.
1459              *
1460              * The recovery strategy for this case should be defined at
1461              * the level of application, so we will not try to estimate
1462              * the required amount of the memory and/or handle OOM in
1463              * any way.
1464              */
1465             theImage = getDestination(param,
1466                                       getImageTypes(0),
1467                                       width,
1468                                       height);
1469 
1470             Rectangle destRegion = new Rectangle(0, 0, 0, 0);
1471             sourceRegion = new Rectangle(0, 0, 0, 0);
1472             computeRegions(param, width, height,
1473                            theImage,
1474                            sourceRegion, destRegion);
1475             destinationOffset.setLocation(destRegion.getLocation());
1476 
1477             // At this point the header has been read and we know
1478             // how many bands are in the image, so perform checking
1479             // of the read param.
1480             int colorType = metadata.IHDR_colorType;
1481             if (theImage.getSampleModel().getNumBands()
1482                 == inputBandsForColorType[colorType] + 1
1483                 && metadata.hasTransparentColor()) {
1484                 checkReadParamBandSettings(param,
1485                     inputBandsForColorType[colorType] + 1,
1486                     theImage.getSampleModel().getNumBands());
1487             } else {
1488                 checkReadParamBandSettings(param,
1489                     inputBandsForColorType[colorType],
1490                     theImage.getSampleModel().getNumBands());
1491             }
1492 
1493             clearAbortRequest();
1494             processImageStarted(0);
1495             if (abortRequested()) {
1496                 processReadAborted();
1497             } else {
1498                 decodeImage();
1499                 if (abortRequested()) {
1500                     processReadAborted();
1501                 } else {
1502                     processImageComplete();
1503                 }
1504             }
1505 
1506         } catch (IOException e) {
1507             throw new IIOException("Error reading PNG image data", e);
1508         } finally {
1509             if (inf != null) {
1510                 inf.end();
1511             }
1512         }
1513     }
1514 
1515     public int getNumImages(boolean allowSearch) throws IIOException {
1516         if (stream == null) {
1517             throw new IllegalStateException("No input source set!");
1518         }
1519         if (seekForwardOnly && allowSearch) {
1520             throw new IllegalStateException
1521                 ("seekForwardOnly and allowSearch can't both be true!");
1522         }
1523         return 1;
1524     }
1525 
1526     public int getWidth(int imageIndex) throws IIOException {
1527         if (imageIndex != 0) {
1528             throw new IndexOutOfBoundsException("imageIndex != 0!");
1529         }
1530 
1531         readHeader();
1532 
1533         return metadata.IHDR_width;
1534     }
1535 
1536     public int getHeight(int imageIndex) throws IIOException {
1537         if (imageIndex != 0) {
1538             throw new IndexOutOfBoundsException("imageIndex != 0!");
1539         }
1540 
1541         readHeader();
1542 
1543         return metadata.IHDR_height;
1544     }
1545 
1546     public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex)
1547       throws IIOException
1548     {
1549         if (imageIndex != 0) {
1550             throw new IndexOutOfBoundsException("imageIndex != 0!");
1551         }
1552 
1553         readHeader();
1554 
1555         ArrayList<ImageTypeSpecifier> l =
1556             new ArrayList<ImageTypeSpecifier>(1);
1557 
1558         ColorSpace rgb;
1559         ColorSpace gray;
1560         int[] bandOffsets;
1561 
1562         int bitDepth = metadata.IHDR_bitDepth;
1563         int colorType = metadata.IHDR_colorType;
1564 
1565         int dataType;
1566         if (bitDepth <= 8) {
1567             dataType = DataBuffer.TYPE_BYTE;
1568         } else {
1569             dataType = DataBuffer.TYPE_USHORT;
1570         }
1571 
1572         switch (colorType) {
1573         /*
1574          * For PNG images of color type PNG_COLOR_RGB or PNG_COLOR_GRAY that
1575          * contain a specific transparent color (given by tRNS chunk), we add
1576          * ImageTypeSpecifier(s) that support transparency to the list of
1577          * supported image types.
1578          */
1579         case PNG_COLOR_GRAY:
1580             readMetadata(); // Need tRNS chunk
1581 
1582             if (metadata.hasTransparentColor()) {
1583                 gray = ColorSpace.getInstance(ColorSpace.CS_GRAY);
1584                 bandOffsets = new int[2];
1585                 bandOffsets[0] = 0;
1586                 bandOffsets[1] = 1;
1587                 l.add(ImageTypeSpecifier.createInterleaved(gray,
1588                                                            bandOffsets,
1589                                                            dataType,
1590                                                            true,
1591                                                            false));
1592             }
1593             // Packed grayscale
1594             l.add(ImageTypeSpecifier.createGrayscale(bitDepth,
1595                                                      dataType,
1596                                                      false));
1597             break;
1598 
1599         case PNG_COLOR_RGB:
1600             readMetadata(); // Need tRNS chunk
1601 
1602             if (bitDepth == 8) {
1603                 if (metadata.hasTransparentColor()) {
1604                     l.add(ImageTypeSpecifier.createFromBufferedImageType(
1605                             BufferedImage.TYPE_4BYTE_ABGR));
1606                 }
1607                 // some standard types of buffered images
1608                 // which can be used as destination
1609                 l.add(ImageTypeSpecifier.createFromBufferedImageType(
1610                           BufferedImage.TYPE_3BYTE_BGR));
1611 
1612                 l.add(ImageTypeSpecifier.createFromBufferedImageType(
1613                           BufferedImage.TYPE_INT_RGB));
1614 
1615                 l.add(ImageTypeSpecifier.createFromBufferedImageType(
1616                           BufferedImage.TYPE_INT_BGR));
1617 
1618             }
1619 
1620             if (metadata.hasTransparentColor()) {
1621                 rgb = ColorSpace.getInstance(ColorSpace.CS_sRGB);
1622                 bandOffsets = new int[4];
1623                 bandOffsets[0] = 0;
1624                 bandOffsets[1] = 1;
1625                 bandOffsets[2] = 2;
1626                 bandOffsets[3] = 3;
1627 
1628                 l.add(ImageTypeSpecifier.
1629                     createInterleaved(rgb, bandOffsets,
1630                                       dataType, true, false));
1631             }
1632             // Component R, G, B
1633             rgb = ColorSpace.getInstance(ColorSpace.CS_sRGB);
1634             bandOffsets = new int[3];
1635             bandOffsets[0] = 0;
1636             bandOffsets[1] = 1;
1637             bandOffsets[2] = 2;
1638             l.add(ImageTypeSpecifier.createInterleaved(rgb,
1639                                                        bandOffsets,
1640                                                        dataType,
1641                                                        false,
1642                                                        false));
1643             break;
1644 
1645         case PNG_COLOR_PALETTE:
1646             readMetadata(); // Need tRNS chunk
1647 
1648             /*
1649              * The PLTE chunk spec says:
1650              *
1651              * The number of palette entries must not exceed the range that
1652              * can be represented in the image bit depth (for example, 2^4 = 16
1653              * for a bit depth of 4). It is permissible to have fewer entries
1654              * than the bit depth would allow. In that case, any out-of-range
1655              * pixel value found in the image data is an error.
1656              *
1657              * http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.PLTE
1658              *
1659              * Consequently, the case when the palette length is smaller than
1660              * 2^bitDepth is legal in the view of PNG spec.
1661              *
1662              * However the spec of createIndexed() method demands the exact
1663              * equality of the palette lengh and number of possible palette
1664              * entries (2^bitDepth).
1665              *
1666              * {@link javax.imageio.ImageTypeSpecifier.html#createIndexed}
1667              *
1668              * In order to avoid this contradiction we need to extend the
1669              * palette arrays to the limit defined by the bitDepth.
1670              */
1671 
1672             int plength = 1 << bitDepth;
1673 
1674             byte[] red = metadata.PLTE_red;
1675             byte[] green = metadata.PLTE_green;
1676             byte[] blue = metadata.PLTE_blue;
1677 
1678             if (metadata.PLTE_red.length < plength) {
1679                 red = Arrays.copyOf(metadata.PLTE_red, plength);
1680                 Arrays.fill(red, metadata.PLTE_red.length, plength,
1681                             metadata.PLTE_red[metadata.PLTE_red.length - 1]);
1682 
1683                 green = Arrays.copyOf(metadata.PLTE_green, plength);
1684                 Arrays.fill(green, metadata.PLTE_green.length, plength,
1685                             metadata.PLTE_green[metadata.PLTE_green.length - 1]);
1686 
1687                 blue = Arrays.copyOf(metadata.PLTE_blue, plength);
1688                 Arrays.fill(blue, metadata.PLTE_blue.length, plength,
1689                             metadata.PLTE_blue[metadata.PLTE_blue.length - 1]);
1690 
1691             }
1692 
1693             // Alpha from tRNS chunk may have fewer entries than
1694             // the RGB LUTs from the PLTE chunk; if so, pad with
1695             // 255.
1696             byte[] alpha = null;
1697             if (metadata.tRNS_present && (metadata.tRNS_alpha != null)) {
1698                 if (metadata.tRNS_alpha.length == red.length) {
1699                     alpha = metadata.tRNS_alpha;
1700                 } else {
1701                     alpha = Arrays.copyOf(metadata.tRNS_alpha, red.length);
1702                     Arrays.fill(alpha,
1703                                 metadata.tRNS_alpha.length,
1704                                 red.length, (byte)255);
1705                 }
1706             }
1707 
1708             l.add(ImageTypeSpecifier.createIndexed(red, green,
1709                                                    blue, alpha,
1710                                                    bitDepth,
1711                                                    DataBuffer.TYPE_BYTE));
1712             break;
1713 
1714         case PNG_COLOR_GRAY_ALPHA:
1715             // Component G, A
1716             gray = ColorSpace.getInstance(ColorSpace.CS_GRAY);
1717             bandOffsets = new int[2];
1718             bandOffsets[0] = 0;
1719             bandOffsets[1] = 1;
1720             l.add(ImageTypeSpecifier.createInterleaved(gray,
1721                                                        bandOffsets,
1722                                                        dataType,
1723                                                        true,
1724                                                        false));
1725             break;
1726 
1727         case PNG_COLOR_RGB_ALPHA:
1728             if (bitDepth == 8) {
1729                 // some standard types of buffered images
1730                 // wich can be used as destination
1731                 l.add(ImageTypeSpecifier.createFromBufferedImageType(
1732                           BufferedImage.TYPE_4BYTE_ABGR));
1733 
1734                 l.add(ImageTypeSpecifier.createFromBufferedImageType(
1735                           BufferedImage.TYPE_INT_ARGB));
1736             }
1737 
1738             // Component R, G, B, A (non-premultiplied)
1739             rgb = ColorSpace.getInstance(ColorSpace.CS_sRGB);
1740             bandOffsets = new int[4];
1741             bandOffsets[0] = 0;
1742             bandOffsets[1] = 1;
1743             bandOffsets[2] = 2;
1744             bandOffsets[3] = 3;
1745 
1746             l.add(ImageTypeSpecifier.createInterleaved(rgb,
1747                                                        bandOffsets,
1748                                                        dataType,
1749                                                        true,
1750                                                        false));
1751             break;
1752 
1753         default:
1754             break;
1755         }
1756 
1757         return l.iterator();
1758     }
1759 
1760     /*
1761      * Super class implementation uses first element
1762      * of image types list as raw image type.
1763      *
1764      * Also, super implementation uses first element of this list
1765      * as default destination type image read param does not specify
1766      * anything other.
1767      *
1768      * However, in case of RGB and RGBA color types, raw image type
1769      * produces buffered image of custom type. It causes some
1770      * performance degradation of subsequent rendering operations.
1771      *
1772      * To resolve this contradiction we put standard image types
1773      * at the first positions of image types list (to produce standard
1774      * images by default) and put raw image type (which is custom)
1775      * at the last position of this list.
1776      *
1777      * After this changes we should override getRawImageType()
1778      * to return last element of image types list.
1779      */
1780     public ImageTypeSpecifier getRawImageType(int imageIndex)
1781       throws IOException {
1782 
1783         Iterator<ImageTypeSpecifier> types = getImageTypes(imageIndex);
1784         ImageTypeSpecifier raw = null;
1785         do {
1786             raw = types.next();
1787         } while (types.hasNext());
1788         return raw;
1789     }
1790 
1791     public ImageReadParam getDefaultReadParam() {
1792         return new ImageReadParam();
1793     }
1794 
1795     public IIOMetadata getStreamMetadata()
1796         throws IIOException {
1797         return null;
1798     }
1799 
1800     public IIOMetadata getImageMetadata(int imageIndex) throws IIOException {
1801         if (imageIndex != 0) {
1802             throw new IndexOutOfBoundsException("imageIndex != 0!");
1803         }
1804         readMetadata();
1805         return metadata;
1806     }
1807 
1808     public BufferedImage read(int imageIndex, ImageReadParam param)
1809         throws IIOException {
1810         if (imageIndex != 0) {
1811             throw new IndexOutOfBoundsException("imageIndex != 0!");
1812         }
1813 
1814         try {
1815             readImage(param);
1816         } catch (IOException |
1817                  IllegalStateException |
1818                  IllegalArgumentException e)
1819         {
1820             throw e;
1821         } catch (Throwable e) {
1822             throw new IIOException("Caught exception during read: ", e);
1823         }
1824         return theImage;
1825     }
1826 
1827     public void reset() {
1828         super.reset();
1829         resetStreamSettings();
1830     }
1831 
1832     private void resetStreamSettings() {
1833         gotHeader = false;
1834         gotMetadata = false;
1835         metadata = null;
1836         pixelStream = null;
1837         imageStartPosition = -1L;
1838     }
1839 }
--- EOF ---