| /* |
| * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.awt.image; |
| |
| import java.io.*; |
| import java.util.*; |
| import java.util.zip.*; |
| import java.awt.image.*; |
| import java.awt.Color; |
| |
| /** PNG - Portable Network Graphics - image file reader. |
| See <a href=http://www.ietf.org/rfc/rfc2083.txt>RFC2083</a> for details. */ |
| |
| /* this is changed |
| public class PNGImageDecoder extends FilterInputStream implements Runnable |
| { */ |
| |
| public class PNGImageDecoder extends ImageDecoder |
| { |
| private static final int GRAY=0; |
| private static final int PALETTE=1; |
| private static final int COLOR=2; |
| private static final int ALPHA=4; |
| |
| private static final int bKGDChunk = 0x624B4744; |
| private static final int cHRMChunk = 0x6348524D; |
| private static final int gAMAChunk = 0x67414D41; |
| private static final int hISTChunk = 0x68495354; |
| private static final int IDATChunk = 0x49444154; |
| private static final int IENDChunk = 0x49454E44; |
| private static final int IHDRChunk = 0x49484452; |
| private static final int PLTEChunk = 0x504C5445; |
| private static final int pHYsChunk = 0x70485973; |
| private static final int sBITChunk = 0x73424954; |
| private static final int tEXtChunk = 0x74455874; |
| private static final int tIMEChunk = 0x74494D45; |
| private static final int tRNSChunk = 0x74524E53; |
| private static final int zTXtChunk = 0x7A545874; |
| |
| private int width; |
| private int height; |
| private int bitDepth; |
| private int colorType; |
| private int compressionMethod; |
| private int filterMethod; |
| private int interlaceMethod; |
| private int gamma = 100000; |
| private java.util.Hashtable properties; |
| /* this is not needed |
| ImageConsumer target; |
| */ |
| private ColorModel cm; |
| private byte[] red_map, green_map, blue_map, alpha_map; |
| private int transparentPixel = -1; |
| private byte[] transparentPixel_16 = null; // we need 6 bytes to store 16bpp value |
| private static ColorModel greyModels[] = new ColorModel[4]; |
| /* this is not needed |
| PNGImageDecoder next; |
| */ |
| |
| private void property(String key,Object value) { |
| if(value==null) return; |
| if(properties==null) properties=new java.util.Hashtable(); |
| properties.put(key,value); |
| } |
| private void property(String key,float value) { |
| property(key,new Float(value)); |
| } |
| private final void pngassert(boolean b) throws IOException { |
| if(!b) { |
| PNGException e = new PNGException("Broken file"); |
| e.printStackTrace(); |
| throw e; |
| } |
| } |
| protected boolean handleChunk(int key, byte[] buf, int st, int len) |
| throws IOException { |
| switch(key) { |
| case bKGDChunk: |
| Color c = null; |
| switch(colorType) { |
| case COLOR: |
| case COLOR|ALPHA: |
| pngassert(len==6); |
| c = new Color(buf[st]&0xff,buf[st+2]&0xff,buf[st+4]&0xff); |
| break; |
| case COLOR|PALETTE: |
| case COLOR|PALETTE|ALPHA: |
| pngassert(len==1); |
| int ix = buf[st]&0xFF; |
| pngassert(red_map!=null && ix<red_map.length); |
| c = new Color(red_map[ix]&0xff,green_map[ix]&0xff,blue_map[ix]&0xff); |
| break; |
| case GRAY: |
| case GRAY|ALPHA: |
| pngassert(len==2); |
| int t = buf[st]&0xFF; |
| c = new Color(t,t,t); |
| break; |
| } |
| if(c!=null) property("background",c); |
| break; |
| case cHRMChunk: |
| property("chromaticities", |
| new Chromaticities( |
| getInt(st), |
| getInt(st+4), |
| getInt(st+8), |
| getInt(st+12), |
| getInt(st+16), |
| getInt(st+20), |
| getInt(st+24), |
| getInt(st+28))); |
| break; |
| case gAMAChunk: |
| if(len!=4) throw new PNGException("bogus gAMA"); |
| gamma = getInt(st); |
| if(gamma!=100000) property("gamma",gamma/100000.0f); |
| break; |
| case hISTChunk: break; |
| case IDATChunk: return false; |
| case IENDChunk: break; |
| case IHDRChunk: |
| if(len!=13 |
| ||(width = getInt(st))==0 |
| ||(height = getInt(st+4))==0 |
| ) throw new PNGException("bogus IHDR"); |
| bitDepth = getByte(st+8); |
| colorType = getByte(st+9); |
| compressionMethod = getByte(st+10); |
| filterMethod = getByte(st+11); |
| interlaceMethod = getByte(st+12); |
| /* this is not needed |
| if(target!=null) target.setDimensions(width,height); |
| */ |
| break; |
| case PLTEChunk: |
| { int tsize = len/3; |
| red_map = new byte[tsize]; |
| green_map = new byte[tsize]; |
| blue_map = new byte[tsize]; |
| for(int i=0,j=st; i<tsize; i++, j+=3) { |
| red_map[i] = buf[j]; |
| green_map[i] = buf[j+1]; |
| blue_map[i] = buf[j+2]; |
| } |
| } |
| break; |
| case pHYsChunk: break; |
| case sBITChunk: break; |
| case tEXtChunk: |
| int klen = 0; |
| while(klen<len && buf[st+klen]!=0) klen++; |
| if(klen<len) { |
| String tkey = new String(buf,st,klen); |
| String tvalue = new String(buf,st+klen+1,len-klen-1); |
| property(tkey,tvalue); |
| } |
| break; |
| case tIMEChunk: |
| property("modtime",new GregorianCalendar( |
| getShort(st+0), |
| getByte(st+2)-1, |
| getByte(st+3), |
| getByte(st+4), |
| getByte(st+5), |
| getByte(st+6)).getTime()); |
| break; |
| case tRNSChunk: |
| switch(colorType) { |
| case PALETTE|COLOR: |
| case PALETTE|COLOR|ALPHA: |
| int alen = len; |
| if(red_map!=null) alen = red_map.length; |
| alpha_map = new byte[alen]; |
| System.arraycopy(buf,st,alpha_map,0,len<alen ? len : alen); |
| while (--alen>=len) alpha_map[alen] = (byte)0xFF; |
| break; |
| case COLOR: // doesn't deal with 16 bit colors properly |
| case COLOR|ALPHA: // doesn't deal with 16 bit colors properly |
| pngassert(len==6); |
| if (bitDepth == 16) { |
| transparentPixel_16 = new byte[6]; |
| for (int i = 0; i < 6; i++) { |
| transparentPixel_16[i] = (byte)getByte(st + i); |
| } |
| } else { |
| transparentPixel = |
| ((getShort(st + 0)&0xFF)<<16) |
| | ((getShort(st + 2)&0xFF)<< 8) |
| | ((getShort(st + 4)&0xFF) ); |
| } |
| break; |
| case GRAY: // doesn't deal with 16 bit colors properly |
| case GRAY|ALPHA: // doesn't deal with 16 bit colors properly |
| pngassert(len==2); |
| /* REMIND: Discarding the LSB for 16 bit depth here |
| * means that the all pixels which match the MSB |
| * will be treated as transparent. |
| */ |
| int t = getShort(st); |
| t = 0xFF & ((bitDepth == 16) ? (t >> 8) : t); |
| transparentPixel = (t<<16) | (t<< 8) | t; |
| break; |
| } |
| break; |
| case zTXtChunk: break; |
| } |
| return true; |
| } |
| public class PNGException extends IOException { |
| PNGException(String s) { super(s); } |
| } |
| /* this is changed |
| public void run() { |
| */ |
| public void produceImage() throws IOException, ImageFormatException { |
| /* this is not needed |
| ImageConsumer t = target; |
| if(t!=null) try { |
| */ |
| try { |
| for(int i=0; i<signature.length; i++) |
| if((signature[i]&0xFF)!=underlyingInputStream.read()) |
| throw new PNGException("Chunk signature mismatch"); |
| |
| InputStream is = new BufferedInputStream(new InflaterInputStream(inputStream,new Inflater())); |
| |
| getData(); |
| |
| byte[] bPixels = null; |
| int[] wPixels = null; |
| int pixSize = width; |
| int rowStride; |
| int logDepth = 0; |
| switch(bitDepth) { |
| case 1: logDepth = 0; break; |
| case 2: logDepth = 1; break; |
| case 4: logDepth = 2; break; |
| case 8: logDepth = 3; break; |
| case 16: logDepth = 4; break; |
| default: throw new PNGException("invalid depth"); |
| } |
| if(interlaceMethod!=0) {pixSize *= height;rowStride=width;} |
| else rowStride = 0; |
| int combinedType = colorType|(bitDepth<<3); |
| int bitMask = (1<<(bitDepth>=8?8:bitDepth))-1; |
| //Figure out the color model |
| switch(colorType) { |
| case COLOR|PALETTE: |
| case COLOR|PALETTE|ALPHA: |
| if(red_map==null) throw new PNGException("palette expected"); |
| if(alpha_map==null) |
| cm = new IndexColorModel(bitDepth,red_map.length, |
| red_map,green_map,blue_map); |
| else |
| cm = new IndexColorModel(bitDepth,red_map.length, |
| red_map,green_map,blue_map,alpha_map); |
| bPixels = new byte[pixSize]; |
| break; |
| case GRAY: |
| { int llog = logDepth>=4 ? 3 : logDepth; |
| if((cm=greyModels[llog]) == null) { |
| int size = 1<<(1<<llog); |
| |
| byte ramp[] = new byte[size]; |
| for(int i = 0; i<size; i++) ramp[i] = (byte)(255*i/(size-1)); |
| |
| if (transparentPixel == -1) { |
| cm = new IndexColorModel(bitDepth,ramp.length,ramp,ramp,ramp); |
| } else { |
| cm = new IndexColorModel(bitDepth,ramp.length,ramp,ramp,ramp, |
| (transparentPixel & 0xFF)); |
| } |
| greyModels[llog] = cm; |
| } |
| } |
| bPixels = new byte[pixSize]; |
| break; |
| case COLOR: |
| case COLOR|ALPHA: |
| case GRAY|ALPHA: |
| cm = ColorModel.getRGBdefault(); |
| wPixels = new int[pixSize]; |
| break; |
| default: |
| throw new PNGException("invalid color type"); |
| } |
| /* this is going to be set in the pixel store |
| t.setColorModel(cm); |
| t.setHints(interlaceMethod !=0 |
| ? ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES |
| : ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES | |
| ImageConsumer.SINGLEPASS | ImageConsumer.SINGLEFRAME); |
| */ |
| // code added to make it work with ImageDecoder architecture |
| setDimensions(width, height); |
| setColorModel(cm); |
| int flags = (interlaceMethod !=0 |
| ? ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES |
| : ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES | |
| ImageConsumer.SINGLEPASS | ImageConsumer.SINGLEFRAME); |
| setHints(flags); |
| headerComplete(); |
| // end of adding |
| |
| int samplesPerPixel = ((colorType&PALETTE)!=0 ? 1 |
| : ((colorType&COLOR)!=0 ? 3 : 1)+((colorType&ALPHA)!=0?1:0)); |
| int bitsPerPixel = samplesPerPixel*bitDepth; |
| int bytesPerPixel = (bitsPerPixel+7)>>3; |
| int pass, passLimit; |
| if(interlaceMethod==0) { pass = -1; passLimit = 0; } |
| else { pass = 0; passLimit = 7; } |
| // These loops are far from being tuned. They're this way to make them easy to |
| // debug. Tuning comes later. |
| /* code changed. target not needed here |
| while(++pass<=passLimit && (t=target)!=null) { |
| */ |
| while(++pass<=passLimit) { |
| int row = startingRow[pass]; |
| int rowInc = rowIncrement[pass]; |
| int colInc = colIncrement[pass]; |
| int bWidth = blockWidth[pass]; |
| int bHeight = blockHeight[pass]; |
| int sCol = startingCol[pass]; |
| int rowPixelWidth = (width-sCol+(colInc-1))/colInc; |
| int rowByteWidth = ((rowPixelWidth*bitsPerPixel)+7)>>3; |
| if(rowByteWidth==0) continue; |
| int pixelBufferInc = interlaceMethod==0 ? rowInc*width : 0; |
| int rowOffset = rowStride*row; |
| boolean firstRow = true; |
| |
| byte[] rowByteBuffer = new byte[rowByteWidth]; |
| byte[] prevRowByteBuffer = new byte[rowByteWidth]; |
| /* code changed. target not needed here |
| while (row < height && (t=target)!=null) { |
| */ |
| while (row < height) { |
| int rowFilter = is.read(); |
| for (int rowFillPos=0;rowFillPos<rowByteWidth; ) { |
| int n = is.read(rowByteBuffer,rowFillPos,rowByteWidth-rowFillPos); |
| if(n<=0) throw new PNGException("missing data"); |
| rowFillPos+=n; |
| } |
| filterRow(rowByteBuffer, |
| firstRow ? null : prevRowByteBuffer, |
| rowFilter, rowByteWidth, bytesPerPixel); |
| int col = sCol; |
| int spos=0; |
| int pixel = 0; |
| while (col < width) { |
| if(wPixels !=null) { |
| switch(combinedType) { |
| case COLOR|ALPHA|(8<<3): |
| wPixels[col+rowOffset] = |
| ((rowByteBuffer[spos ]&0xFF)<<16) |
| | ((rowByteBuffer[spos+1]&0xFF)<< 8) |
| | ((rowByteBuffer[spos+2]&0xFF) ) |
| | ((rowByteBuffer[spos+3]&0xFF)<<24); |
| spos+=4; |
| break; |
| case COLOR|ALPHA|(16<<3): |
| wPixels[col+rowOffset] = |
| ((rowByteBuffer[spos ]&0xFF)<<16) |
| | ((rowByteBuffer[spos+2]&0xFF)<< 8) |
| | ((rowByteBuffer[spos+4]&0xFF) ) |
| | ((rowByteBuffer[spos+6]&0xFF)<<24); |
| spos+=8; |
| break; |
| case COLOR|(8<<3): |
| pixel = |
| ((rowByteBuffer[spos ]&0xFF)<<16) |
| | ((rowByteBuffer[spos+1]&0xFF)<< 8) |
| | ((rowByteBuffer[spos+2]&0xFF) ); |
| if (pixel != transparentPixel) { |
| pixel |= 0xff000000; |
| } |
| wPixels[col+rowOffset] = pixel; |
| spos+=3; |
| break; |
| case COLOR|(16<<3): |
| pixel = |
| ((rowByteBuffer[spos ]&0xFF)<<16) |
| | ((rowByteBuffer[spos+2]&0xFF)<< 8) |
| | ((rowByteBuffer[spos+4]&0xFF) ); |
| |
| boolean isTransparent = (transparentPixel_16 != null); |
| for (int i = 0; isTransparent && (i < 6); i++) { |
| isTransparent &= |
| (rowByteBuffer[spos + i] & 0xFF) == (transparentPixel_16[i] & 0xFF); |
| } |
| if (!isTransparent) { |
| pixel |= 0xff000000; |
| } |
| wPixels[col+rowOffset] = pixel; |
| spos+=6; |
| break; |
| case GRAY|ALPHA|(8<<3): |
| { int tx = rowByteBuffer[spos]&0xFF; |
| wPixels[col+rowOffset] = |
| (tx<<16)|(tx<<8)|tx |
| |((rowByteBuffer[spos+1]&0xFF)<<24); } |
| spos+=2; |
| break; |
| case GRAY|ALPHA|(16<<3): |
| { int tx = rowByteBuffer[spos]&0xFF; |
| wPixels[col+rowOffset] = |
| (tx<<16)|(tx<<8)|tx |
| |((rowByteBuffer[spos+2]&0xFF)<<24); } |
| spos+=4; |
| break; |
| default: throw new PNGException("illegal type/depth"); |
| } |
| } else switch(bitDepth) { |
| case 1: |
| bPixels[col+rowOffset] = |
| (byte)((rowByteBuffer[spos>>3]>>(7-(spos&7)))&1); |
| spos++; |
| break; |
| case 2: |
| bPixels[col+rowOffset] = |
| (byte)((rowByteBuffer[spos>>2]>>((3-(spos&3))*2))&3); |
| spos++; |
| break; |
| case 4: |
| bPixels[col+rowOffset] = |
| (byte)((rowByteBuffer[spos>>1]>>((1-(spos&1))*4))&15); |
| spos++; |
| break; |
| case 8: bPixels[col+rowOffset] = rowByteBuffer[spos++]; |
| break; |
| case 16: bPixels[col+rowOffset] = rowByteBuffer[spos]; spos+=2; |
| break; |
| default: throw new PNGException("illegal type/depth"); |
| } |
| /*visit (row, col, |
| min (bHeight, height - row), |
| min (bWidth, width - col)); */ |
| col += colInc; |
| } |
| if(interlaceMethod==0) |
| if(wPixels!=null) { |
| /* code changed. target not needed here |
| t.setPixels(0,row,width,1,cm,wPixels,0,width); |
| */ |
| // code added to make it work with ImageDecoder arch |
| sendPixels(0,row,width,1,wPixels,0,width); |
| // end of adding |
| } |
| else { |
| /* code changed. target not needed here |
| t.setPixels(0,row,width,1,cm,bPixels,0,width); |
| */ |
| // code added to make it work with ImageDecoder arch |
| sendPixels(0,row,width,1,bPixels,0,width); |
| //end of adding |
| } |
| row += rowInc; |
| rowOffset += rowInc*rowStride; |
| byte[] T = rowByteBuffer; |
| rowByteBuffer = prevRowByteBuffer; |
| prevRowByteBuffer = T; |
| firstRow = false; |
| } |
| if(interlaceMethod!=0) |
| if(wPixels!=null) { |
| /* code changed. target not needed here |
| t.setPixels(0,0,width,height,cm,wPixels,0,width); |
| */ |
| // code added to make it work with ImageDecoder arch |
| sendPixels(0,0,width,height,wPixels,0,width); |
| //end of adding |
| } |
| else { |
| /* code changed. target not needed here |
| t.setPixels(0,0,width,height,cm,bPixels,0,width); |
| */ |
| // code added to make it work with ImageDecoder arch |
| sendPixels(0,0,width,height,bPixels,0,width); |
| //end of adding |
| } |
| } |
| |
| /* Here, the function "visit(row,column,height,width)" obtains the |
| next transmitted pixel and paints a rectangle of the specified |
| height and width, whose upper-left corner is at the specified row |
| and column, using the color indicated by the pixel. Note that row |
| and column are measured from 0,0 at the upper left corner. */ |
| |
| /* code not needed, don't deal with target |
| if((t=target)!=null) { |
| if(properties!=null) t.setProperties(properties); |
| t.imageComplete(ImageConsumer.STATICIMAGEDONE); |
| */ |
| |
| imageComplete(ImageConsumer.STATICIMAGEDONE, true); |
| |
| /* code not needed } |
| is.close(); |
| */ |
| } catch(IOException e) { |
| if(!aborted) { |
| /* code not needed |
| if((t=target)!=null) { |
| PNGEncoder.prChunk(e.toString(),inbuf,pos,limit-pos,true); |
| */ |
| property("error", e); |
| /* code not needed |
| t.setProperties(properties); |
| t.imageComplete(ImageConsumer.IMAGEERROR|ImageConsumer.STATICIMAGEDONE); |
| */ |
| imageComplete(ImageConsumer.IMAGEERROR|ImageConsumer.STATICIMAGEDONE, true); |
| throw e; |
| } |
| } finally { |
| try { close(); } catch(Throwable e){} |
| /* code not needed |
| target = null; |
| endTurn(); |
| */ |
| } |
| } |
| |
| private boolean sendPixels(int x, int y, int w, int h, int[] pixels, |
| int offset, int pixlength) { |
| int count = setPixels(x, y, w, h, cm, |
| pixels, offset, pixlength); |
| if (count <= 0) { |
| aborted = true; |
| } |
| return !aborted; |
| } |
| private boolean sendPixels(int x, int y, int w, int h, byte[] pixels, |
| int offset, int pixlength) { |
| int count = setPixels(x, y, w, h, cm, |
| pixels, offset, pixlength); |
| if (count <= 0) { |
| aborted = true; |
| } |
| return !aborted; |
| } |
| |
| private void filterRow(byte rowByteBuffer[], byte[] prevRow, |
| int rowFilter, int rowByteWidth, int bytesPerSample) |
| throws IOException { |
| int x = 0; |
| switch (rowFilter) { |
| case 0: |
| break; |
| case 1: |
| for (x = bytesPerSample; x < rowByteWidth; x++) |
| rowByteBuffer[x] += rowByteBuffer[x - bytesPerSample]; |
| break; |
| case 2: |
| if (prevRow != null) |
| for ( ; x < rowByteWidth; x++) |
| rowByteBuffer[x] += prevRow[x]; |
| break; |
| case 3: |
| if (prevRow != null) { |
| for ( ; x < bytesPerSample; x++) |
| rowByteBuffer[x] += (0xff & prevRow[x])>>1; |
| for ( ; x < rowByteWidth; x++) |
| rowByteBuffer[x] += ((prevRow[x]&0xFF) + (rowByteBuffer[x - bytesPerSample]&0xFF))>>1; |
| } else |
| for (x = bytesPerSample; x < rowByteWidth; x++) |
| rowByteBuffer[x] += (rowByteBuffer[x - bytesPerSample]&0xFF)>>1; |
| break; |
| case 4: |
| if (prevRow != null) { |
| for ( ; x < bytesPerSample; x++) |
| rowByteBuffer[x] += prevRow[x]; |
| for ( ; x < rowByteWidth; x++) { |
| int a, b, c, p, pa, pb, pc, rval; |
| a = rowByteBuffer[x - bytesPerSample]&0xFF; |
| b = prevRow[x]&0xFF; |
| c = prevRow[x - bytesPerSample]&0xFF; |
| p = a + b - c; |
| pa = p > a ? p - a : a - p; |
| pb = p > b ? p - b : b - p; |
| pc = p > c ? p - c : c - p; |
| rowByteBuffer[x] += (pa <= pb) && (pa <= pc) ? a : pb <= pc ? b : c; |
| } |
| } else |
| for (x = bytesPerSample; x < rowByteWidth; x++) |
| rowByteBuffer[x] += rowByteBuffer[x - bytesPerSample]; |
| break; |
| default: |
| throw new PNGException("Illegal filter"); |
| } |
| } |
| private static final byte[] startingRow = { 0, 0, 0, 4, 0, 2, 0, 1 }; |
| private static final byte[] startingCol = { 0, 0, 4, 0, 2, 0, 1, 0 }; |
| private static final byte[] rowIncrement = { 1, 8, 8, 8, 4, 4, 2, 2 }; |
| private static final byte[] colIncrement = { 1, 8, 8, 4, 4, 2, 2, 1 }; |
| private static final byte[] blockHeight = { 1, 8, 8, 4, 4, 2, 2, 1 }; |
| private static final byte[] blockWidth = { 1, 8, 4, 4, 2, 2, 1, 1 }; |
| |
| //abstract public class ChunkReader extends FilterInputStream { |
| int pos, limit; |
| int chunkStart; |
| int chunkKey, chunkLength, chunkCRC; |
| boolean seenEOF; |
| |
| private static final byte[] signature = { (byte) 137, (byte) 80, (byte) 78, |
| (byte) 71, (byte) 13, (byte) 10, (byte) 26, (byte) 10 }; |
| |
| PNGFilterInputStream inputStream; |
| InputStream underlyingInputStream; |
| |
| /* code changed |
| public PNGImageDecoder(InputStream in, ImageConsumer t) throws IOException { |
| */ |
| public PNGImageDecoder(InputStreamImageSource src, InputStream input) throws IOException { |
| // code added |
| super(src, input); |
| inputStream = new PNGFilterInputStream(this, input); |
| underlyingInputStream = inputStream.underlyingInputStream; |
| // end of adding |
| /* code changed |
| super(in); |
| target = t; |
| waitTurn(); |
| new Thread(this).start(); |
| */ |
| } |
| /* code changed to make it work with ImageDecoder architecture |
| static int ThreadLimit = 10; |
| private synchronized static void waitTurn() { |
| try { |
| while(ThreadLimit<=0) PNGImageDecoder.class.wait(1000); |
| } catch(InterruptedException e){} |
| ThreadLimit--; |
| } |
| private synchronized static void endTurn() { |
| if(ThreadLimit<=0) PNGImageDecoder.class.notify(); |
| ThreadLimit++; |
| } |
| */ |
| byte[] inbuf = new byte[4096]; |
| private void fill() throws IOException { |
| if(!seenEOF) { |
| if(pos>0 && pos<limit) { |
| System.arraycopy(inbuf,pos,inbuf,0,limit-pos); |
| limit = limit-pos; |
| pos = 0; |
| } else if(pos>=limit) { |
| pos = 0; limit = 0; |
| } |
| int bsize = inbuf.length; |
| while(limit<bsize) { |
| int n = underlyingInputStream.read(inbuf,limit,bsize-limit); |
| if(n<=0) { seenEOF=true; break; } |
| limit += n; |
| } |
| } |
| } |
| private boolean need(int n) throws IOException { |
| if(limit-pos>=n) return true; |
| fill(); |
| if(limit-pos>=n) return true; |
| if(seenEOF) return false; |
| byte nin[] = new byte[n+100]; |
| System.arraycopy(inbuf,pos,nin,0,limit-pos); |
| limit = limit-pos; |
| pos = 0; |
| inbuf = nin; |
| fill(); |
| return limit-pos>=n; |
| } |
| private final int getInt(int pos) { |
| return ((inbuf[pos ]&0xFF)<<24) |
| | ((inbuf[pos+1]&0xFF)<<16) |
| | ((inbuf[pos+2]&0xFF)<< 8) |
| | ((inbuf[pos+3]&0xFF) ); |
| } |
| private final int getShort(int pos) { |
| return (short)(((inbuf[pos ]&0xFF)<<8) |
| | ((inbuf[pos+1]&0xFF) )); |
| } |
| private final int getByte(int pos) { |
| return inbuf[pos]&0xFF; |
| } |
| private final boolean getChunk() throws IOException { |
| chunkLength = 0; |
| if (!need(8)) return false; |
| chunkLength = getInt(pos); |
| chunkKey = getInt(pos+4); |
| if(chunkLength<0) throw new PNGException("bogus length: "+chunkLength); |
| if (!need(chunkLength+12)) return false; |
| chunkCRC = getInt(pos+8+chunkLength); |
| chunkStart = pos+8; |
| int calcCRC = crc(inbuf,pos+4,chunkLength+4); |
| if(chunkCRC!=calcCRC && checkCRC) throw new PNGException("crc corruption"); |
| pos+=chunkLength+12; |
| return true; |
| } |
| private void readAll() throws IOException { |
| while(getChunk()) handleChunk(chunkKey,inbuf,chunkStart,chunkLength); |
| } |
| boolean getData() throws IOException { |
| while(chunkLength==0 && getChunk()) |
| if(handleChunk(chunkKey,inbuf,chunkStart,chunkLength)) |
| chunkLength = 0; |
| return chunkLength>0; |
| } |
| //abstract protected boolean handleChunk(int key, byte[] buf, int st, int len) |
| // throws IOException; |
| private static boolean checkCRC = true; |
| public static boolean getCheckCRC() { return checkCRC; } |
| public static void setCheckCRC(boolean c) { checkCRC = c; } |
| |
| protected void wrc(int c) { |
| c = c&0xFF; |
| if(c<=' '||c>'z') c = '?'; |
| System.out.write(c); |
| } |
| protected void wrk(int n) { |
| wrc(n>>24); |
| wrc(n>>16); |
| wrc(n>>8); |
| wrc(n); |
| } |
| public void print() { |
| wrk(chunkKey); |
| System.out.print(" "+chunkLength+"\n"); |
| } |
| |
| /* Table of CRCs of all 8-bit messages. */ |
| private static final int[] crc_table = new int[256]; |
| |
| /* Make the table for a fast CRC. */ |
| static { |
| for (int n = 0; n < 256; n++) { |
| int c = n; |
| for (int k = 0; k < 8; k++) |
| if ((c & 1) != 0) |
| c = 0xedb88320 ^ (c >>> 1); |
| else |
| c = c >>> 1; |
| crc_table[n] = c; |
| } |
| } |
| |
| /* Update a running CRC with the bytes buf[0..len-1]--the CRC |
| should be initialized to all 1's, and the transmitted value |
| is the 1's complement of the final running CRC (see the |
| crc() routine below)). */ |
| |
| static private int update_crc(int crc, byte[] buf, int offset, int len) { |
| int c = crc; |
| while (--len>=0) |
| c = crc_table[(c ^ buf[offset++]) & 0xff] ^ (c >>> 8); |
| return c; |
| } |
| |
| /* Return the CRC of the bytes buf[0..len-1]. */ |
| static private int crc(byte[] buf, int offset, int len) { |
| return update_crc(0xffffffff, buf, offset, len) ^ 0xffffffff; |
| } |
| public static class Chromaticities { |
| public float whiteX, whiteY, redX, redY, greenX, greenY, blueX, blueY; |
| Chromaticities(int wx, int wy, int rx, int ry, int gx, int gy, int bx, int by) { |
| whiteX = wx/100000.0f; |
| whiteY = wy/100000.0f; |
| redX = rx/100000.0f; |
| redY = ry/100000.0f; |
| greenX = gx/100000.0f; |
| greenY = gy/100000.0f; |
| blueX = bx/100000.0f; |
| blueY = by/100000.0f; |
| } |
| public String toString() { |
| return "Chromaticities(white="+whiteX+","+whiteY+";red="+ |
| redX+","+redY+";green="+ |
| greenX+","+greenY+";blue="+ |
| blueX+","+blueY+")"; |
| } |
| } |
| } |
| |
| // the following class are added to make it work with ImageDecoder architecture |
| |
| class PNGFilterInputStream extends FilterInputStream { |
| PNGImageDecoder owner; |
| public InputStream underlyingInputStream; |
| public PNGFilterInputStream(PNGImageDecoder owner, InputStream is) { |
| super(is); |
| underlyingInputStream = in; |
| this.owner = owner; |
| } |
| |
| public int available() throws IOException { |
| return owner.limit-owner.pos+in.available();} |
| public boolean markSupported() { return false; } |
| public int read() throws IOException { |
| if(owner.chunkLength<=0) if(!owner.getData()) return -1; |
| owner.chunkLength--; |
| return owner.inbuf[owner.chunkStart++]&0xFF; |
| } |
| public int read(byte[] b) throws IOException{return read(b,0,b.length);} |
| public int read(byte[] b, int st, int len) throws IOException { |
| if(owner.chunkLength<=0) if(!owner.getData()) return -1; |
| if(owner.chunkLength<len) len = owner.chunkLength; |
| System.arraycopy(owner.inbuf,owner.chunkStart,b,st,len); |
| owner.chunkLength-=len; |
| owner.chunkStart+=len; |
| return len; |
| } |
| public long skip(long n) throws IOException { |
| int i; |
| for(i = 0; i<n && read()>=0; i++); |
| return i; |
| } |
| |
| |
| } |
