diff options
Diffstat (limited to 'java/XMPCore/src/com/adobe/xmp/impl/Base64.java')
| -rw-r--r-- | java/XMPCore/src/com/adobe/xmp/impl/Base64.java | 251 |
1 files changed, 251 insertions, 0 deletions
diff --git a/java/XMPCore/src/com/adobe/xmp/impl/Base64.java b/java/XMPCore/src/com/adobe/xmp/impl/Base64.java new file mode 100644 index 0000000..c47d08c --- /dev/null +++ b/java/XMPCore/src/com/adobe/xmp/impl/Base64.java @@ -0,0 +1,251 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2001-2005 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +package com.adobe.xmp.impl; + + + + +/** + * A utility class to perform base64 encoding and decoding as specified + * in RFC-1521. See also RFC 1421. + * + * @version $Revision: 1.4 $ + */ +public class Base64 +{ + /** marker for invalid bytes */ + private static final byte INVALID = -1; + /** marker for accepted whitespace bytes */ + private static final byte WHITESPACE = -2; + /** marker for an equal symbol */ + private static final byte EQUAL = -3; + + /** */ + private static byte[] base64 = { + (byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', // 0 to 3 + (byte) 'E', (byte) 'F', (byte) 'G', (byte) 'H', // 4 to 7 + (byte) 'I', (byte) 'J', (byte) 'K', (byte) 'L', // 8 to 11 + (byte) 'M', (byte) 'N', (byte) 'O', (byte) 'P', // 11 to 15 + (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T', // 16 to 19 + (byte) 'U', (byte) 'V', (byte) 'W', (byte) 'X', // 20 to 23 + (byte) 'Y', (byte) 'Z', (byte) 'a', (byte) 'b', // 24 to 27 + (byte) 'c', (byte) 'd', (byte) 'e', (byte) 'f', // 28 to 31 + (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j', // 32 to 35 + (byte) 'k', (byte) 'l', (byte) 'm', (byte) 'n', // 36 to 39 + (byte) 'o', (byte) 'p', (byte) 'q', (byte) 'r', // 40 to 43 + (byte) 's', (byte) 't', (byte) 'u', (byte) 'v', // 44 to 47 + (byte) 'w', (byte) 'x', (byte) 'y', (byte) 'z', // 48 to 51 + (byte) '0', (byte) '1', (byte) '2', (byte) '3', // 52 to 55 + (byte) '4', (byte) '5', (byte) '6', (byte) '7', // 56 to 59 + (byte) '8', (byte) '9', (byte) '+', (byte) '/' // 60 to 63 + }; + /** */ + private static byte[] ascii = new byte[255]; + /** */ + static { + // not valid bytes + for (int idx = 0; idx < 255; idx++) + { + ascii[idx] = INVALID; + } + // valid bytes + for (int idx = 0; idx < base64.length; idx++) + { + ascii[base64[idx]] = (byte) idx; + } + // whitespaces + ascii[0x09] = WHITESPACE; + ascii[0x0A] = WHITESPACE; + ascii[0x0D] = WHITESPACE; + ascii[0x20] = WHITESPACE; + + // trailing equals + ascii[0x3d] = EQUAL; + } + + + /** + * Encode the given byte[]. + * + * @param src the source string. + * @return the base64-encoded data. + */ + public static final byte[] encode(byte[] src) + { + return encode(src, 0); + } + + + /** + * Encode the given byte[]. + * + * @param src the source string. + * @param lineFeed a linefeed is added after <code>linefeed</code> characters; + * must be dividable by four; 0 means no linefeeds + * @return the base64-encoded data. + */ + public static final byte[] encode(byte[] src, int lineFeed) + { + // linefeed must be dividable by 4 + lineFeed = lineFeed / 4 * 4; + if (lineFeed < 0) + { + lineFeed = 0; + } + + // determine code length + int codeLength = ((src.length + 2) / 3) * 4; + if (lineFeed > 0) + { + codeLength += (codeLength - 1) / lineFeed; + } + + byte[] dst = new byte[codeLength]; + int bits24; + int bits6; + // + // Do 3-byte to 4-byte conversion + 0-63 to ascii printable conversion + // + int didx = 0; + int sidx = 0; + int lf = 0; + while (sidx + 3 <= src.length) + { + bits24 = (src[sidx++] & 0xFF) << 16; + bits24 |= (src[sidx++] & 0xFF) << 8; + bits24 |= (src[sidx++] & 0xFF) << 0; + bits6 = (bits24 & 0x00FC0000) >> 18; + dst[didx++] = base64[bits6]; + bits6 = (bits24 & 0x0003F000) >> 12; + dst[didx++] = base64[bits6]; + bits6 = (bits24 & 0x00000FC0) >> 6; + dst[didx++] = base64[bits6]; + bits6 = (bits24 & 0x0000003F); + dst[didx++] = base64[bits6]; + + lf += 4; + if (didx < codeLength && lineFeed > 0 && lf % lineFeed == 0) + { + dst[didx++] = 0x0A; + } + } + if (src.length - sidx == 2) + { + bits24 = (src[sidx ] & 0xFF) << 16; + bits24 |= (src[sidx + 1] & 0xFF) << 8; + bits6 = (bits24 & 0x00FC0000) >> 18; + dst[didx++] = base64[bits6]; + bits6 = (bits24 & 0x0003F000) >> 12; + dst[didx++] = base64[bits6]; + bits6 = (bits24 & 0x00000FC0) >> 6; + dst[didx++] = base64[bits6]; + dst[didx++] = (byte) '='; + } + else if (src.length - sidx == 1) + { + bits24 = (src[sidx] & 0xFF) << 16; + bits6 = (bits24 & 0x00FC0000) >> 18; + dst[didx++] = base64[bits6]; + bits6 = (bits24 & 0x0003F000) >> 12; + dst[didx++] = base64[bits6]; + dst[didx++] = (byte) '='; + dst[didx++] = (byte) '='; + } + return dst; + } + + + /** + * Encode the given string. + * @param src the source string. + * @return the base64-encoded string. + */ + public static final String encode(String src) + { + return new String(encode(src.getBytes())); + } + + + /** + * Decode the given byte[]. + * + * @param src + * the base64-encoded data. + * @return the decoded data. + * @throws IllegalArgumentException Thrown if the base 64 strings contains non-valid characters, + * beside the bas64 chars, LF, CR, tab and space are accepted. + */ + public static final byte[] decode(byte[] src) throws IllegalArgumentException + { + // + // Do ascii printable to 0-63 conversion. + // + int sidx; + int srcLen = 0; + for (sidx = 0; sidx < src.length; sidx++) + { + byte val = ascii[src[sidx]]; + if (val >= 0) + { + src[srcLen++] = val; + } + else if (val == INVALID) + { + throw new IllegalArgumentException("Invalid base 64 string"); + } + } + + // + // Trim any padding. + // + while (srcLen > 0 && src[srcLen - 1] == EQUAL) + { + srcLen--; + } + byte[] dst = new byte[srcLen * 3 / 4]; + + // + // Do 4-byte to 3-byte conversion. + // + int didx; + for (sidx = 0, didx = 0; didx < dst.length - 2; sidx += 4, didx += 3) + { + dst[didx ] = (byte) (((src[sidx ] << 2) & 0xFF) + | ((src[sidx + 1] >>> 4) & 0x03)); + dst[didx + 1] = (byte) (((src[sidx + 1] << 4) & 0xFF) + | ((src[sidx + 2] >>> 2) & 0x0F)); + dst[didx + 2] = (byte) (((src[sidx + 2] << 6) & 0xFF) + | ((src[sidx + 3]) & 0x3F)); + } + if (didx < dst.length) + { + dst[didx] = (byte) (((src[sidx ] << 2) & 0xFF) + | ((src[sidx + 1] >>> 4) & 0x03)); + } + if (++didx < dst.length) + { + dst[didx] = (byte) (((src[sidx + 1] << 4) & 0xFF) + | ((src[sidx + 2] >>> 2) & 0x0F)); + } + return dst; + } + + + /** + * Decode the given string. + * + * @param src the base64-encoded string. + * @return the decoded string. + */ + public static final String decode(String src) + { + return new String(decode(src.getBytes())); + } +} |