content: // =================================================================================================
  // ADOBE SYSTEMS INCORPORATED
  // Copyright 2001 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.internal.xmp.impl;
  
  
  
  
  /**
   * A utility class to perform base64 encoding and decoding as specified
   * in RFC-1521. See also RFC 1421.
   *
   * @author      Mike P. Tardif
   * @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()));
  	}
  }
  