/**
* Reads color table as 256 RGB integer values
*
* @param ncolors int number of colors to read
* @return int array containing 256 colors (packed ARGB with full alpha)
*/
protected int[] readColorTable(int ncolors) {
int nbytes = 3 * ncolors;
int[] tab = null;
byte[] c = new byte[nbytes];
int n = 0;
try {
n = in.read(c);
} catch (IOException e) {
}
if (n < nbytes) {
status = STATUS_FORMAT_ERROR;
} else {
tab = new int[256]; // max size to avoid bounds checks
int i = 0;
int j = 0;
while (i < ncolors) {
int r = ((int) c[j++]) & 0xff;
int g = ((int) c[j++]) & 0xff;
int b = ((int) c[j++]) & 0xff;
tab[i++] = 0xff000000 | (r << 16) | (g << 8) | b;
}
}
return tab;
}
/** Reads a single byte from the input stream. */
protected int read() {
int curByte = 0;
try {
curByte = in.read();
} catch (IOException e) {
status = STATUS_FORMAT_ERROR;
}
return curByte;
}
/**
* Reads GIF image from stream
*
* @param BufferedInputStream containing GIF file.
* @return read status code (0 = no errors)
*/
public int read(BufferedInputStream is) {
init();
if (is != null) {
in = is;
readHeader();
if (!err()) {
readContents();
if (frameCount < 0) {
status = STATUS_FORMAT_ERROR;
}
}
} else {
status = STATUS_OPEN_ERROR;
}
try {
is.close();
} catch (IOException e) {
}
return status;
}
/**
* Reads next variable length block from input.
*
* @return number of bytes stored in "buffer"
*/
protected int readBlock() {
blockSize = read();
int n = 0;
if (blockSize > 0) {
try {
int count = 0;
while (n < blockSize) {
count = in.read(block, n, blockSize - n);
if (count == -1) break;
n += count;
}
} catch (IOException e) {
}
if (n < blockSize) {
status = STATUS_FORMAT_ERROR;
}
}
return n;
}
/**
* Loads PNG files and returns the result as an int[][]. The only PNG formats permitted are those
* with up to 256 grays (including simple black and white) or indexed colors from an up to
* 256-sized color table. Each integer value represents the gray level or the color table index
* value of the pixel. The Y dimension is not flipped.
*/
public static int[][] loadPNGFile(InputStream str) throws IOException {
// read the bytes into a byte array
BufferedInputStream stream = new BufferedInputStream(str);
ArrayList list = new ArrayList();
int count = 0;
while (true) {
byte[] buffer = new byte[16384 * 16];
int len = stream.read(buffer);
if (len <= 0) // all done
break;
else if (len < buffer.length) {
byte[] buf2 = new byte[len];
System.arraycopy(buffer, 0, buf2, 0, len);
buffer = buf2;
}
count += len;
list.add(buffer);
}
byte[] data = new byte[count];
int cur = 0;
for (int i = 0; i < list.size(); i++) {
byte[] b = (byte[]) (list.get(i));
System.arraycopy(b, 0, data, cur, b.length);
cur += b.length;
}
// Next convert the byte array to a buffered image
BufferedImage image = ((ToolkitImage) (new ImageIcon(data).getImage())).getBufferedImage();
// Is the color model something we can use?
int type = image.getType();
if (type == BufferedImage.TYPE_BYTE_BINARY || type == BufferedImage.TYPE_BYTE_GRAY) {
int w = image.getWidth();
int h = image.getHeight();
int[][] result = new int[w][h];
// obviously this could be done more efficiently
for (int i = 0; i < w; i++)
for (int j = 0; j < h; j++) result[i][j] = (image.getRGB(i, j) & 0xFF);
return result;
} else if (type == BufferedImage.TYPE_BYTE_INDEXED) {
Raster raster = image.getRaster();
if (raster.getTransferType() != DataBuffer.TYPE_BYTE) // uh oh
throw new IOException("Input Stream must contain an image with byte data if indexed.");
byte[] pixel = new byte[1];
int w = image.getWidth();
int h = image.getHeight();
int[][] result = new int[w][h];
// obviously this could be done more efficiently
for (int i = 0; i < w; i++)
for (int j = 0; j < h; j++) {
result[i][j] = ((byte[]) (raster.getDataElements(i, j, pixel)))[0];
if (result[i][j] < 0) result[i][j] += 256;
}
return result;
}
// else if (type == TYPE_USHORT_GRAY) // at present we don't handle shorts
// {
// }
else
throw new IOException(
"Input Stream must contain a binary, byte-sized grayscale, or byte-sized indexed color scheme: "
+ image);
}