ImageInputStreamImpl.java [plain text]
package javax.imageio.stream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.nio.ByteOrder;
import java.util.Stack;
public abstract class ImageInputStreamImpl implements ImageInputStream
{
private boolean closed;
private Stack markStack = new Stack();
byte[] buffer = new byte[8];
protected int bitOffset;
protected ByteOrder byteOrder;
protected long flushedPos;
protected long streamPos;
public ImageInputStreamImpl()
{
}
protected final void checkClosed()
throws IOException
{
if (closed)
throw new IOException("stream closed");
}
public void close()
throws IOException
{
checkClosed();
closed = true;
}
protected void finalize()
throws Throwable
{
close();
}
public void flush()
throws IOException
{
flushBefore(getStreamPosition());
}
public void flushBefore(long position)
throws IOException
{
if (position < flushedPos)
throw new IndexOutOfBoundsException();
if (position > streamPos)
throw new IndexOutOfBoundsException();
flushedPos = position;
}
public int getBitOffset()
throws IOException
{
checkClosed();
return bitOffset;
}
public ByteOrder getByteOrder()
{
return byteOrder;
}
public long getFlushedPosition()
{
return flushedPos;
}
public long getStreamPosition()
throws IOException
{
checkClosed();
return streamPos;
}
public boolean isCached()
{
return false;
}
public boolean isCachedFile()
{
return false;
}
public boolean isCachedMemory()
{
return false;
}
public long length()
{
return -1L;
}
public void mark()
{
try
{
markStack.push(new Long(getStreamPosition()));
}
catch (IOException e)
{
}
}
public abstract int read()
throws IOException;
public int read(byte[] data)
throws IOException
{
return read(data, 0, data.length);
}
public abstract int read(byte[] data, int offset, int len)
throws IOException;
public int readBit()
throws IOException
{
checkClosed();
int newOffset = (bitOffset + 1) & 0x7;
byte data = readByte();
if (bitOffset != 0)
{
seek(getStreamPosition() - 1);
data = (byte) (data >> (8 - newOffset));
}
bitOffset = newOffset;
return data & 0x1;
}
public long readBits(int numBits)
throws IOException
{
checkClosed();
if (numBits < 0 || numBits > 64)
throw new IllegalArgumentException();
if (numBits == 0)
return 0L;
long bits = 0L;
for (int i = 0; i < numBits; i++)
{
bits <<= 1;
bits |= readBit();
}
return bits;
}
public boolean readBoolean()
throws IOException
{
byte data = readByte();
return data != 0;
}
public byte readByte()
throws IOException
{
int data = read();
if (data == -1)
throw new EOFException();
return (byte) data;
}
public void readBytes(IIOByteBuffer buffer, int len)
throws IOException
{
int result = read(buffer.getData(), buffer.getOffset(), len);
if (result == -1 || result < len)
throw new EOFException();
buffer.setLength(len);
}
public char readChar()
throws IOException
{
return (char) readShort();
}
public double readDouble()
throws IOException
{
return (double) readLong();
}
public float readFloat()
throws IOException
{
return (float) readInt();
}
public void readFully(byte[] data)
throws IOException
{
readFully(data, 0, data.length);
}
public void readFully(byte[] data, int offset, int len)
throws IOException
{
for (int i = 0; i < len; ++i)
data[offset + i] = readByte();
}
public void readFully(char[] data, int offset, int len)
throws IOException
{
for (int i = 0; i < len; ++i)
data[offset + i] = readChar();
}
public void readFully(double[] data, int offset, int len)
throws IOException
{
for (int i = 0; i < len; ++i)
data[offset + i] = readDouble();
}
public void readFully(float[] data, int offset, int len)
throws IOException
{
for (int i = 0; i < len; ++i)
data[offset + i] = readFloat();
}
public void readFully(int[] data, int offset, int len)
throws IOException
{
for (int i = 0; i < len; ++i)
data[offset + i] = readInt();
}
public void readFully(long[] data, int offset, int len)
throws IOException
{
for (int i = 0; i < len; ++i)
data[offset + i] = readLong();
}
public void readFully(short[] data, int offset, int len)
throws IOException
{
for (int i = 0; i < len; ++i)
data[offset + i] = readShort();
}
public int readInt()
throws IOException
{
int result = read(buffer, 0, 4);
if (result == -1)
throw new EOFException();
if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)
{
return ((buffer[0] & 0xff)
+ (buffer[1] << 8)
+ (buffer[2] << 16)
+ (buffer[3] << 24));
}
return ((buffer[4] << 24)
+ (buffer[3] << 16)
+ (buffer[2] << 8)
+ (buffer[1] & 0xff));
}
public String readLine()
throws IOException
{
checkClosed();
int c = -1;
boolean eol = false;
StringBuffer buffer = new StringBuffer();
while (!eol && (c = read()) != -1)
{
switch(c)
{
case '\r':
long oldPosition = getStreamPosition();
if (read() != '\n')
seek(oldPosition);
case '\n':
eol = true;
break;
default:
buffer.append((char) c);
break;
}
}
if (c == -1 && buffer.length() == 0)
return null;
return buffer.toString();
}
public long readLong()
throws IOException
{
int result = read(buffer, 0, 8);
if (result == -1)
throw new EOFException();
if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)
{
return ((buffer[0] & 0xff)
+ (((buffer[1] & 0xff)) << 8)
+ (((buffer[2] & 0xff)) << 16)
+ (((buffer[3] & 0xffL)) << 24)
+ (((buffer[4] & 0xffL)) << 32)
+ (((buffer[5] & 0xffL)) << 40)
+ (((buffer[6] & 0xffL)) << 48)
+ (((long) buffer[7]) << 56));
}
return ((((long) buffer[7]) << 56)
+ ((buffer[6] & 0xffL) << 48)
+ ((buffer[5] & 0xffL) << 40)
+ ((buffer[4] & 0xffL) << 32)
+ ((buffer[3] & 0xffL) << 24)
+ ((buffer[2] & 0xff) << 16)
+ ((buffer[1] & 0xff) << 8)
+ (buffer[0] & 0xff));
}
public short readShort()
throws IOException
{
int result = read(buffer, 0, 2);
if (result == -1)
throw new EOFException();
if (getByteOrder() == ByteOrder.LITTLE_ENDIAN)
{
return (short) ((buffer[0] & 0xff)
+ (buffer[1] << 8));
}
return (short) ((buffer[0] << 8)
+ (buffer[1] & 0xff));
}
public int readUnsignedByte()
throws IOException
{
return readByte() & 0xff;
}
public long readUnsignedInt()
throws IOException
{
return readInt() & 0xffffffff;
}
public int readUnsignedShort()
throws IOException
{
return readShort() & 0xffff;
}
public String readUTF()
throws IOException
{
checkClosed();
String data;
ByteOrder old = getByteOrder();
setByteOrder(ByteOrder.BIG_ENDIAN);
try
{
data = DataInputStream.readUTF(this);
}
finally
{
setByteOrder(old);
}
return data;
}
public void reset()
throws IOException
{
checkClosed();
long mark = ((Long) markStack.pop()).longValue();
seek(mark);
}
public void seek(long position)
throws IOException
{
checkClosed();
if (position < getFlushedPosition())
throw new IndexOutOfBoundsException("position < flushed position");
streamPos = position;
bitOffset = 0;
}
public void setBitOffset (int bitOffset)
throws IOException
{
checkClosed();
if (bitOffset < 0 || bitOffset > 7)
throw new IllegalArgumentException();
this.bitOffset = bitOffset;
}
public void setByteOrder(ByteOrder byteOrder)
{
this.byteOrder = byteOrder;
}
public int skipBytes(int num)
throws IOException
{
checkClosed();
seek(getStreamPosition() + num);
bitOffset = 0;
return num;
}
public long skipBytes(long num)
throws IOException
{
checkClosed();
seek(getStreamPosition() + num);
bitOffset = 0;
return num;
}
}