net.sourceforge.jiu.util

Class ArrayConverter


public class ArrayConverter
extends java.lang.Object

Helper class with static methods to convert between byte arrays and primitive types. Useful for serialization.
Author:
Marco Schmidt
Since:
0.9.0

Field Summary

private static int
INT_SIZE
private static int
SHORT_SIZE

Constructor Summary

ArrayConverter()

Method Summary

private static void
checkArray(byte[] array, int offset, int length)
Makes sure that the arguments define a valid (existing) array interval.
static void
convertPacked2BitIntensityTo8Bit(byte[] src, int srcOffset, byte[] dest, int destOffset, int numPackedBytes)
Converts bytes with two four-bit-intensity samples to 8 byte intensity values, each stored in one byte.
static void
convertPacked4BitIntensityTo8Bit(byte[] src, int srcOffset, byte[] dest, int destOffset, int numPackedBytes)
Converts bytes with four two-bit-intensity samples to byte-sized intensity values.
static void
copyPackedBytes(byte[] src, int srcOffset, int srcBitOffset, byte[] dest, int destOffset, int destBitOffset, int numSamples)
Copies a number of bit values from one byte array to another.
static void
decodePacked1Bit(byte[] src, int srcOffset, byte[] dest, int destOffset, int numPackedBytes)
static void
decodePacked2Bit(byte[] src, int srcOffset, byte[] dest, int destOffset, int numPackedBytes)
Decodes bytes with four two-bit samples to single bytes.
static void
decodePacked4Bit(byte[] src, int srcOffset, byte[] dest, int destOffset, int numPackedBytes)
Decodes bytes with two four-bit samples to single bytes.
static void
decodePackedRGB565BigEndianToRGB24(byte[] src, int srcOffset, byte[] red, int redOffset, byte[] green, int greenOffset, byte[] blue, int blueOffset, int numPixels)
Convert 16 bit RGB samples stored in big endian (BE) byte order with 5 bits for red and blue and 6 bits for green to 24 bit RGB byte samples.
static void
encodePacked2Bit(byte[] src, int srcOffset, byte[] dest, int destOffset, int numSamples)
static void
encodePacked4Bit(byte[] src, int srcOffset, byte[] dest, int destOffset, int numSamples)
static void
encodeRGB24ToPackedRGB565BigEndian(byte[] red, int redOffset, byte[] green, int greenOffset, byte[] blue, int blueOffset, byte[] dest, int destOffset, int numPixels)
Convert 24 bit RGB pixels to 16 bit pixels stored in big endian (BE) byte order with 5 bits for red and blue and 6 bits for green.
static int
getIntBE(byte[] src, int srcOffset)
Reads four consecutive bytes from the given array at the given position in big endian order and returns them as an int.
static int
getIntLE(byte[] src, int srcOffset)
Reads four consecutive bytes from the given array at the given position in little endian order and returns them as an int.
static short
getShortBE(byte[] src, int srcOffset)
Reads two consecutive bytes from the given array at the given position in big endian order and returns them as a short.
static int
getShortBEAsInt(byte[] src, int srcOffset)
static short
getShortLE(byte[] src, int srcOffset)
Reads two consecutive bytes from the given array at the given position in little endian order and returns them as a short.
static void
setIntBE(byte[] dest, int destOffset, int newValue)
Writes an int value into four consecutive bytes of a byte array, in big endian (network) byte order.
static void
setIntLE(byte[] dest, int destOffset, int newValue)
Writes an int value into four consecutive bytes of a byte array, in little endian (Intel) byte order.
static void
setShortBE(byte[] dest, int destOffset, short newValue)
static void
setShortLE(byte[] dest, int destOffset, short newValue)

Field Details

INT_SIZE

private static final int INT_SIZE
Field Value:
4

SHORT_SIZE

private static final int SHORT_SIZE
Field Value:
2

Constructor Details

ArrayConverter

private ArrayConverter()

Method Details

checkArray

private static void checkArray(byte[] array,
                               int offset,
                               int length)
            throws IllegalArgumentException
Makes sure that the arguments define a valid (existing) array interval. This includes:
  • array is non-null
  • offset is >= 0 and smaller than array.length
  • length is > 0
  • offset + length is <= array.length

convertPacked2BitIntensityTo8Bit

public static void convertPacked2BitIntensityTo8Bit(byte[] src,
                                                    int srcOffset,
                                                    byte[] dest,
                                                    int destOffset,
                                                    int numPackedBytes)
Parameters:
src - byte array, each byte stores four two-bit intensity values
srcOffset - index into src
dest - byte array, each byte stores an eight-bit intensity values
destOffset - index into dest
numPackedBytes - number of bytes in src to be decoded

convertPacked4BitIntensityTo8Bit

public static void convertPacked4BitIntensityTo8Bit(byte[] src,
                                                    int srcOffset,
                                                    byte[] dest,
                                                    int destOffset,
                                                    int numPackedBytes)
Converts bytes with four two-bit-intensity samples to byte-sized intensity values. Four-bit values can be from 0 to 15. These values will be scaled to the full [0;255] range so that 0 remains 0, 1 becomes 17, 2 becomes 34, ..., and 15 becomes 255. The most significant four bits in a byte become the left, the least significant four bits the right pixel.
Parameters:
src - byte array, each byte stores two four-bit intensity values
srcOffset - index into src
dest - byte array, each byte stores an eight-bit intensity values
destOffset - index into dest
numPackedBytes - number of bytes in src to be decoded
Since:
0.12.0

copyPackedBytes

public static void copyPackedBytes(byte[] src,
                                   int srcOffset,
                                   int srcBitOffset,
                                   byte[] dest,
                                   int destOffset,
                                   int destBitOffset,
                                   int numSamples)
Copies a number of bit values from one byte array to another.
Parameters:
src - array from which is copied
srcOffset - index into the src array of the first byte from which is copied
srcBitOffset - first bit within src[srcOffset] from which is copied (0 is left-most, 1 is second left-most, 7 is right-most)
dest - array to which is copied
destOffset - index into the dest array of the first byte to which is copied
destBitOffset - first bit within dest[destOffset] to which is copied (0 is left-most, 1 is second left-most, 7 is right-most)
numSamples - number of bits to be copied

decodePacked1Bit

public static void decodePacked1Bit(byte[] src,
                                    int srcOffset,
                                    byte[] dest,
                                    int destOffset,
                                    int numPackedBytes)

decodePacked2Bit

public static void decodePacked2Bit(byte[] src,
                                    int srcOffset,
                                    byte[] dest,
                                    int destOffset,
                                    int numPackedBytes)
Decodes bytes with four two-bit samples to single bytes. The two most significant bits of a source byte become the first value, the two least significant bits the fourth value. The method expects numPackedBytes bytes at src[srcOffset] (these will be read and interpreted) and numPackedBytes * 4 at dest[destOffset] (where the decoded byte values will be stored.

Parameters:
src - byte array, each byte stores four two-bit values
srcOffset - index into src
dest - byte array, each byte stores a single decoded value (from 0 to 3)
destOffset - index into dest
numPackedBytes - number of bytes in src to be decoded
Since:
0.10.0

decodePacked4Bit

public static void decodePacked4Bit(byte[] src,
                                    int srcOffset,
                                    byte[] dest,
                                    int destOffset,
                                    int numPackedBytes)
Decodes bytes with two four-bit samples to single bytes. The four most significant bits of a source byte become the first value, the least significant four bits the second value. The method expects numPackedBytes bytes at src[srcOffset] (these will be read and interpreted) and numPackedBytes * 2 at dest[destOffset] (where the decoded byte values will be stored.

Parameters:
src - byte array, each byte stores two four-bit values
srcOffset - index into src
dest - byte array, each byte stores a single decoded value
destOffset - index into dest
numPackedBytes - number of bytes in src to be decoded

decodePackedRGB565BigEndianToRGB24

public static void decodePackedRGB565BigEndianToRGB24(byte[] src,
                                                      int srcOffset,
                                                      byte[] red,
                                                      int redOffset,
                                                      byte[] green,
                                                      int greenOffset,
                                                      byte[] blue,
                                                      int blueOffset,
                                                      int numPixels)
Convert 16 bit RGB samples stored in big endian (BE) byte order with 5 bits for red and blue and 6 bits for green to 24 bit RGB byte samples.
Since:
0.10.0

encodePacked2Bit

public static void encodePacked2Bit(byte[] src,
                                    int srcOffset,
                                    byte[] dest,
                                    int destOffset,
                                    int numSamples)

encodePacked4Bit

public static void encodePacked4Bit(byte[] src,
                                    int srcOffset,
                                    byte[] dest,
                                    int destOffset,
                                    int numSamples)

encodeRGB24ToPackedRGB565BigEndian

public static void encodeRGB24ToPackedRGB565BigEndian(byte[] red,
                                                      int redOffset,
                                                      byte[] green,
                                                      int greenOffset,
                                                      byte[] blue,
                                                      int blueOffset,
                                                      byte[] dest,
                                                      int destOffset,
                                                      int numPixels)
Convert 24 bit RGB pixels to 16 bit pixels stored in big endian (BE) byte order with 5 bits for red and blue and 6 bits for green.
Since:
0.10.0

getIntBE

public static int getIntBE(byte[] src,
                           int srcOffset)
Reads four consecutive bytes from the given array at the given position in big endian order and returns them as an int.
Parameters:
src - the array from which bytes are read
srcOffset - the index into the array from which the bytes are read
Returns:
int value taken from the array

getIntLE

public static int getIntLE(byte[] src,
                           int srcOffset)
Reads four consecutive bytes from the given array at the given position in little endian order and returns them as an int.
Parameters:
src - the array from which bytes are read
srcOffset - the index into the array from which the bytes are read
Returns:
short value taken from the array

getShortBE

public static short getShortBE(byte[] src,
                               int srcOffset)
Reads two consecutive bytes from the given array at the given position in big endian order and returns them as a short.
Parameters:
src - the array from which two bytes are read
srcOffset - the index into the array from which the two bytes are read
Returns:
short value taken from the array

getShortBEAsInt

public static int getShortBEAsInt(byte[] src,
                                  int srcOffset)

getShortLE

public static short getShortLE(byte[] src,
                               int srcOffset)
Reads two consecutive bytes from the given array at the given position in little endian order and returns them as a short.
Parameters:
src - the array from which two bytes are read
srcOffset - the index into the array from which the two bytes are read
Returns:
short value taken from the array

setIntBE

public static void setIntBE(byte[] dest,
                            int destOffset,
                            int newValue)
Writes an int value into four consecutive bytes of a byte array, in big endian (network) byte order.
Parameters:
dest - the array to which bytes are written
destOffset - index of the array to which the first byte is written
newValue - the int value to be written to the array

setIntLE

public static void setIntLE(byte[] dest,
                            int destOffset,
                            int newValue)
Writes an int value into four consecutive bytes of a byte array, in little endian (Intel) byte order.
Parameters:
dest - the array to which bytes are written
destOffset - index of the array to which the first byte is written
newValue - the int value to be written to the array

setShortBE

public static void setShortBE(byte[] dest,
                              int destOffset,
                              short newValue)

setShortLE

public static void setShortLE(byte[] dest,
                              int destOffset,
                              short newValue)