net.sourceforge.jiu.util
Class ArrayConverter

java.lang.Object
  net.sourceforge.jiu.util.ArrayConverter

public class ArrayConverter

extends Object

Helper class with static methods to convert between byte arrays and primitive types. Useful for serialization.

Since:

0.9.0

Author:

Marco Schmidt

Method Summary

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)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

convertPacked2BitIntensityTo8Bit

public 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. Two-bit values can be 0, 1, 2 or 3. These values will be scaled to the full [0;255] range so that 0 remains 0, 1 becomes 85, 2 becomes 170 and 3 becomes 255.

A little discussion on how to implement this method was held in the German Java newsgroup de.comp.lang.java. The message I wrote to start the thread has the ID 1ef7du4vfqsd2pskb6jukut6pnhn87htt2@4ax.com. Read the thread at Google Groups.

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)