Base64的编解码原理很简单，下面是编解码的部分核心代码：
编码：
/**
* 编码
* data : byte数组
* realLength : 数组长度
* offset : 偏移量
* length : 从偏移量开始截取的长度
* flag : 选项
*/
EncodeData *encode(const char *data, int realLength, int offset, int length, int flag) {
/* 将字符串数据转换成ascii码，再将ascii码变成二进制表示，
* 将二进制中每3个8位的数据转换成4个6位的数据，
* 并且在6位的数据前加‘00’，最终变成4个8位，
* 操作完的4个8位二进制再变成4个十进制数字，并根据数字对应的base64表获取编码，
* 如果不满足3个8位，则在其后补0直至到3个8位，再分割成4个6位，其中补完的数据用'='表示*/
/*android的base64库中，默认换行用/n，不用/r/n*/
/* e.g
* char : 's'
* binary : 01110011
* split : 011100 | 11
* complete 0 : 011100 | 110000 | 000000 | 000000
* add 0 to head : 00011100 | 00110000 | 00000000 | 00000000
* decimal : 28 | 48 | 64(complete) | 64(complete)
* encode : c | w | = | =
* result : cw==
* */
EncodeData *encodeData = (EncodeData *) malloc(sizeof(EncodeData));
Flags *flags = getFlags(flag);//根据选项值获取对应选项
const char *table = flags->isUrlSafe ? ENCODE_WEB_TABLE : ENCODE_TABLE;
char *p;//活动指针，用于循环取数据
char temp1, temp2, temp3;//辅助取数
int encodeLength = getEncodeLength(realLength, length, flags);
encodeData->data = p = (char *) malloc(encodeLength * sizeof(char));
int i;
int count = LINE_GROUPS;
int len = realLength;
if (length != LEN_DEFAULT)
len = length;
len += offset;
for (i = offset; i < len; i += 3) {
bool isSecondCharEmpty = (i + 1 >= len);
bool isThirdCharEmpty = (i + 2 >= len);
//每次增长3个，若能进入循环，第一个字节肯定存在
temp1 = data[i];
temp2 = isSecondCharEmpty ? 0 : data[i + 1];
temp3 = isThirdCharEmpty ? 0 : data[i + 2];
//第一个转码取第一个字节的前6位，再通过0x3F(0011 1111)提取出
*(p++) = table[(temp1 >> 2) & 0x3F];
//第二个转码取第一个字节的7、8位(0x3F)和第二个字节的前4位(0x0F)
*(p++) = table[((temp1 << 4) & 0x3F) + ((temp2 >> 4) & 0x0F)];
//第三个转码取第二个字节的5、6、7、8位(0x3C)和第三个字节的前2位(0x03)
//假设只有一个字节，那么必定可以转换出第一、二个转码，所以只需要判断第二个字节是否为空
//若第二字节为空，则用‘=’（64）号代替
if (isSecondCharEmpty && flags->isPadding)
*(p++) = table[64];
else if (!isSecondCharEmpty)
*(p++) = table[(((temp2 << 2) & 0x3C) + ((temp3 >> 6) & 0x03))];
//第四个转码直接取第三个字节的后6位即可
if (isThirdCharEmpty && flags->isPadding)
*(p++) = table[64];
else if (!isThirdCharEmpty)
*(p++) = table[(temp3 & 0x3F)];
if (flags->isWrap && (--count) == 0) {
if (flags->isCRLF) *(p++) = '\r';
*(p++) = '\n';
count = LINE_GROUPS;
}
}
if (flags->isWrap) {
if (flags->isCRLF) *(p++) = '\r';
*p = '\n';//最后要加结束符号
}
free(flags);
encodeData->length = encodeLength;
return encodeData;
}
编码部分用unit test里简略的运行时间统计，速度大概比原来android方法20%左右
/**
* 另一种方法解码，不预先计算解码长度
*/
DecodeData *decodeLikeAndroid(const char *data, int realLength, int offset, int length, int flag) {
DecodeData *decodeData = (DecodeData *) malloc(sizeof(DecodeData));
const int *table;
if (flag & URL_SAFE)
table = DECODE_WEB_TABLE;
else
table = DECODE_TABLE;
int value;
char c;
int index = offset;
int len = realLength;
if (length != LEN_DEFAULT)
len = length;
len += offset;
decodeData->data = (char *) malloc(sizeof(char) * len);
int decodeLength = 0;
int state = 0;//记录状态
//最后还是用了android源码里的解决方法
//因为解码数据中可能存在多种被无效数据（如头文件里解码表中的-1、-2）污染的情况
//自己写过2种方法，效果不理想
while (index < len) {
if (state == 0) {
while (index + 4 <= len && (value = (table[data[index]] << 18) |
(table[data[index + 1]] << 12) |
(table[data[index + 2]] << 6) |
(table[data[index + 3]])) >= 0) {
decodeData->data[decodeLength++] = (value >> 16);
decodeData->data[decodeLength++] = (value >> 8);
decodeData->data[decodeLength++] = value;
// //第一个解码取第一个字节的第2~8位，第二个字节的第3~4位
// decodeData->data[decodeLength++] = (temp1 << 2) + (temp2 >> 4);
// //第二个解码取第二个字节的后4位，第三个字节的第2~6位
// decodeData->data[decodeLength++] = (temp2 << 4) + (temp3 >> 2);
// //第三个解码取第三个字节的后2位，第四个字节的第0~6位
// decodeData->data[decodeLength++] = (temp3 << 6) + temp4;
index += 4;
}
if (index >= len)
break;
}
c = table[data[index++]];
switch (state) {
case 0:
if (c < DECODE_EQUALS) {
value = c;
++state;
} else if (c != DECODE_SKIP)
return getErrorDecodeData(decodeData);
break;
case 1:
if (c < DECODE_EQUALS) {
value = (value << 6) | c;
++state;
} else if (c != DECODE_SKIP)
return getErrorDecodeData(decodeData);
break;
case 2:
if (c < DECODE_EQUALS) {
value = (value << 6) | c;
++state;
} else if (c == DECODE_EQUALS) {
decodeData->data[decodeLength++] = (value >> 4);
// //第一个解码取第一个字节的第2~8位，第二个字节的第3~4位
// decodeData->data[decodeLength++] = (temp1 << 2) + (temp2 >> 4);
state = 4;
} else if (c != DECODE_SKIP)
return getErrorDecodeData(decodeData);
break;
case 3:
if (c < DECODE_EQUALS) {
value = (value << 6) | c;
decodeData->data[decodeLength++] = (value >> 16);
decodeData->data[decodeLength++] = (value >> 8);
decodeData->data[decodeLength++] = value;
state = 0;
} else if (c == DECODE_EQUALS) {
decodeData->data[decodeLength++] = (value >> 10);
decodeData->data[decodeLength++] = (value >> 2);
state = 5;
} else if (c != DECODE_SKIP)
return getErrorDecodeData(decodeData);
break;
case 4:
if (c == DECODE_EQUALS) {
++state;
} else if (c != DECODE_SKIP)
return getErrorDecodeData(decodeData);
break;
case 5:
if (c != DECODE_SKIP)
return getErrorDecodeData(decodeData);
break;
}
}
//跳出while循环后
switch (state) {
case 0:
break;
case 1:
return getErrorDecodeData(decodeData);
case 2:
decodeData->data[decodeLength++] = (value >> 4);
break;
case 3:
decodeData->data[decodeLength++] = (value >> 10);
decodeData->data[decodeLength++] = (value >> 2);
break;
case 4:
return getErrorDecodeData(decodeData);
case 5:
break;
}
decodeData->length = decodeLength;
return decodeData;
}
注意的是，解码部分还是用了android源码中Base64的解码方法，原因是在解码中会出现解码数据被无效字符污染的情况，暂时没想到好的思路。
结果倒是很有意思，我在单元测试里写了简单的统计运行时间，结果解码时间比android提供的Base64方法还要慢一些（大数据量、10000次左右的循环）。
想到好的思路再修改了
修改了解码拼接字符部分，现在在同一测试中的运行时间基本与android方法持平（最多快1%）
另外，代码里写了一个计算解码后数据长度的方法，适合统计数据源里没有污染情况下的解码长度：
/**
* 计算解码后的数据长度
*/
int getDecodeLength(const char *data, int realLength, int offset, int length, Flags *flags) {
char log[256];
int decodeLength = 0;
int tempLength = realLength;
if (length != LEN_DEFAULT)
tempLength = length;
sprintf(log, "tempLength:%d", tempLength);
LOGV(log);
//当数据应该有'='存在时，数据长度少于4，则无法被解码
//反之，不应该存在'='时，数据长度少于2，则同上
if (flags->isPadding && tempLength < 4) {
return -1;
} else if (!flags->isPadding && tempLength < 2) {
return -2;
}
//计算数据尾部的换行符占位数（若存在）
int endSpace = 0;
if (length == LEN_DEFAULT || (length + offset == realLength)) {
if (flags->isCRLF) {
if (data[realLength - 2] == '\r')
endSpace = 2;
} else if (data[realLength - 1] == '\n')
endSpace = 1;
}
sprintf(log, "endSpace:%d", endSpace);
LOGV(log);
//计算换行符个数
int enters = 0;
if (flags->isWrap) {
enters = tempLength / (flags->isCRLF ? 78 : 77);
}
sprintf(log, "enters:%d", enters);
LOGV(log);
tempLength -= endSpace;
decodeLength = tempLength;
int t = tempLength - enters;
tempLength = t >= 0 ? t : tempLength;
bool isRemainder = false;
int equals = 0;//记录'='号个数（若存在）
int remainder = 0;//记录余数（若存在）
sprintf(log, "tempLength--:%d", tempLength);
LOGV(log);
/*
* 多判断一层，存在padding时，解码数据不足4位且不能被4整除的throw exception，
* 不存在padding时，最少解码数据是2位，数据不能被4整除时，若余数为1、2，则数据完整可被解码
*/
if (flags->isPadding) {
if (tempLength % 4 != 0) {
return -3;
}
if (data[decodeLength - 2] == '=') {
equals = 2;
isRemainder = true;
}
else if (data[decodeLength - 1] == '=') {
equals = 1;
isRemainder = true;
}
} else {
int d = tempLength % 4;
if (d > 2) {
return -4;
} else if (d != 0) {
remainder = d;
isRemainder = true;
}
}
if (isRemainder) {
decodeLength -= enters;
decodeLength += remainder;
decodeLength = decodeLength * DECODE_CONST - 3;
decodeLength += (3 - equals);
} else {
decodeLength -= enters;
decodeLength = decodeLength * DECODE_CONST;
}
sprintf(log, "decodeLength--:%d", decodeLength);
LOGV(log);
return decodeLength;
}
获取编码后长度的方法也有，思路简单很多：
/**
* 计算、获取编码长度
*/
int getEncodeLength(int realLength, int length, Flags *flags) {
//编码后的长度计算：3×8=4×6->4×8
int tempLength = realLength;
if (length != LEN_DEFAULT)
tempLength = length;
int encodeLength = 0;
if (realLength > 0) {
int remainder = tempLength % 3;
encodeLength = (remainder == 0 ? ((tempLength / 3) << 2) : (((tempLength / 3) + 1) << 2));
if (flags->isWrap) {
if (!flags->isCRLF) //编码后每76个字符插入'\n'换行
encodeLength = encodeLength + 1 + encodeLength / LINE_CHARS;
else //编码后每76个字符插入'\r\n'换行
encodeLength = encodeLength + (1 + encodeLength / LINE_CHARS) * 2;
}
//没有padding，不需要在后面补'='
if (!flags->isPadding && remainder > 0)
encodeLength -= (3 - remainder);
}
return encodeLength;
}
具体的代码已上传到github：https://github.com/ViTess/Android-Base64