encode(source, 0, source.length).
*
* @param src the data to convert.
*/
public static final String encode(final byte[] src)
{
return encode(src, 0, src.length, true);
}
/**
* Encodes a byte array into Base64 notation.
*
* @param src the data to convert.
* @param off offset in array where conversion should begin.
* @param len length of data to convert.
* @param breakLines break lines at 80 characters or less.
*/
public static final String encode(final byte[] src, final int off,
final int len, final boolean breakLines)
{
final int len43 = len * 4 / 3;
final byte[] outBuff = new byte[len43 // Main 4:3
+ ((len % 3) > 0 ? 4 : 0) // Account for padding
+ (breakLines ? (len43 / MAX_LINE_LENGTH)
: 0)]; // New lines
int d = 0;
int e = 0;
final int len2 = len - 2;
int lineLength = 0;
for (; d < len2; d += 3, e += 4)
{
encode3to4(src, d + off, 3, outBuff, e);
lineLength += 4;
if (breakLines && lineLength == MAX_LINE_LENGTH)
{
outBuff[e + 4] = NEW_LINE;
e++;
lineLength = 0;
}
}
if (d < len)
{ // padding needed
encode3to4(src, d + off, len - d, outBuff, e);
e += 4;
}
return new String(outBuff, 0, e);
}
/**
* Decodes data from Base64 notation.
*
* @param s the string to decode.
* @return the decoded data.
*/
public static final byte[] decode(final String s)
throws UnsupportedEncodingException
{
final byte[] bytes;
bytes = s.getBytes("US-ASCII");
return decode(bytes, 0, bytes.length);
}
/**
* Decodes Base64 content in byte array format and returns the decoded byte
* array.
*
* @param src the Base64 encoded data.
* @param off the offset of where to begin decoding.
* @param len the length of characters to decode.
* @return the decoded data.
* @throws IllegalArgumentException if src contains an illegal
* Base-64 character.
*/
public static byte[] decode(final byte[] src, final int off, final int len)
{
final int len34 = len * 3 / 4;
final byte[] outBuff = new byte[len34]; // Upper limit on size of output
int outBuffPosn = 0;
final byte[] b4 = new byte[4];
int b4Posn = 0;
int i;
byte sbiCrop, sbiDecode;
for (i = off; i < off + len; i++)
{
sbiCrop = (byte) (src[i] & 0x7F); // Only the low seven bits
sbiDecode = DECODABET[sbiCrop];
if (sbiDecode >= WHITE_SPACE_ENC)
{ // White space, Equals sign or better
if (sbiDecode >= EQUALS_SIGN_ENC)
{
b4[b4Posn++] = sbiCrop;
if (b4Posn > 3)
{
outBuffPosn += decode4to3(b4, 0, outBuff, outBuffPosn);
b4Posn = 0;
// If that was the equals sign, break out of 'for' loop
if (sbiCrop == EQUALS_SIGN)
break;
} // end if: quartet built
} // end if: equals sign or better
}
else
{
throw new IllegalArgumentException("Illegal BASE-64 character at #"
+ i + ": " + src[i]
+ "(decimal)");
}
}
final byte[] result = new byte[outBuffPosn];
System.arraycopy(outBuff, 0, result, 0, outBuffPosn);
return result;
}
/**
* Encodes up to three bytes of the array src and writes
* the resulting four Base64 bytes to dest. The source and
* destination arrays can be manipulated anywhere along their length by
* specifying sOffset and dOffset.
This method does not check to make sure the arrays are large enough to
* accomodate sOffset + 3 for the src array or
* dOffset + 4 for the dest array. The actual
* number of significant bytes in the input array is given by
* numBytes.
destination array.
*/
private static final byte[] encode3to4(final byte[] src, final int sOffset,
final int numBytes, final byte[] dest,
final int dOffset)
{
// 1 2 3
// 01234567890123456789012345678901 Bit position
// --------000000001111111122222222 Array position from threeBytes
// --------| || || || | Six bit groups to index ALPHABET
// >>18 >>12 >> 6 >> 0 Right shift necessary
// 0x3F 0x3F 0x3F Additional AND
// Create buffer with zero-padding if there are only one or two
// significant bytes passed in the array.
// We have to shift left 24 in order to flush out the 1's that appear
// when Java treats a value as negative that is cast from a byte to an int.
final int inBuff = (numBytes > 0 ? ((src[sOffset] << 24) >>> 8) : 0)
| (numBytes > 1 ? ((src[sOffset + 1] << 24) >>> 16) : 0)
| (numBytes > 2 ? ((src[sOffset + 2] << 24) >>> 24) : 0);
switch (numBytes)
{
case 3:
dest[dOffset] = ALPHABET[(inBuff >>> 18)];
dest[dOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3F];
dest[dOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3F];
dest[dOffset + 3] = ALPHABET[(inBuff) & 0x3F];
break;
case 2:
dest[dOffset] = ALPHABET[(inBuff >>> 18)];
dest[dOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3F];
dest[dOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3F];
dest[dOffset + 3] = EQUALS_SIGN;
break;
case 1:
dest[dOffset] = ALPHABET[(inBuff >>> 18)];
dest[dOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3F];
dest[dOffset + 2] = EQUALS_SIGN;
dest[dOffset + 3] = EQUALS_SIGN;
break;
}
return dest;
}
/**
* Decodes four bytes from array src and writes the
* resulting bytes (up to three of them) to dest.
The source and destination arrays can be manipulated anywhere along
* their length by specifying sOffset and dOffset.
*
This method does not check to make sure your arrays are large enough
* to accomodate sOffset + 4 for the src array or
* dOffset + 3 for the dest array. This method
* returns the actual number of bytes that were converted from the Base64
* encoding.