mirror of
https://github.com/openjdk/jdk.git
synced 2026-02-19 14:55:17 +00:00
842 lines
35 KiB
Java
842 lines
35 KiB
Java
/*
|
|
* Copyright (c) 1999, 2017, 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<String, Object> 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, Float.valueOf(value));
|
|
}
|
|
private 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;
|
|
}
|
|
@SuppressWarnings("serial") // JDK-implementation class
|
|
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 static synchronized void waitTurn() {
|
|
try {
|
|
while(ThreadLimit<=0) PNGImageDecoder.class.wait(1000);
|
|
} catch(InterruptedException e){}
|
|
ThreadLimit--;
|
|
}
|
|
private static synchronized 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 int getInt(int pos) {
|
|
return ((inbuf[pos ]&0xFF)<<24)
|
|
| ((inbuf[pos+1]&0xFF)<<16)
|
|
| ((inbuf[pos+2]&0xFF)<< 8)
|
|
| ((inbuf[pos+3]&0xFF) );
|
|
}
|
|
private int getShort(int pos) {
|
|
return (short)(((inbuf[pos ]&0xFF)<<8)
|
|
| ((inbuf[pos+1]&0xFF) ));
|
|
}
|
|
private int getByte(int pos) {
|
|
return inbuf[pos]&0xFF;
|
|
}
|
|
private 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)). */
|
|
|
|
private static 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]. */
|
|
private static 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;
|
|
}
|
|
|
|
|
|
}
|