src/main/java/org/apache/commons/imaging/common/BinaryConversions.java

/*
 * 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.commons.imaging.common;

public class BinaryConversions implements BinaryConstants {
    public static byte[] convertToByteArray(short[] values, int byteOrder) {
        return convertToByteArray(values, 0, values.length, byteOrder);
    }
    
    public static byte[] convertToByteArray(short[] values, int length, int byteOrder) {
        return convertToByteArray(values, 0, length, byteOrder);
    }
    
    public static byte[] convertToByteArray(short[] values, int offset, int length, int byteOrder) {
        byte[] result = new byte[length * 2];
        for (int i = 0; i < length; i++) {
            short value = values[offset + i];
            int start = i * 2;
            if (byteOrder == BYTE_ORDER_MOTOROLA) {
                result[start + 0] = (byte) (value >> 8);
                result[start + 1] = (byte) (value >> 0);
            } else {
                result[start + 1] = (byte) (value >> 8);
                result[start + 0] = (byte) (value >> 0);
            }
        }
        return result;
    }
    
    public static byte[] convertToByteArray(int[] values, int byteOrder) {
        return convertToByteArray(values, 0, values.length, byteOrder);
    }
    
    public static byte[] convertToByteArray(int[] values, int length, int byteOrder) {
        return convertToByteArray(values, 0, length, byteOrder);
    }
    
    public static byte[] convertToByteArray(int[] values, int offset, int length, int byteOrder) {
        byte[] result = new byte[length * 4];
        for (int i = 0; i < length; i++) {
            int value = values[offset + i];
            int start = i * 4;
            if (byteOrder == BYTE_ORDER_MOTOROLA) {
                result[start + 0] = (byte) (value >> 24);
                result[start + 1] = (byte) (value >> 16);
                result[start + 2] = (byte) (value >> 8);
                result[start + 3] = (byte) (value >> 0);
            } else {
                result[start + 3] = (byte) (value >> 24);
                result[start + 2] = (byte) (value >> 16);
                result[start + 1] = (byte) (value >> 8);
                result[start + 0] = (byte) (value >> 0);
            }
        }
        return result;
    }

    public static byte[] convertToByteArray(float[] values, int byteOrder) {
        return convertToByteArray(values, 0, values.length, byteOrder);
    }
    
    public static byte[] convertToByteArray(float[] values, int length, int byteOrder) {
        return convertToByteArray(values, 0, length, byteOrder);
    }
    
    public static byte[] convertToByteArray(float[] values, int offset, int length, int byteOrder) {
        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_INTEL) {
                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;
    }
    
    public static byte[] convertToByteArray(double[] values, int byteOrder) {
        return convertToByteArray(values, 0, values.length, byteOrder);
    }
    
    public static byte[] convertToByteArray(double[] values, int length, int byteOrder) {
        return convertToByteArray(values, 0, length, byteOrder);
    }
    
    public static byte[] convertToByteArray(double[] values, int offset, int length, int byteOrder) {
        byte[] result = new byte[length * 8];
        for (int i = 0; i < length; i++) {
            double value = values[offset + i];
            long bits = Double.doubleToRawLongBits(value);
            int start = i * 8;
            if (byteOrder == BYTE_ORDER_INTEL) {
                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;
    }
    
    public static byte[] convertToByteArray(RationalNumber[] values, int byteOrder) {
        return convertToByteArray(values, 0, values.length, byteOrder);
    }
    
    public static byte[] convertToByteArray(RationalNumber[] values, int length, int byteOrder) {
        return convertToByteArray(values, 0, length, byteOrder);
    }
    
    public static byte[] convertToByteArray(RationalNumber[] values, int offset, int length, int byteOrder) {
        byte[] result = new byte[length * 8];
        for (int i = 0; i < length; i++) {
            RationalNumber value = values[offset + i];
            int start = i * 8;
            if (byteOrder == BYTE_ORDER_MOTOROLA) {
                result[start + 0] = (byte) (value.numerator >> 24);
                result[start + 1] = (byte) (value.numerator >> 16);
                result[start + 2] = (byte) (value.numerator >> 8);
                result[start + 3] = (byte) (value.numerator >> 0);
                result[start + 4] = (byte) (value.divisor >> 24);
                result[start + 5] = (byte) (value.divisor >> 16);
                result[start + 6] = (byte) (value.divisor >> 8);
                result[start + 7] = (byte) (value.divisor >> 0);
            } else {
                result[start + 3] = (byte) (value.numerator >> 24);
                result[start + 2] = (byte) (value.numerator >> 16);
                result[start + 1] = (byte) (value.numerator >> 8);
                result[start + 0] = (byte) (value.numerator >> 0);
                result[start + 7] = (byte) (value.divisor >> 24);
                result[start + 6] = (byte) (value.divisor >> 16);
                result[start + 5] = (byte) (value.divisor >> 8);
                result[start + 4] = (byte) (value.divisor >> 0);
            }
        }
        return result;
    }

    public static short convertToShort(byte[] bytes, int byteOrder) {
        return convertToShort(bytes, 0, byteOrder);
    }
    
    public static short convertToShort(byte[] bytes, int offset, int byteOrder) {
        int byte0 = 0xff & bytes[offset + 0];
        int byte1 = 0xff & bytes[offset + 1];
        if (byteOrder == BYTE_ORDER_MOTOROLA) {
            return (short) ((byte0 << 8) | byte1);
        } else {
            return (short) ((byte1 << 8) | byte0);
        }
    }
    
    public static short[] convertToShortArray(byte[] bytes, int byteOrder) {
        return convertToShortArray(bytes, 0, bytes.length, byteOrder);
    }
    
    public static short[] convertToShortArray(byte[] bytes, int length, int byteOrder) {
        return convertToShortArray(bytes, 0, length, byteOrder);
    }
    
    public static short[] convertToShortArray(byte[] bytes, int offset, int length, int byteOrder) {
        short[] result = new short[length / 2];
        for (int i = 0; i < result.length; i++) {
            result[i] = convertToShort(bytes, offset + 2*i, byteOrder);
        }
        return result;
    }

    public static int convertToInt(byte[] bytes, int byteOrder) {
        return convertToInt(bytes, 0, byteOrder);
    }
    
    public static int convertToInt(byte[] bytes, int offset, int byteOrder) {
        int byte0 = 0xff & bytes[offset + 0];
        int byte1 = 0xff & bytes[offset + 1];
        int byte2 = 0xff & bytes[offset + 2];
        int byte3 = 0xff & bytes[offset + 3];
        if (byteOrder == BYTE_ORDER_MOTOROLA) {
            return (byte0 << 24) | (byte1 << 16) |
                    (byte2 << 8) | byte3;
        } else {
            return (byte3 << 24) | (byte2 << 16) |
                    (byte1 << 8) | byte0;
        }
    }
    
    public static int[] convertToIntArray(byte[] bytes, int byteOrder) {
        return convertToIntArray(bytes, 0, bytes.length, byteOrder);
    }
    
    public static int[] convertToIntArray(byte[] bytes, int length, int byteOrder) {
        return convertToIntArray(bytes, 0, length, byteOrder);
    }
    
    public static int[] convertToIntArray(byte[] bytes, int offset, int length, int byteOrder) {
        int[] result = new int[length / 4];
        for (int i = 0; i < result.length; i++) {
            result[i] = convertToInt(bytes, offset + 4*i, byteOrder);
        }
        return result;
    }
    
    public static float convertToFloat(byte[] bytes, int byteOrder) {
        return convertToFloat(bytes, 0, byteOrder);
    }
    
    public static float convertToFloat(byte[] bytes, int offset, int byteOrder) {
        int byte0 = 0xff & bytes[offset + 0];
        int byte1 = 0xff & bytes[offset + 1];
        int byte2 = 0xff & bytes[offset + 2];
        int byte3 = 0xff & bytes[offset + 3];
        int bits;
        if (byteOrder == BYTE_ORDER_MOTOROLA) {
            bits = (byte0 << 24) | (byte1 << 16) |
                    (byte2 << 8) | (byte3 << 0);
        } else {
            bits = (byte3 << 24) | (byte2 << 16) |
                    (byte1 << 8) | (byte0 << 0);
        }
        return Float.intBitsToFloat(bits);
    }
    
    public static float[] convertToFloatArray(byte[] bytes, int byteOrder) {
        return convertToFloatArray(bytes, 0, bytes.length, byteOrder);
    }
    
    public static float[] convertToFloatArray(byte[] bytes, int length, int byteOrder) {
        return convertToFloatArray(bytes, 0, length, byteOrder);
    }

    public static float[] convertToFloatArray(byte[] bytes, int offset, int length, int byteOrder) {
        float[] result = new float[length / 4];
        for (int i = 0; i < result.length; i++) {
            result[i] = convertToFloat(bytes, offset + 4*i, byteOrder);
        }
        return result;
    }
    
    public static double convertToDouble(byte[] bytes, int byteOrder) {
        return convertToDouble(bytes, 0, byteOrder);
    }
    
    public static double convertToDouble(byte[] bytes, int offset, int byteOrder) {
        long byte0 = 0xffL & bytes[offset + 0];
        long byte1 = 0xffL & bytes[offset + 1];
        long byte2 = 0xffL & bytes[offset + 2];
        long byte3 = 0xffL & bytes[offset + 3];
        long byte4 = 0xffL & bytes[offset + 4];
        long byte5 = 0xffL & bytes[offset + 5];
        long byte6 = 0xffL & bytes[offset + 6];
        long byte7 = 0xffL & bytes[offset + 7];
        long bits;
        if (byteOrder == BYTE_ORDER_MOTOROLA) {
            bits = (byte0 << 56) | (byte1 << 48) |
                    (byte2 << 40) | (byte3 << 32) |
                    (byte4 << 24) | (byte5 << 16) |
                    (byte6 << 8) | (byte7 << 0);
        } else {
            bits = (byte7 << 56) | (byte6 << 48) |
                    (byte5 << 40) | (byte4 << 32) |
                    (byte3 << 24) | (byte2 << 16) |
                    (byte1 << 8) | (byte0 << 0);
        }
        return Double.longBitsToDouble(bits);
    }
    
    public static double[] convertToDoubleArray(byte[] bytes, int byteOrder) {
        return convertToDoubleArray(bytes, 0, bytes.length, byteOrder);
    }
    
    public static double[] convertToDoubleArray(byte[] bytes, int length, int byteOrder) {
        return convertToDoubleArray(bytes, 0, length, byteOrder);
    }
    
    public static double[] convertToDoubleArray(byte[] bytes, int offset, int length, int byteOrder) {
        double[] result = new double[length / 8];
        for (int i = 0; i < result.length; i++) {
            result[i] = convertToDouble(bytes, offset + 8*i, byteOrder);
        }
        return result;
    }
    
    public static RationalNumber convertToRational(byte[] bytes, int byteOrder) {
        return convertToRational(bytes, 0, byteOrder);
    }
    
    public static RationalNumber convertToRational(byte[] bytes, int offset, int byteOrder) {
        int byte0 = 0xff & bytes[offset + 0];
        int byte1 = 0xff & bytes[offset + 1];
        int byte2 = 0xff & bytes[offset + 2];
        int byte3 = 0xff & bytes[offset + 3];
        int byte4 = 0xff & bytes[offset + 4];
        int byte5 = 0xff & bytes[offset + 5];
        int byte6 = 0xff & bytes[offset + 6];
        int byte7 = 0xff & bytes[offset + 7];
        int numerator;
        int divisor;
        if (byteOrder == BYTE_ORDER_MOTOROLA) {
            numerator = (byte0 << 24) | (byte1 << 16) |
                    (byte2 << 8) | byte3;
            divisor = (byte4 << 24) | (byte5 << 16) |
                    (byte6 << 8) | byte7;
        } else {
            numerator = (byte3 << 24) | (byte2 << 16) |
                    (byte1 << 8) | byte0;
            divisor = (byte7 << 24) | (byte6 << 16) |
                    (byte5 << 8) | byte4;
        }
        return new RationalNumber(numerator, divisor);
    }
    
    public static RationalNumber[] convertToRationalArray(byte[] bytes, int byteOrder) {
        return convertToRationalArray(bytes, 0, bytes.length, byteOrder);
    }
    
    public static RationalNumber[] convertToRationalArray(byte[] bytes, int length, int byteOrder) {
        return convertToRationalArray(bytes, 0, length, byteOrder);
    }
    
    public static RationalNumber[] convertToRationalArray(byte[] bytes, int offset, int length, int byteOrder) {
        RationalNumber[] result = new RationalNumber[length / 8];
        for (int i = 0; i < result.length; i++) {
            result[i] = convertToRational(bytes, offset + 8*i, byteOrder);
        }
        return result;
    }
}