Here you can find the source of base64Decode(char[] a_data)
| Parameter | Description |
|---|---|
| a_data | data to decode. |
public static byte[] base64Decode(char[] a_data)
//package com.java2s; /*/* w ww . ja va2s .co m*/ * Copyright 2006-2012 The Scriptella Project Team. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ public class Main { /** lookup table for converting base64 characters to value in range 0..63 */ private static byte[] s_codes = new byte[256]; /** * Decodes a BASE-64 encoded stream to recover the original data. White * space before and after will be trimmed away, but no other manipulation of * the input will be performed. As of version 1.2 this method will properly * handle input containing junk characters (newlines and the like) rather * than throwing an error. It does this by pre-parsing the input and * generating from that a count of VALID input characters. * * @param a_data * data to decode. * @return the decoded binary data. */ public static byte[] base64Decode(char[] a_data) { // as our input could contain non-BASE64 data (newlines, // whitespace of any sort, whatever) we must first adjust // our count of USABLE data so that... // (a) we don't misallocate the output array, and // (b) think that we miscalculated our data length // just because of extraneous throw-away junk int l_tempLen = a_data.length; for (char anA_data1 : a_data) { if ((anA_data1 > 255) || s_codes[anA_data1] < 0) { --l_tempLen; // ignore non-valid chars and padding } } // calculate required length: // -- 3 bytes for every 4 valid base64 chars // -- plus 2 bytes if there are 3 extra base64 chars, // or plus 1 byte if there are 2 extra. int l_len = (l_tempLen / 4) * 3; if ((l_tempLen % 4) == 3) { l_len += 2; } if ((l_tempLen % 4) == 2) { l_len += 1; } byte[] l_out = new byte[l_len]; int l_shift = 0; // # of excess bits stored in accum int l_accum = 0; // excess bits int l_index = 0; // we now go through the entire array (NOT using the 'tempLen' value) for (char anA_data : a_data) { int l_value = (anA_data > 255) ? -1 : s_codes[anA_data]; if (l_value >= 0) // skip over non-code { l_accum <<= 6; // bits shift up by 6 each time thru l_shift += 6; // loop, with new bits being put in l_accum |= l_value; // at the bottom. whenever there if (l_shift >= 8) // are 8 or more shifted in, write them { l_shift -= 8; // out (from the top, leaving any excess l_out[l_index++] = // at the bottom for next iteration. (byte) ((l_accum >> l_shift) & 0xff); } } // we will also have skipped processing a padding null byte ('=') // here; // these are used ONLY for padding to an even length and do not // legally // occur as encoded data. for this reason we can ignore the fact // that // no index++ operation occurs in that special case: the out[] array // is // initialized to all-zero bytes to start with and that works to our // advantage in this combination. } // if there is STILL something wrong we just have to throw up now! if (l_index != l_out.length) { throw new Error("Miscalculated data length (wrote " + l_index + " instead of " + l_out.length + ")"); } return l_out; } }