/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.sanselan.common;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import org.apache.sanselan.ImageReadException;
public class BinaryInputStream extends InputStream implements BinaryConstants
{
protected boolean debug = false;
public final void setDebug(boolean b)
{
debug = b;
}
public final boolean getDebug()
{
return debug;
}
private final InputStream is;
public BinaryInputStream(byte bytes[], int byteOrder)
{
this.byteOrder = byteOrder;
this.is = new ByteArrayInputStream(bytes);
}
public BinaryInputStream(InputStream is, int byteOrder)
{
this.byteOrder = byteOrder;
this.is = is;
}
public BinaryInputStream(InputStream is)
{
this.is = is;
}
// default byte order for Java, many file formats.
private int byteOrder = BYTE_ORDER_NETWORK;
protected void setByteOrder(int a, int b) throws ImageReadException,
IOException
{
if (a != b)
throw new ImageReadException("Byte Order bytes don't match (" + a
+ ", " + b + ").");
if (a == BYTE_ORDER_MOTOROLA)
byteOrder = a;
else if (a == BYTE_ORDER_INTEL)
byteOrder = a;
else
throw new ImageReadException("Unknown Byte Order hint: " + a);
}
protected void setByteOrder(int byteOrder)
{
this.byteOrder = byteOrder;
}
protected int getByteOrder()
{
return byteOrder;
}
public int read() throws IOException
{
return is.read();
}
protected final int convertByteArrayToInt(String name, byte bytes[])
{
return convertByteArrayToInt(name, bytes, byteOrder);
}
public final int convertByteArrayToShort(String name, byte bytes[])
{
return convertByteArrayToShort(name, bytes, byteOrder);
}
public final int convertByteArrayToShort(String name, int start,
byte bytes[])
{
return convertByteArrayToShort(name, start, bytes, byteOrder);
}
public final int read4Bytes(String name, String exception)
throws ImageReadException, IOException
{
return read4Bytes(name, exception, byteOrder);
}
public final int read3Bytes(String name, String exception)
throws ImageReadException, IOException
{
return read3Bytes(name, exception, byteOrder);
}
public final int read2Bytes(String name, String exception)
throws ImageReadException, IOException
{
return read2Bytes(name, exception, byteOrder);
}
protected final void readRandomBytes() throws ImageReadException,
IOException
{
for (int counter = 0; counter < 100; counter++)
{
readByte("" + counter, "Random Data");
}
}
public final void debugNumber(String msg, int data)
{
debugNumber(msg, data, 1);
}
public final void debugNumber(String msg, int data, int bytes)
{
System.out.print(msg + ": " + data + " (");
int byteData = data;
for (int i = 0; i < bytes; i++)
{
if (i > 0)
System.out.print(",");
int singleByte = 0xff & byteData;
System.out.print((char) singleByte + " [" + singleByte + "]");
byteData >>= 8;
}
System.out.println(") [0x" + Integer.toHexString(data) + ", "
+ Integer.toBinaryString(data) + "]");
}
public final void readAndVerifyBytes(byte expected[], String exception)
throws ImageReadException, IOException
{
for (int i = 0; i < expected.length; i++)
{
int data = is.read();
byte b = (byte) (0xff & data);
if ((data < 0) || (b != expected[i]))
{
System.out.println("i" + ": " + i);
this.debugByteArray("expected", expected);
debugNumber("data[" + i + "]", b);
// debugNumber("expected[" + i + "]", expected[i]);
throw new ImageReadException(exception);
}
}
}
protected final void readAndVerifyBytes(String name, byte expected[],
String exception) throws ImageReadException, IOException
{
byte bytes[] = readByteArray(name, expected.length, exception);
for (int i = 0; i < expected.length; i++)
{
if (bytes[i] != expected[i])
{
System.out.println("i" + ": " + i);
debugNumber("bytes[" + i + "]", bytes[i]);
debugNumber("expected[" + i + "]", expected[i]);
throw new ImageReadException(exception);
}
}
}
public final void skipBytes(int length, String exception)
throws IOException
{
long total = 0;
while (length != total)
{
long skipped = is.skip(length - total);
if (skipped < 1)
throw new IOException(exception + " (" + skipped + ")");
total += skipped;
}
}
protected final void scanForByte(byte value) throws IOException
{
int count = 0;
for (int i = 0; count < 3; i++)
// while(count<3)
{
int b = is.read();
if (b < 0)
return;
if ((0xff & b) == value)
{
System.out.println("\t" + i + ": match.");
count++;
}
}
}
public final byte readByte(String name, String exception)
throws IOException
{
int result = is.read();
if ((result < 0))
{
System.out.println(name + ": " + result);
throw new IOException(exception);
}
if (debug)
debugNumber(name, result);
return (byte) (0xff & result);
}
protected final RationalNumber[] convertByteArrayToRationalArray(
String name, byte bytes[], int start, int length, int byteOrder)
{
int expectedLength = start + length * 8;
if (bytes.length < expectedLength)
{
System.out.println(name + ": expected length: " + expectedLength
+ ", actual length: " + bytes.length);
return null;
}
RationalNumber result[] = new RationalNumber[length];
for (int i = 0; i < length; i++)
{
result[i] = convertByteArrayToRational(name, bytes, start + i * 8,
byteOrder);
}
return result;
}
protected final RationalNumber convertByteArrayToRational(String name,
byte bytes[], int byteOrder)
{
return convertByteArrayToRational(name, bytes, 0, byteOrder);
}
protected final RationalNumber convertByteArrayToRational(String name,
byte bytes[], int start, int byteOrder)
{
int numerator = convertByteArrayToInt(name, bytes, start + 0, 4,
byteOrder);
int divisor = convertByteArrayToInt(name, bytes, start + 4, 4,
byteOrder);
return new RationalNumber(numerator, divisor);
}
protected final int convertByteArrayToInt(String name, byte bytes[],
int byteOrder)
{
return convertByteArrayToInt(name, bytes, 0, 4, byteOrder);
}
protected final int convertByteArrayToInt(String name, byte bytes[],
int start, int length, int byteOrder)
{
byte byte0 = bytes[start + 0];
byte byte1 = bytes[start + 1];
byte byte2 = bytes[start + 2];
byte byte3 = 0;
if (length == 4)
byte3 = bytes[start + 3];
// return convert4BytesToInt(name, byte0, byte1, byte2, byte3,
// byteOrder);
int result;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
result = ((0xff & byte0) << 24) + ((0xff & byte1) << 16)
+ ((0xff & byte2) << 8) + ((0xff & byte3) << 0);
// result = (( byte0) << 24) + ((byte1) << 16)
// + (( byte2) << 8) + (( byte3) << 0);
else
// intel, little endian
result = ((0xff & byte3) << 24) + ((0xff & byte2) << 16)
+ ((0xff & byte1) << 8) + ((0xff & byte0) << 0);
// result = (( byte3) << 24) + (( byte2) << 16)
// + (( byte1) << 8) + (( byte0) << 0);
if (debug)
debugNumber(name, result, 4);
return result;
}
protected final int[] convertByteArrayToIntArray(String name, byte bytes[],
int start, int length, int byteOrder)
{
int expectedLength = start + length * 4;
if (bytes.length < expectedLength)
{
System.out.println(name + ": expected length: " + expectedLength
+ ", actual length: " + bytes.length);
return null;
}
int result[] = new int[length];
for (int i = 0; i < length; i++)
{
result[i] = convertByteArrayToInt(name, bytes, start + i * 4, 4,
byteOrder);
}
return result;
}
protected final int convertByteArrayToShort(String name, byte bytes[],
int byteOrder)
{
return convertByteArrayToShort(name, 0, bytes, byteOrder);
}
protected final int convertByteArrayToShort(String name, int start,
byte bytes[], int byteOrder)
{
byte byte0 = bytes[start + 0];
byte byte1 = bytes[start + 1];
// return convert2BytesToShort(name, byte0, byte1, byteOrder);
int result;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
result = ((0xff & byte0) << 8) + ((0xff & byte1) << 0);
else
// intel, little endian
result = ((0xff & byte1) << 8) + ((0xff & byte0) << 0);
if (debug)
debugNumber(name, result, 2);
return result;
}
protected final int[] convertByteArrayToShortArray(String name,
byte bytes[], int start, int length, int byteOrder)
{
int expectedLength = start + length * 2;
if (bytes.length < expectedLength)
{
System.out.println(name + ": expected length: " + expectedLength
+ ", actual length: " + bytes.length);
return null;
}
int result[] = new int[length];
for (int i = 0; i < length; i++)
{
result[i] = convertByteArrayToShort(name, start + i * 2, bytes,
byteOrder);
// byte byte0 = bytes[start + i * 2];
// byte byte1 = bytes[start + i * 2 + 1];
// result[i] = convertBytesToShort(name, byte0, byte1, byteOrder);
}
return result;
}
public final byte[] readByteArray(String name, int length, String exception)
throws ImageReadException, IOException
{
byte result[] = new byte[length];
int read = 0;
while (read < length)
{
int count = is.read(result, read, length - read);
if (count < 1)
throw new IOException(exception);
read += count;
}
if (debug)
{
for (int i = 0; ((i < length) && (i < 150)); i++)
{
debugNumber(name + " (" + i + ")", 0xff & result[i]);
}
}
return result;
}
protected final void debugByteArray(String name, byte bytes[])
{
System.out.println(name + ": " + bytes.length);
for (int i = 0; ((i < bytes.length) && (i < 50)); i++)
{
debugNumber(name + " (" + i + ")", bytes[i]);
}
}
protected final void debugNumberArray(String name, int numbers[], int length)
{
System.out.println(name + ": " + numbers.length);
for (int i = 0; ((i < numbers.length) && (i < 50)); i++)
{
debugNumber(name + " (" + i + ")", numbers[i], length);
}
}
public final byte[] readBytearray(String name, byte bytes[], int start,
int count)
{
if (bytes.length < (start + count))
return null;
byte result[] = new byte[count];
System.arraycopy(bytes, start, result, 0, count);
if (debug)
debugByteArray(name, result);
return result;
}
public final byte[] readByteArray(int length, String error)
throws ImageReadException, IOException
{
boolean verbose = false;
boolean strict = true;
return readByteArray(length, error, verbose, strict);
}
public final byte[] readByteArray(int length, String error,
boolean verbose, boolean strict) throws ImageReadException,
IOException
{
byte bytes[] = new byte[length];
int total = 0;
int read;
while ((read = read(bytes, total, length - total)) > 0)
total += read;
if (total < length)
{
if (strict)
throw new ImageReadException(error);
else if(verbose)
System.out.println(error);
return null;
}
return bytes;
}
protected final byte[] getBytearrayTail(String name, byte bytes[], int count)
{
return readBytearray(name, bytes, count, bytes.length - count);
}
protected final byte[] getBytearrayHead(String name, byte bytes[], int count)
{
return readBytearray(name, bytes, 0, bytes.length - count);
}
public final boolean compareByteArrays(byte a[], int aStart, byte b[],
int bStart, int length)
{
if (a.length < (aStart + length))
return false;
if (b.length < (bStart + length))
return false;
for (int i = 0; i < length; i++)
{
if (a[aStart + i] != b[bStart + i])
{
debugNumber("a[" + (aStart + i) + "]", a[aStart + i]);
debugNumber("b[" + (bStart + i) + "]", b[bStart + i]);
return false;
}
}
return true;
}
protected final int read4Bytes(String name, String exception, int byteOrder)
throws ImageReadException, IOException
{
int size = 4;
byte bytes[] = new byte[size];
int read = 0;
while (read < size)
{
int count = is.read(bytes, read, size - read);
if (count < 1)
throw new IOException(exception);
read += count;
}
return convertByteArrayToInt(name, bytes, byteOrder);
}
protected final int read3Bytes(String name, String exception, int byteOrder)
throws ImageReadException, IOException
{
int size = 3;
byte bytes[] = new byte[size];
int read = 0;
while (read < size)
{
int count = is.read(bytes, read, size - read);
if (count < 1)
throw new IOException(exception);
read += count;
}
return convertByteArrayToInt(name, bytes, 0, 3, byteOrder);
}
protected final int read2Bytes(String name, String exception, int byteOrder)
throws ImageReadException, IOException
{
int size = 2;
byte bytes[] = new byte[size];
int read = 0;
while (read < size)
{
int count = is.read(bytes, read, size - read);
if (count < 1)
throw new IOException(exception);
read += count;
}
return convertByteArrayToShort(name, bytes, byteOrder);
}
public final int read1ByteInteger(String exception)
throws ImageReadException, IOException
{
int byte0 = is.read();
if (byte0 < 0)
throw new ImageReadException(exception);
return 0xff & byte0;
}
public final int read2ByteInteger(String exception)
throws ImageReadException, IOException
{
int byte0 = is.read();
int byte1 = is.read();
if (byte0 < 0 || byte1 < 0)
throw new ImageReadException(exception);
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
return ((0xff & byte0) << 8) + ((0xff & byte1) << 0);
else
// intel, little endian
return ((0xff & byte1) << 8) + ((0xff & byte0) << 0);
}
public final int read4ByteInteger(String exception)
throws ImageReadException, IOException
{
int byte0 = is.read();
int byte1 = is.read();
int byte2 = is.read();
int byte3 = is.read();
if (byte0 < 0 || byte1 < 0 || byte2 < 0 || byte3 < 0)
throw new ImageReadException(exception);
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
return ((0xff & byte0) << 24) + ((0xff & byte1) << 16)
+ ((0xff & byte2) << 8) + ((0xff & byte3) << 0);
else
// intel, little endian
return ((0xff & byte3) << 24) + ((0xff & byte2) << 16)
+ ((0xff & byte1) << 8) + ((0xff & byte0) << 0);
}
protected final void printCharQuad(String msg, int i)
{
System.out.println(msg + ": '" + (char) (0xff & (i >> 24))
+ (char) (0xff & (i >> 16)) + (char) (0xff & (i >> 8))
+ (char) (0xff & (i >> 0)) + "'");
}
protected final void printByteBits(String msg, byte i)
{
System.out.println(msg + ": '" + Integer.toBinaryString(0xff & i));
}
protected final static int CharsToQuad(char c1, char c2, char c3, char c4)
{
return (((0xff & c1) << 24) | ((0xff & c2) << 16) | ((0xff & c3) << 8) | ((0xff & c4) << 0));
}
public final int findNull(byte src[])
{
return findNull(src, 0);
}
public final int findNull(byte src[], int start)
{
for (int i = start; i < src.length; i++)
{
if (src[i] == 0)
return i;
}
return -1;
}
protected final byte[] getRAFBytes(RandomAccessFile raf, long pos,
int length, String exception) throws IOException
{
byte result[] = new byte[length];
if (debug)
{
System.out.println("getRAFBytes pos" + ": " + pos);
System.out.println("getRAFBytes length" + ": " + length);
}
raf.seek(pos);
int read = 0;
while (read < length)
{
int count = raf.read(result, read, length - read);
if (count < 1)
throw new IOException(exception);
read += count;
}
return result;
}
protected void skipBytes(int length) throws IOException
{
skipBytes(length, "Couldn't skip bytes");
}
}