|
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
/**
* Class PSDReader - Decodes a PhotoShop (.psd) file into one or more frames.
* Supports uncompressed or RLE-compressed RGB files only. Each layer may be
* retrieved as a full frame BufferedImage, or as a smaller image with an offset
* if the layer does not occupy the full frame size. Transparency in the
* original psd file is preserved in the returned BufferedImage's. Does not
* support additional features in PS versions higher than 3.0. Example: <br>
*
* <pre>
* PSDReader r = new PSDReader();
* r.read("sample.psd");
* int n = r.getFrameCount();
* for (int i = 0; i < n; i++) {
* BufferedImage image = r.getLayer(i);
* Point offset = r.getLayerOffset(i);
* // do something with image
* }
* </pre>
*
* No copyright asserted on the source code of this class. May be used for any
* purpose. Please forward any corrections to kweiner@fmsware.com.
*
* @author Kevin Weiner, FM Software.
* @version 1.1 January 2004 [bug fix; add RLE support]
*
*/
public class PSDReader {
/**
* File read status: No errors.
*/
public static final int STATUS_OK = 0;
/**
* File read status: Error decoding file (may be partially decoded)
*/
public static final int STATUS_FORMAT_ERROR = 1;
/**
* File read status: Unable to open source.
*/
public static final int STATUS_OPEN_ERROR = 2;
/**
* File read status: Unsupported format
*/
public static final int STATUS_UNSUPPORTED = 3;
public static int ImageType = BufferedImage.TYPE_INT_ARGB;
protected BufferedInputStream input;
protected int frameCount;
protected BufferedImage[] frames;
protected int status = 0;
protected int nChan;
protected int width;
protected int height;
protected int nLayers;
protected int miscLen;
protected boolean hasLayers;
protected LayerInfo[] layers;
protected short[] lineLengths;
protected int lineIndex;
protected boolean rleEncoded;
protected class LayerInfo {
int x, y, w, h;
int nChan;
int[] chanID;
int alpha;
}
/**
* Gets the number of layers read from file.
*
* @return frame count
*/
public int getFrameCount() {
return frameCount;
}
protected void setInput(InputStream stream) {
// open input stream
init();
if (stream == null) {
status = STATUS_OPEN_ERROR;
} else {
if (stream instanceof BufferedInputStream)
input = (BufferedInputStream) stream;
else
input = new BufferedInputStream(stream);
}
}
protected void setInput(String name) {
// open input file
init();
try {
name = name.trim();
if (name.startsWith("file:")) {
name = name.substring(5);
while (name.startsWith("/"))
name = name.substring(1);
}
if (name.indexOf("://") > 0) {
URL url = new URL(name);
input = new BufferedInputStream(url.openStream());
} else {
input = new BufferedInputStream(new FileInputStream(name));
}
} catch (IOException e) {
status = STATUS_OPEN_ERROR;
}
}
/**
* Gets display duration for specified frame. Always returns 0.
*
*/
public int getDelay(int forFrame) {
return 0;
}
/**
* Gets the image contents of frame n. Note that this expands the image to the
* full frame size (if the layer was smaller) and any subsequent use of
* getLayer() will return the full image.
*
* @return BufferedImage representation of frame, or null if n is invalid.
*/
public BufferedImage getFrame(int n) {
BufferedImage im = null;
if ((n >= 0) && (n < nLayers)) {
im = frames[n];
LayerInfo info = layers[n];
if ((info.w != width) || (info.h != height)) {
BufferedImage temp = new BufferedImage(width, height, ImageType);
Graphics2D gc = temp.createGraphics();
gc.drawImage(im, info.x, info.y, null);
gc.dispose();
im = temp;
frames[n] = im;
}
}
return im;
}
/**
* Gets maximum image size. Individual layers may be smaller.
*
* @return maximum image dimensions
*/
public Dimension getFrameSize() {
return new Dimension(width, height);
}
/**
* Gets the first (or only) image read.
*
* @return BufferedImage containing first frame, or null if none.
*/
public BufferedImage getImage() {
return getFrame(0);
}
/**
* Gets the image contents of layer n. May be smaller than full frame size -
* use getFrameOffset() to obtain position of subimage within main image area.
*
* @return BufferedImage representation of layer, or null if n is invalid.
*/
public BufferedImage getLayer(int n) {
BufferedImage im = null;
if ((n >= 0) && (n < nLayers)) {
im = frames[n];
}
return im;
}
/**
* Gets the subimage offset of layer n if it is smaller than the full frame
* size.
*
* @return Point indicating offset from upper left corner of frame.
*/
public Point getLayerOffset(int n) {
Point p = null;
if ((n >= 0) && (n < nLayers)) {
int x = layers[n].x;
int y = layers[n].y;
p = new Point(x, y);
}
if (p == null) {
p = new Point(0, 0);
}
return p;
}
/**
* Reads PhotoShop layers from stream.
*
* @param InputStream
* in PhotoShop format.
* @return read status code (0 = no errors)
*/
public int read(InputStream stream) {
setInput(stream);
process();
return status;
}
/**
* Reads PhotoShop file from specified source (file or URL string)
*
* @param name
* String containing source
* @return read status code (0 = no errors)
*/
public int read(String name) {
setInput(name);
process();
return status;
}
/**
* Closes input stream and discards contents of all frames.
*
*/
public void reset() {
init();
}
protected void close() {
if (input != null) {
try {
input.close();
} catch (Exception e) {
}
input = null;
}
}
protected boolean err() {
return status != STATUS_OK;
}
protected byte[] fillBytes(int size, int value) {
// create byte array filled with given value
byte[] b = new byte[size];
if (value != 0) {
byte v = (byte) value;
for (int i = 0; i < size; i++) {
b[i] = v;
}
}
return b;
}
protected void init() {
close();
frameCount = 0;
frames = null;
layers = null;
hasLayers = true;
status = STATUS_OK;
}
protected void makeDummyLayer() {
// creat dummy layer for non-layered image
rleEncoded = readShort() == 1;
hasLayers = false;
nLayers = 1;
layers = new LayerInfo[1];
LayerInfo layer = new LayerInfo();
layers[0] = layer;
layer.h = height;
layer.w = width;
int nc = Math.min(nChan, 4);
if (rleEncoded) {
// get list of rle encoded line lengths for all channels
readLineLengths(height * nc);
}
layer.nChan = nc;
layer.chanID = new int[nc];
for (int i = 0; i < nc; i++) {
int id = i;
if (i == 3)
id = -1;
layer.chanID[i] = id;
}
}
protected void readLineLengths(int nLines) {
// read list of rle encoded line lengths
lineLengths = new short[nLines];
for (int i = 0; i < nLines; i++) {
lineLengths[i] = readShort();
}
lineIndex = 0;
}
protected BufferedImage makeImage(int w, int h, byte[] r, byte[] g, byte[] b, byte[] a) {
// create image from given plane data
BufferedImage im = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
int[] data = ((DataBufferInt) im.getRaster().getDataBuffer()).getData();
int n = w * h;
int j = 0;
while (j < n) {
try {
int ac = a[j] & 0xff;
int rc = r[j] & 0xff;
int gc = g[j] & 0xff;
int bc = b[j] & 0xff;
data[j] = (((((ac << 8) | rc) << 8) | gc) << 8) | bc;
} catch (Exception e) {
}
j++;
}
return im;
}
protected void process() {
// decode PSD file
if (err())
return;
readHeader();
if (err())
return;
readLayerInfo();
if (err())
return;
if (nLayers == 0) {
makeDummyLayer();
if (err())
return;
}
readLayers();
}
protected int readByte() {
// read single byte from input
int curByte = 0;
try {
curByte = input.read();
} catch (IOException e) {
status = STATUS_FORMAT_ERROR;
}
return curByte;
}
protected int readBytes(byte[] bytes, int n) {
// read multiple bytes from input
if (bytes == null)
return 0;
int r = 0;
try {
r = input.read(bytes, 0, n);
} catch (IOException e) {
status = STATUS_FORMAT_ERROR;
}
if (r < n) {
status = STATUS_FORMAT_ERROR;
}
return r;
}
protected void readHeader() {
// read PSD header info
String sig = readString(4);
int ver = readShort();
skipBytes(6);
nChan = readShort();
height = readInt();
width = readInt();
int depth = readShort();
int mode = readShort();
int cmLen = readInt();
skipBytes(cmLen);
int imResLen = readInt();
skipBytes(imResLen);
// require 8-bit RGB data
if ((!sig.equals("8BPS")) || (ver != 1)) {
status = STATUS_FORMAT_ERROR;
} else if ((depth != 8) || (mode != 3)) {
status = STATUS_UNSUPPORTED;
}
}
protected int readInt() {
// read big-endian 32-bit integer
return (((((readByte() << 8) | readByte()) << 8) | readByte()) << 8) | readByte();
}
protected void readLayerInfo() {
// read layer header info
miscLen = readInt();
if (miscLen == 0) {
return; // no layers, only base image
}
int layerInfoLen = readInt();
nLayers = readShort();
if (nLayers > 0) {
layers = new LayerInfo[nLayers];
}
for (int i = 0; i < nLayers; i++) {
LayerInfo info = new LayerInfo();
layers[i] = info;
info.y = readInt();
info.x = readInt();
info.h = readInt() - info.y;
info.w = readInt() - info.x;
info.nChan = readShort();
info.chanID = new int[info.nChan];
for (int j = 0; j < info.nChan; j++) {
int id = readShort();
int size = readInt();
info.chanID[j] = id;
}
String s = readString(4);
if (!s.equals("8BIM")) {
status = STATUS_FORMAT_ERROR;
return;
}
skipBytes(4); // blend mode
info.alpha = readByte();
int clipping = readByte();
int flags = readByte();
readByte(); // filler
int extraSize = readInt();
skipBytes(extraSize);
}
}
protected void readLayers() {
// read and convert each layer to BufferedImage
frameCount = nLayers;
frames = new BufferedImage[nLayers];
for (int i = 0; i < nLayers; i++) {
LayerInfo info = layers[i];
byte[] r = null, g = null, b = null, a = null;
for (int j = 0; j < info.nChan; j++) {
int id = info.chanID[j];
switch (id) {
case 0:
r = readPlane(info.w, info.h);
break;
case 1:
g = readPlane(info.w, info.h);
break;
case 2:
b = readPlane(info.w, info.h);
break;
case -1:
a = readPlane(info.w, info.h);
break;
default:
readPlane(info.w, info.h);
}
if (err())
break;
}
if (err())
break;
int n = info.w * info.h;
if (r == null)
r = fillBytes(n, 0);
if (g == null)
g = fillBytes(n, 0);
if (b == null)
b = fillBytes(n, 0);
if (a == null)
a = fillBytes(n, 255);
BufferedImage im = makeImage(info.w, info.h, r, g, b, a);
frames[i] = im;
}
lineLengths = null;
if ((miscLen > 0) && !err()) {
int n = readInt(); // global layer mask info len
skipBytes(n);
}
}
protected byte[] readPlane(int w, int h) {
// read a single color plane
byte[] b = null;
int size = w * h;
if (hasLayers) {
// get RLE compression info for channel
rleEncoded = readShort() == 1;
if (rleEncoded) {
// list of encoded line lengths
readLineLengths(h);
}
}
if (rleEncoded) {
b = readPlaneCompressed(w, h);
} else {
b = new byte[size];
readBytes(b, size);
}
return b;
}
protected byte[] readPlaneCompressed(int w, int h) {
byte[] b = new byte[w * h];
byte[] s = new byte[w * 2];
int pos = 0;
for (int i = 0; i < h; i++) {
if (lineIndex >= lineLengths.length) {
status = STATUS_FORMAT_ERROR;
return null;
}
int len = lineLengths[lineIndex++];
readBytes(s, len);
decodeRLE(s, 0, len, b, pos);
pos += w;
}
return b;
}
protected void decodeRLE(byte[] src, int sindex, int slen, byte[] dst, int dindex) {
try {
int max = sindex + slen;
while (sindex < max) {
byte b = src[sindex++];
int n = (int) b;
if (n < 0) {
// dup next byte 1-n times
n = 1 - n;
b = src[sindex++];
for (int i = 0; i < n; i++) {
dst[dindex++] = b;
}
} else {
// copy next n+1 bytes
n = n + 1;
System.arraycopy(src, sindex, dst, dindex, n);
dindex += n;
sindex += n;
}
}
} catch (Exception e) {
status = STATUS_FORMAT_ERROR;
}
}
protected short readShort() {
// read big-endian 16-bit integer
return (short) ((readByte() << 8) | readByte());
}
protected String readString(int len) {
// read string of specified length
String s = "";
for (int i = 0; i < len; i++) {
s = s + (char) readByte();
}
return s;
}
protected void skipBytes(int n) {
// skip over n input bytes
for (int i = 0; i < n; i++) {
readByte();
}
}
}
|