/*
* 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.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import org.apache.sanselan.ImageReadException;
import org.apache.sanselan.ImageWriteException;
public class BinaryFileFunctions implements BinaryConstants
{
protected boolean debug = false;
public final void setDebug(boolean b)
{
debug = b;
}
public final boolean getDebug()
{
return debug;
}
protected final void readRandomBytes(InputStream is)
throws ImageReadException, IOException
{
for (int counter = 0; counter < 100; counter++)
{
readByte("" + counter, is, "Random Data");
}
}
public final void debugNumber(String msg, int data)
{
debugNumber(msg, data, 1);
}
public final void debugNumber(String msg, int data, int bytes)
{
PrintWriter pw = new PrintWriter(System.out);
debugNumber(pw, msg,
data, bytes);
pw.flush();
}
public final void debugNumber(PrintWriter pw, String msg, int data)
{
debugNumber(pw, msg, data, 1);
}
public final void debugNumber(PrintWriter pw, String msg, int data,
int bytes)
{
pw.print(msg + ": " + data + " (");
int byteData = data;
for (int i = 0; i < bytes; i++)
{
if (i > 0)
pw.print(",");
int singleByte = 0xff & byteData;
pw.print((char) singleByte + " [" + singleByte + "]");
byteData >>= 8;
}
pw.println(") [0x" + Integer.toHexString(data) + ", "
+ Integer.toBinaryString(data) + "]");
pw.flush();
}
public final boolean startsWith(byte haystack[], byte needle[])
{
if (needle == null)
return false;
if (haystack == null)
return false;
if (needle.length > haystack.length)
return false;
for (int i = 0; i < needle.length; i++)
{
if (needle[i] != haystack[i])
return false;
}
return true;
}
public final byte[] readBytes(InputStream is, int count)
throws ImageReadException, IOException
{
byte result[] = new byte[count];
for (int i = 0; i < count; i++)
{
int data = is.read();
result[i] = (byte) data;
}
return result;
}
public final void readAndVerifyBytes(InputStream is, 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)
throw new ImageReadException("Unexpected EOF.");
if (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, InputStream is,
byte expected[], String exception) throws ImageReadException,
IOException
{
byte bytes[] = readByteArray(name, expected.length, is, 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(InputStream is, 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(InputStream is, 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, InputStream is, String exception)
throws ImageReadException, 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, byteOrder);
int divisor = convertByteArrayToInt(name, bytes, start + 4, byteOrder);
return new RationalNumber(numerator, divisor);
}
protected final int convertByteArrayToInt(String name, byte bytes[],
int byteOrder)
{
return convertByteArrayToInt(name, bytes, 0, byteOrder);
}
protected final int convertByteArrayToInt(String name, byte bytes[],
int start, int byteOrder)
{
byte byte0 = bytes[start + 0];
byte byte1 = bytes[start + 1];
byte byte2 = bytes[start + 2];
byte byte3 = bytes[start + 3];
int result;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
result = ((0xff & byte0) << 24) | ((0xff & byte1) << 16)
| ((0xff & byte2) << 8) | ((0xff & byte3) << 0);
} else
{
// intel, little endian
result = ((0xff & byte3) << 24) | ((0xff & byte2) << 16)
| ((0xff & byte1) << 8) | ((0xff & 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,
byteOrder);
}
return result;
}
protected final void writeIntInToByteArray(int value, byte bytes[],
int start, int byteOrder)
{
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
bytes[start + 0] = (byte) (value >> 24);
bytes[start + 1] = (byte) (value >> 16);
bytes[start + 2] = (byte) (value >> 8);
bytes[start + 3] = (byte) (value >> 0);
} else
{
bytes[start + 3] = (byte) (value >> 24);
bytes[start + 2] = (byte) (value >> 16);
bytes[start + 1] = (byte) (value >> 8);
bytes[start + 0] = (byte) (value >> 0);
}
}
protected static final byte[] int2ToByteArray(int value, int byteOrder)
{
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
return new byte[] { (byte) (value >> 8), (byte) (value >> 0), };
else
return new byte[] { (byte) (value >> 0), (byte) (value >> 8), };
}
protected final byte[] convertIntArrayToByteArray(int values[],
int byteOrder)
{
byte result[] = new byte[values.length * 4];
for (int i = 0; i < values.length; i++)
{
writeIntInToByteArray(values[i], result, i * 4, byteOrder);
}
return result;
}
protected final byte[] convertShortArrayToByteArray(int values[],
int byteOrder)
{
byte result[] = new byte[values.length * 2];
for (int i = 0; i < values.length; i++)
{
int value = values[i];
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
result[i * 2 + 0] = (byte) (value >> 8);
result[i * 2 + 1] = (byte) (value >> 0);
} else
{
result[i * 2 + 1] = (byte) (value >> 8);
result[i * 2 + 0] = (byte) (value >> 0);
}
}
return result;
}
protected final byte[] convertShortToByteArray(int value, int byteOrder)
{
byte result[] = new byte[2];
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
result[0] = (byte) (value >> 8);
result[1] = (byte) (value >> 0);
} else
{
result[1] = (byte) (value >> 8);
result[0] = (byte) (value >> 0);
}
return result;
}
protected final byte[] convertIntArrayToRationalArray(int numerators[],
int denominators[], int byteOrder) throws ImageWriteException
{
if (numerators.length != denominators.length)
throw new ImageWriteException("numerators.length ("
+ numerators.length + " != denominators.length ("
+ denominators.length + ")");
byte result[] = new byte[numerators.length * 8];
for (int i = 0; i < numerators.length; i++)
{
writeIntInToByteArray(numerators[i], result, i * 8, byteOrder);
writeIntInToByteArray(denominators[i], result, i * 8 + 4, byteOrder);
}
return result;
}
protected final byte[] convertRationalArrayToByteArray(
RationalNumber numbers[], int byteOrder) throws ImageWriteException
{
// Debug.debug("convertRationalArrayToByteArray 2");
byte result[] = new byte[numbers.length * 8];
for (int i = 0; i < numbers.length; i++)
{
writeIntInToByteArray(numbers[i].numerator, result, i * 8,
byteOrder);
writeIntInToByteArray(numbers[i].divisor, result, i * 8 + 4,
byteOrder);
}
return result;
}
protected final byte[] convertRationalToByteArray(RationalNumber number,
int byteOrder) throws ImageWriteException
{
byte result[] = new byte[8];
writeIntInToByteArray(number.numerator, result, 0, byteOrder);
writeIntInToByteArray(number.divisor, result, 4, byteOrder);
return result;
}
protected final int convertByteArrayToShort(String name, byte bytes[],
int byteOrder) throws ImageReadException
{
return convertByteArrayToShort(name, 0, bytes, byteOrder);
}
protected final int convertByteArrayToShort(String name, int index,
byte bytes[], int byteOrder) throws ImageReadException
{
if (index + 1 >= bytes.length)
throw new ImageReadException("Index out of bounds. Array size: "
+ bytes.length + ", index: " + index);
int byte0 = 0xff & bytes[index + 0];
int byte1 = 0xff & bytes[index + 1];
int result;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
result = (byte0 << 8) | byte1;
else
// intel, little endian
result = (byte1 << 8) | byte0;
if (debug)
debugNumber(name, result, 2);
return result;
}
protected final int[] convertByteArrayToShortArray(String name,
byte bytes[], int start, int length, int byteOrder)
throws ImageReadException
{
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);
}
return result;
}
public final byte[] readByteArray(String name, int length, InputStream is)
throws IOException
{
String exception = name + " could not be read.";
return readByteArray(name, length, is, exception);
}
public final byte[] readByteArray(String name, int length, InputStream is,
String exception) throws IOException
{
byte result[] = new byte[length];
int read = 0;
while (read < length)
{
int count = is.read(result, read, length - read);
// Debug.debug("count", count);
if (count < 1)
throw new IOException(exception+" count: "+ count + " read: "+read+" length: "+length);
read += count;
}
if (debug)
{
for (int i = 0; ((i < length) && (i < 50)); i++)
{
debugNumber(name + " (" + i + ")", 0xff & result[i]);
}
}
return result;
}
public final void debugByteArray(String name, byte bytes[])
{
System.out.println(name + ": " + bytes.length);
for (int i = 0; ((i < bytes.length) && (i < 50)); i++)
{
debugNumber("\t" + " (" + i + ")", 0xff & 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) throws ImageReadException
{
if (bytes.length < (start + count))
{
throw new ImageReadException("Invalid read. bytes.length: " + bytes.length+ ", start: " + start + ", count: " + count);
// return null;
}
byte result[] = new byte[count];
System.arraycopy(bytes, start, result, 0, count);
if (debug)
debugByteArray(name, result);
return result;
}
protected final byte[] getByteArrayTail(String name, byte bytes[], int count) throws ImageReadException
{
return readBytearray(name, bytes, count, bytes.length - count);
}
protected final byte[] getBytearrayHead(String name, byte bytes[], int count) throws ImageReadException
{
return readBytearray(name, bytes, 0, bytes.length - count);
}
public static final byte[] slice(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);
return result;
}
public static final byte[] tail(byte bytes[], int count)
{
if (count > bytes.length)
count = bytes.length;
return slice(bytes, bytes.length - count, count);
}
public static final byte[] head(byte bytes[], int count)
{
if (count > bytes.length)
count = bytes.length;
return slice(bytes, 0, count);
}
public final boolean compareByteArrays(byte a[], byte b[])
{
if (a.length != b.length)
return false;
return compareByteArrays(a, 0, b, 0, a.length);
}
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("\t" + "a[" + (aStart + i) + "]", a[aStart + i]);
// debugNumber("\t" + "b[" + (bStart + i) + "]", b[bStart + i]);
return false;
}
}
return true;
}
public static final boolean compareBytes(byte a[], byte b[])
{
if (a.length != b.length)
return false;
return compareBytes(a, 0, b, 0, a.length);
}
public static final boolean compareBytes(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])
return false;
}
return true;
}
protected final int read4Bytes(String name, InputStream is,
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, InputStream is,
String exception, int byteOrder) throws ImageReadException,
IOException
{
byte byte0 = (byte) is.read();
byte byte1 = (byte) is.read();
byte byte2 = (byte) is.read();
int result;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
result = ((0xff & byte0) << 16) | ((0xff & byte1) << 8)
| ((0xff & byte2) << 0);
else
// intel, little endian
result = ((0xff & byte2) << 16) | ((0xff & byte1) << 8)
| ((0xff & byte0) << 0);
if (debug)
debugNumber(name, result, 3);
return result;
//
//
// 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, InputStream is,
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);
}
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 printCharQuad(PrintWriter pw, String msg, int i)
{
pw.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));
}
public 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
{
if (debug)
{
System.out.println("getRAFBytes pos" + ": " + pos);
System.out.println("getRAFBytes length" + ": " + length);
}
byte result[] = new byte[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 final float convertByteArrayToFloat(String name, byte bytes[],
int byteOrder)
{
return convertByteArrayToFloat(name, bytes, 0, byteOrder);
}
protected final float convertByteArrayToFloat(String name, byte bytes[],
int start, int byteOrder)
{
// TODO: not tested; probably wrong.
byte byte0 = bytes[start + 0];
byte byte1 = bytes[start + 1];
byte byte2 = bytes[start + 2];
byte byte3 = bytes[start + 3];
int bits;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
bits = ((0xff & byte0) << 24) | ((0xff & byte1) << 16)
| ((0xff & byte2) << 8) | ((0xff & byte3) << 0);
} else
{
// intel, little endian
bits = ((0xff & byte3) << 24) | ((0xff & byte2) << 16)
| ((0xff & byte1) << 8) | ((0xff & byte0) << 0);
}
float result = Float.intBitsToFloat(bits);
// if (debug)
// debugNumber(name, result, 4);
return result;
}
protected final float[] convertByteArrayToFloatArray(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;
}
float result[] = new float[length];
for (int i = 0; i < length; i++)
{
result[i] = convertByteArrayToFloat(name, bytes, start + i * 4,
byteOrder);
}
return result;
}
protected final byte[] convertFloatToByteArray(float value, int byteOrder)
{
// TODO: not tested; probably wrong.
byte result[] = new byte[4];
int bits = Float.floatToRawIntBits(value);
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
result[0] = (byte) (0xff & (bits >> 0));
result[1] = (byte) (0xff & (bits >> 8));
result[2] = (byte) (0xff & (bits >> 16));
result[3] = (byte) (0xff & (bits >> 24));
} else
{
result[3] = (byte) (0xff & (bits >> 0));
result[2] = (byte) (0xff & (bits >> 8));
result[1] = (byte) (0xff & (bits >> 16));
result[0] = (byte) (0xff & (bits >> 24));
}
return result;
}
protected final byte[] convertFloatArrayToByteArray(float values[],
int byteOrder)
{
// TODO: not tested; probably wrong.
byte result[] = new byte[values.length * 4];
for (int i = 0; i < values.length; i++)
{
float value = values[i];
int bits = Float.floatToRawIntBits(value);
int start = i * 4;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
result[start + 0] = (byte) (0xff & (bits >> 0));
result[start + 1] = (byte) (0xff & (bits >> 8));
result[start + 2] = (byte) (0xff & (bits >> 16));
result[start + 3] = (byte) (0xff & (bits >> 24));
} else
{
result[start + 3] = (byte) (0xff & (bits >> 0));
result[start + 2] = (byte) (0xff & (bits >> 8));
result[start + 1] = (byte) (0xff & (bits >> 16));
result[start + 0] = (byte) (0xff & (bits >> 24));
}
}
return result;
}
protected final byte[] convertDoubleToByteArray(double value, int byteOrder)
{
// TODO: not tested; probably wrong.
byte result[] = new byte[8];
long bits = Double.doubleToRawLongBits(value);
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
result[0] = (byte) (0xff & (bits >> 0));
result[1] = (byte) (0xff & (bits >> 8));
result[2] = (byte) (0xff & (bits >> 16));
result[3] = (byte) (0xff & (bits >> 24));
result[4] = (byte) (0xff & (bits >> 32));
result[5] = (byte) (0xff & (bits >> 40));
result[6] = (byte) (0xff & (bits >> 48));
result[7] = (byte) (0xff & (bits >> 56));
} else
{
result[7] = (byte) (0xff & (bits >> 0));
result[6] = (byte) (0xff & (bits >> 8));
result[5] = (byte) (0xff & (bits >> 16));
result[4] = (byte) (0xff & (bits >> 24));
result[3] = (byte) (0xff & (bits >> 32));
result[2] = (byte) (0xff & (bits >> 40));
result[1] = (byte) (0xff & (bits >> 48));
result[0] = (byte) (0xff & (bits >> 56));
}
return result;
}
protected final byte[] convertDoubleArrayToByteArray(double values[],
int byteOrder)
{
// TODO: not tested; probably wrong.
byte result[] = new byte[values.length * 8];
for (int i = 0; i < values.length; i++)
{
double value = values[i];
long bits = Double.doubleToRawLongBits(value);
int start = i * 8;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
result[start + 0] = (byte) (0xff & (bits >> 0));
result[start + 1] = (byte) (0xff & (bits >> 8));
result[start + 2] = (byte) (0xff & (bits >> 16));
result[start + 3] = (byte) (0xff & (bits >> 24));
result[start + 4] = (byte) (0xff & (bits >> 32));
result[start + 5] = (byte) (0xff & (bits >> 40));
result[start + 6] = (byte) (0xff & (bits >> 48));
result[start + 7] = (byte) (0xff & (bits >> 56));
} else
{
result[start + 7] = (byte) (0xff & (bits >> 0));
result[start + 6] = (byte) (0xff & (bits >> 8));
result[start + 5] = (byte) (0xff & (bits >> 16));
result[start + 4] = (byte) (0xff & (bits >> 24));
result[start + 3] = (byte) (0xff & (bits >> 32));
result[start + 2] = (byte) (0xff & (bits >> 40));
result[start + 1] = (byte) (0xff & (bits >> 48));
result[start + 0] = (byte) (0xff & (bits >> 56));
}
}
return result;
}
protected final double convertByteArrayToDouble(String name, byte bytes[],
int byteOrder)
{
return convertByteArrayToDouble(name, bytes, 0, byteOrder);
}
protected final double convertByteArrayToDouble(String name, byte bytes[],
int start, int byteOrder)
{
// TODO: not tested; probably wrong.
byte byte0 = bytes[start + 0];
byte byte1 = bytes[start + 1];
byte byte2 = bytes[start + 2];
byte byte3 = bytes[start + 3];
byte byte4 = bytes[start + 4];
byte byte5 = bytes[start + 5];
byte byte6 = bytes[start + 6];
byte byte7 = bytes[start + 7];
long bits;
if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
{
bits = ((0xff & byte0) << 56) | ((0xff & byte1) << 48)
| ((0xff & byte2) << 40) | ((0xff & byte3) << 32)
| ((0xff & byte4) << 24) | ((0xff & byte5) << 16)
| ((0xff & byte6) << 8) | ((0xff & byte7) << 0);
} else
{
// intel, little endian
bits = ((0xff & byte7) << 56) | ((0xff & byte6) << 48)
| ((0xff & byte5) << 40) | ((0xff & byte4) << 32)
| ((0xff & byte3) << 24) | ((0xff & byte2) << 16)
| ((0xff & byte1) << 8) | ((0xff & byte0) << 0);
}
double result = Double.longBitsToDouble(bits);
// if (debug)
// debugNumber(name, result, 4);
return result;
// byte array[];
// if (byteOrder == BYTE_ORDER_MOTOROLA) // motorola, big endian
// // ?? dunno byte order very likely wrong here.
// array = new byte[]{
// bytes[start + 0], bytes[start + 1], bytes[start + 2],
// bytes[start + 3], bytes[start + 4], bytes[start + 5],
// bytes[start + 6], bytes[start + 7],
//
// };
// else
// // ?? dunno byte order very likely wrong here.
// array = new byte[]{
// bytes[start + 3], bytes[start + 2], bytes[start + 1],
// bytes[start + 0], bytes[start + 7], bytes[start + 6],
// bytes[start + 5], bytes[start + 4],
// };
//
// double result = Double.NaN;
//
// try
// {
// ByteArrayInputStream bais = new ByteArrayInputStream(array);
// if (start > 0)
// {
// skipBytes(bais, start);
// // bais.skip(start);
// }
// DataInputStream dis = new DataInputStream(bais);
// result = dis.readDouble();
//
// dis.close();
// }
// catch (Exception e)
// {
// Debug.debug(e);
// }
//
// return result;
}
protected final double[] convertByteArrayToDoubleArray(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;
}
double result[] = new double[length];
for (int i = 0; i < length; i++)
{
result[i] = convertByteArrayToDouble(name, bytes, start + i * 8,
byteOrder);
}
return result;
}
protected void skipBytes(InputStream is, int length) throws IOException
{
this.skipBytes(is, length, "Couldn't skip bytes");
}
public final void copyStreamToStream(InputStream is, OutputStream os)
throws IOException
{
byte buffer[] = new byte[1024];
int read;
while ((read = is.read(buffer)) > 0)
{
os.write(buffer, 0, read);
}
}
public final byte[] getStreamBytes(InputStream is) throws IOException
{
ByteArrayOutputStream os = new ByteArrayOutputStream();
copyStreamToStream(is, os);
return os.toByteArray();
}
}