v3.2.1

1. 修复32位加密错误
2. 优化性能

app/build.gradle

@@ -11,8 +11,8 @@ android {
         applicationId "top.fumiama.base16384"
         minSdkVersion 23
         targetSdkVersion 31
-        versionCode 15
-        versionName '3.2'
+        versionCode 16
+        versionName '3.2.1'
         resConfigs "zh", "en"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

app/src/main/cpp/base14/32/base1432le.c

@@ -2,147 +2,178 @@
 //fumiama 20210408
 #include <stdio.h>
 #include <stdlib.h>
+#if defined(__linux__)
+#  include <endian.h>
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+#  include <sys/endian.h>
+#elif defined(__OpenBSD__)
+#  include <sys/types.h>
+#  define be16toh(x) betoh16(x)
+#  define be32toh(x) betoh32(x)
+#  define be64toh(x) betoh64(x)
+#elif defined(__MAC_10_0)
+#  define be16toh(x) ntohs(x)
+#  define be32toh(x) ntohl(x)
+#  define be64toh(x) ntohll(x)
+#  define htobe16(x) ntohs(x)
+#  define htobe32(x) htonl(x)
+#  define htobe64(x) htonll(x)
+#endif
 #include "base1432le.h"
 
 //#define DEBUG
 
 LENDAT* encode(const uint8_t* data, const int32_t len) {
-	LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
-	int32_t outlen = len / 7 * 8;
-	uint8_t offset = len % 7;
-	switch(offset) {	//算上偏移标志字符占用的2字节
-		case 0: break;
-		case 1: outlen += 4; break;
-		case 2:
-		case 3: outlen += 6; break;
-		case 4:
-		case 5: outlen += 8; break;
-		case 6: outlen += 10; break;
-		default: break;
-	}
+    LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
+    int32_t outlen = len / 7 * 8;
+    uint8_t offset = len % 7;
+    switch(offset) {	//算上偏移标志字符占用的2字节
+        case 0: break;
+        case 1: outlen += 4; break;
+        case 2:
+        case 3: outlen += 6; break;
+        case 4:
+        case 5: outlen += 8; break;
+        case 6: outlen += 10; break;
+        default: break;
+    }
 #ifdef DEBUG
-	printf("outlen: %llu, offset: %u, malloc: %llu\n", outlen, offset, outlen + 8);
+    printf("outlen: %llu, offset: %u, malloc: %llu\n", outlen, offset, outlen + 8);
 #endif
-	encd->data = (uint8_t*)malloc(outlen + 8);	//冗余的8B用于可能的结尾的覆盖
-	encd->len = outlen;
-	uint32_t* vals = (uint32_t*)(encd->data);
-	uint32_t n = 0;
-	int32_t i = 0;
-	for(; i <= len - 7; i += 7) {
-		register uint32_t sum = 0x0000003f & ((uint32_t)data[i] >> 2);
-		sum |= (((uint32_t)data[i + 1] << 6) | (data[i] << 14)) & 0x0000ff00;
-		sum |= (((uint32_t)data[i + 1] << 20) | ((uint32_t)data[i + 2] << 12)) & 0x003f0000;
-		sum |= (((uint32_t)data[i + 2] << 28) | ((uint32_t)data[i + 3] << 20)) & 0xff000000;
-		sum += 0x004e004e;
-		vals[n++] = sum;
-#ifdef DEBUG
-		printf("n: %u, add sum: %08x\n", n, sum);
+    encd->data = (uint8_t*)malloc(outlen + 8);	//冗余的8B用于可能的结尾的覆盖
+    encd->len = outlen;
+    uint32_t* vals = (uint32_t*)(encd->data);
+    uint32_t n = 0;
+    int32_t i = 0;
+    for(; i <= len - 7; i += 7) {
+        register uint32_t sum = 0;
+        register uint32_t shift = htobe32(*(uint32_t*)(data+i));
+        sum |= (shift>>2) & 0x3fff0000;
+        sum |= (shift>>4) & 0x00003fff;
+        sum += 0x4e004e00;
+        vals[n++] = be32toh(sum);
+        shift <<= 26;
+        shift &= 0x3c000000;
+        sum = 0;
+        shift |= (htobe32(*(uint32_t*)(data+i+4))>>6)&0x03fffffc;
+        sum |= shift & 0x3fff0000;
+        shift >>= 2;
+        sum |= shift & 0x00003fff;
+        sum += 0x4e004e00;
+        vals[n++] = be32toh(sum);
+    }
+    uint8_t o = offset;
+    if(o--) {
+        register uint32_t sum = 0x0000003f & (data[i] >> 2);
+        sum |= ((uint32_t)data[i] << 14) & 0x0000c000;
+        if(o--) {
+            sum |= ((uint32_t)data[i + 1] << 6) & 0x00003f00;
+            sum |= ((uint32_t)data[i + 1] << 20) & 0x00300000;
+            if(o--) {
+                sum |= ((uint32_t)data[i + 2] << 12) & 0x000f0000;
+                sum |= ((uint32_t)data[i + 2] << 28) & 0xf0000000;
+                if(o--) {
+                    sum |= ((uint32_t)data[i + 3] << 20) & 0x0f000000;
+                    sum += 0x004e004e;
+#if BYTE_ORDER == BIG_ENDIAN
+                    vals[n++] = __builtin_bswap32(sum);
+#else
+                    vals[n++] = sum;
 #endif
-		sum = ((((uint32_t)data[i + 3] << 2) | ((uint32_t)data[i + 4] >> 6))) & 0x0000003f;
-		sum |= (((uint32_t)data[i + 4] << 10) | ((uint32_t)data[i + 5] << 2)) & 0x0000ff00;
-		sum |= ((uint32_t)data[i + 5] << 16) & 0x003f0000;
-		sum |= ((uint32_t)data[i + 6] << 24) & 0xff000000;
-		sum += 0x004e004e;
-		vals[n++] = sum;
-#ifdef DEBUG
-		printf("n: %u, add sum: %08x\n", n, sum);
+                    sum = (((uint32_t)data[i + 3] << 2)) & 0x0000003c;
+                    if(o--) {
+                        sum |= (((uint32_t)data[i + 4] >> 6)) & 0x00000003;
+                        sum |= ((uint32_t)data[i + 4] << 10) & 0x0000fc00;
+                        if(o--) {
+                            sum |= ((uint32_t)data[i + 5] << 2) & 0x00000300;
+                            sum |= ((uint32_t)data[i + 5] << 16) & 0x003f0000;
+                        }
+                    }
+                }
+            }
+        }
+        sum += 0x004e004e;
+#if BYTE_ORDER == BIG_ENDIAN
+        vals[n] = __builtin_bswap32(sum);
+#else
+        vals[n] = sum;
 #endif
-	}
-	uint8_t o = offset;
-	if(o--) {
-		register uint32_t sum = 0x0000003f & (data[i] >> 2);
-		sum |= ((uint32_t)data[i] << 14) & 0x0000c000;
-		if(o--) {
-			sum |= ((uint32_t)data[i + 1] << 6) & 0x00003f00;
-			sum |= ((uint32_t)data[i + 1] << 20) & 0x00300000;
-			if(o--) {
-				sum |= ((uint32_t)data[i + 2] << 12) & 0x000f0000;
-				sum |= ((uint32_t)data[i + 2] << 28) & 0xf0000000;
-				if(o--) {
-					sum |= ((uint32_t)data[i + 3] << 20) & 0x0f000000;
-					sum += 0x004e004e;
-					vals[n++] = sum;
-					sum = (((uint32_t)data[i + 3] << 2)) & 0x0000003c;
-					if(o--) {
-						sum |= (((uint32_t)data[i + 4] >> 6)) & 0x00000003;
-						sum |= ((uint32_t)data[i + 4] << 10) & 0x0000fc00;
-						if(o--) {
-							sum |= ((uint32_t)data[i + 5] << 2) & 0x00000300;
-							sum |= ((uint32_t)data[i + 5] << 16) & 0x003f0000;
-						}
-					}
-					sum += 0x004e004e;
-					vals[n] = sum;
-				}
-			}
-		}
-		encd->data[outlen - 2] = '=';
-		encd->data[outlen - 1] = offset;
-	}
-	return encd;
+        encd->data[outlen - 2] = '=';
+        encd->data[outlen - 1] = offset;
+    }
+    return encd;
 }
 
 LENDAT* decode(const uint8_t* data, const int32_t len) {
-	LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
-	int32_t outlen = len;
-	uint8_t offset = 0;
-	if(data[len-2] == '=') {
-		offset = data[len-1];
-		switch(offset) {	//算上偏移标志字符占用的2字节
-			case 0: break;
-			case 1: outlen -= 4; break;
-			case 2:
-			case 3: outlen -= 6; break;
-			case 4:
-			case 5: outlen -= 8; break;
-			case 6: outlen -= 10; break;
-			default: break;
-		}
-	}
-	outlen = outlen / 8 * 7 + offset;
-	decd->data = (uint8_t*)malloc(outlen);
-	decd->len = outlen;
-	uint32_t* vals = (uint32_t*)data;
-	uint32_t n = 0;
-	int32_t i = 0;
-	for(; i <= outlen - 7; n++) {	//n实际每次自增2
-		register uint32_t sum = vals[n++];
-		sum -= 0x004e004e;
-		decd->data[i++] = ((sum & 0x0000003f) << 2) | ((sum & 0x0000c000) >> 14);
-		decd->data[i++] = ((sum & 0x00003f00) >> 6) | ((sum & 0x00300000) >> 20);
-		decd->data[i++] = ((sum & 0x000f0000) >> 12) | ((sum & 0xf0000000) >> 28);
-		decd->data[i] = ((sum & 0x0f000000) >> 20);
-		sum = vals[n];
-		sum -= 0x004e004e;
-		decd->data[i++] |= ((sum & 0x0000003c) >> 2);
-		decd->data[i++] = ((sum & 0x00000003) << 6) | ((sum & 0x0000fc00) >> 10);
-		decd->data[i++] = ((sum & 0x00000300) >> 2) | ((sum & 0x003f0000) >> 16);
-		decd->data[i++] = ((sum & 0xff000000) >> 24);
-	}
-	if(offset--) {
-		register uint32_t sum = vals[n++];
-		sum -= 0x0000004e;
-		decd->data[i++] = ((sum & 0x0000003f) << 2) | ((sum & 0x0000c000) >> 14);
-		if(offset--) {
-			sum -= 0x004e0000;
-			decd->data[i++] = ((sum & 0x00003f00) >> 6) | ((sum & 0x00300000) >> 20);
-			if(offset--) {
-				decd->data[i++] = ((sum & 0x000f0000) >> 12) | ((sum & 0xf0000000) >> 28);
-				if(offset--) {
-					decd->data[i++] = (sum & 0x0f000000) >> 20;
-					sum = vals[n];
-					sum -= 0x0000004e;
-					decd->data[i++] |= (sum & 0x0000003c) >> 2;
-					if(offset--) {
-						decd->data[i++] = ((sum & 0x00000003) << 6) | ((sum & 0x0000fc00) >> 10);
-						if(offset--) {
-							sum -= 0x004e0000;
-							decd->data[i] = ((sum & 0x00000300) >> 2) | ((sum & 0x003f0000) >> 16);
-						}
-					}
-				}
-			}
-		}
-	}
-	return decd;
+    LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
+    int32_t outlen = len;
+    uint8_t offset = 0;
+    if(data[len-2] == '=') {
+        offset = data[len-1];
+        switch(offset) {	//算上偏移标志字符占用的2字节
+            case 0: break;
+            case 1: outlen -= 4; break;
+            case 2:
+            case 3: outlen -= 6; break;
+            case 4:
+            case 5: outlen -= 8; break;
+            case 6: outlen -= 10; break;
+            default: break;
+        }
+    }
+    outlen = outlen / 8 * 7 + offset;
+    decd->data = (uint8_t*)malloc(outlen+1); //多出1字节用于循环覆盖
+    decd->len = outlen;
+    uint32_t* vals = (uint32_t*)data;
+    uint32_t n = 0;
+    int32_t i = 0;
+    for(; i <= outlen - 7; i+=7) {	//n实际每次自增2
+        register uint32_t sum = 0;
+        register uint32_t shift = htobe32(vals[n++]) - 0x4e004e00;
+        shift <<= 2;
+        sum |= shift & 0xfffc0000;
+        shift <<= 2;
+        sum |= shift & 0x0003fff0;
+        shift = htobe32(vals[n++]) - 0x4e004e00;
+        sum |= shift >> 26;
+        *(uint32_t*)(decd->data+i) = be32toh(sum);
+        sum = 0;
+        shift <<= 6;
+        sum |= shift & 0xffc00000;
+        shift <<= 2;
+        sum |= shift & 0x003fff00;
+        *(uint32_t*)(decd->data+i+4) = be32toh(sum);
+    }
+    if(offset--) {
+        //这里有读取越界
+#if BYTE_ORDER == BIG_ENDIAN
+        register uint32_t sum = __builtin_bswap32(vals[n++]);
+#else
+        register uint32_t sum = vals[n++];
+#endif
+        sum -= 0x0000004e;
+        decd->data[i++] = ((sum & 0x0000003f) << 2) | ((sum & 0x0000c000) >> 14);
+        if(offset--) {
+            sum -= 0x004e0000;
+            decd->data[i++] = ((sum & 0x00003f00) >> 6) | ((sum & 0x00300000) >> 20);
+            if(offset--) {
+                decd->data[i++] = ((sum & 0x000f0000) >> 12) | ((sum & 0xf0000000) >> 28);
+                if(offset--) {
+                    decd->data[i++] = (sum & 0x0f000000) >> 20;
+                    //这里有读取越界
+                    sum = vals[n];
+                    sum -= 0x0000004e;
+                    decd->data[i++] |= (sum & 0x0000003c) >> 2;
+                    if(offset--) {
+                        decd->data[i++] = ((sum & 0x00000003) << 6) | ((sum & 0x0000fc00) >> 10);
+                        if(offset--) {
+                            sum -= 0x004e0000;
+                            decd->data[i] = ((sum & 0x00000300) >> 2) | ((sum & 0x003f0000) >> 16);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return decd;
 }

app/src/main/cpp/base14/32/base1432le.h

@@ -2,7 +2,7 @@
 //fumiama 20210408
 #include <stdint.h>
 
-#define B14BUFSIZ 8192
+#define B14BUFSIZ 1024*1024 // 1M
 struct LENDAT {
     uint8_t* data;
     int32_t len;

app/src/main/cpp/base14/64/base1464le.c

@@ -1,137 +1,170 @@
-//base1464le.c
-//fumiama 20210407
+//base14.c
+//fumiama 20211029
 #include <stdio.h>
 #include <stdlib.h>
+#if defined(__linux__)
+#  include <endian.h>
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+#  include <sys/endian.h>
+#elif defined(__OpenBSD__)
+#  include <sys/types.h>
+#  define be16toh(x) betoh16(x)
+#  define be32toh(x) betoh32(x)
+#  define be64toh(x) betoh64(x)
+#elif defined(__MAC_10_0)
+#  define be16toh(x) ntohs(x)
+#  define be32toh(x) ntohl(x)
+#  define be64toh(x) ntohll(x)
+#  define htobe16(x) ntohs(x)
+#  define htobe32(x) htonl(x)
+#  define htobe64(x) htonll(x)
+#endif
 #include "base1464le.h"
 
 //#define DEBUG
 
 LENDAT* encode(const uint8_t* data, const int64_t len) {
-	LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
-	int64_t outlen = len / 7 * 8;
-	uint8_t offset = len % 7;
-	switch(offset) {	//算上偏移标志字符占用的2字节
-		case 0: break;
-		case 1: outlen += 4; break;
-		case 2:
-		case 3: outlen += 6; break;
-		case 4:
-		case 5: outlen += 8; break;
-		case 6: outlen += 10; break;
-		default: break;
-	}
+    LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
+    int64_t outlen = len / 7 * 8;
+    uint8_t offset = len % 7;
+    switch(offset) {	//算上偏移标志字符占用的2字节
+        case 0: break;
+        case 1: outlen += 4; break;
+        case 2:
+        case 3: outlen += 6; break;
+        case 4:
+        case 5: outlen += 8; break;
+        case 6: outlen += 10; break;
+        default: break;
+    }
 #ifdef DEBUG
-	printf("outlen: %llu, offset: %u, malloc: %llu\n", outlen, offset, outlen + 8);
+    printf("outlen: %llu, offset: %u, malloc: %llu\n", outlen, offset, outlen + 8);
 #endif
-	encd->data = (uint8_t*)malloc(outlen + 8);	//冗余的8B用于可能的结尾的覆盖
-	encd->len = outlen;
-	uint64_t* vals = (uint64_t*)(encd->data);
-	uint64_t n = 0;
-	int64_t i = 0;
-	for(; i <= len - 7; i += 7) {
-		register uint64_t sum = 0x000000000000003f & ((uint64_t)data[i] >> 2);
-		sum |= (((uint64_t)data[i + 1] << 6) | (data[i] << 14)) & 0x000000000000ff00;
-		sum |= (((uint64_t)data[i + 1] << 20) | ((uint64_t)data[i + 2] << 12)) & 0x00000000003f0000;
-		sum |= (((uint64_t)data[i + 2] << 28) | ((uint64_t)data[i + 3] << 20)) & 0x00000000ff000000;
-		sum |= (((uint64_t)data[i + 3] << 34) | ((uint64_t)data[i + 4] << 26)) & 0x0000003f00000000;
-		sum |= (((uint64_t)data[i + 4] << 42) | ((uint64_t)data[i + 5] << 34)) & 0x0000ff0000000000;
-		sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
-		sum |= ((uint64_t)data[i + 6] << 56) & 0xff00000000000000;
-		sum += 0x004e004e004e004e;
-		vals[n++] = sum;
+    encd->data = (uint8_t*)malloc(outlen + 8);	//冗余的8B用于可能的结尾的覆盖
+    encd->len = outlen;
+    uint64_t* vals = (uint64_t*)(encd->data);
+    uint64_t n = 0;
+    int64_t i = 0;
+    for(; i <= len - 7; i += 7) {
+        register uint64_t sum = 0;
+        register uint64_t shift = htobe64(*(uint64_t*)(data+i))>>2; //这里有读取越界
+        sum |= shift & 0x3fff000000000000;
+        shift >>= 2;
+        sum |= shift & 0x00003fff00000000;
+        shift >>= 2;
+        sum |= shift & 0x000000003fff0000;
+        shift >>= 2;
+        sum |= shift & 0x0000000000003fff;
+        sum += 0x4e004e004e004e00;
+        vals[n++] = be64toh(sum);
 #ifdef DEBUG
-		printf("i: %llu, add sum: %016llx\n", i, sum);
+        printf("i: %llu, add sum: %016llx\n", i, sum);
+#endif
+    }
+    uint8_t o = offset;
+    if(o--) {
+        register uint64_t sum = 0x000000000000003f & (data[i] >> 2);
+        sum |= ((uint64_t)data[i] << 14) & 0x000000000000c000;
+        if(o--) {
+            sum |= ((uint64_t)data[i + 1] << 6) & 0x0000000000003f00;
+            sum |= ((uint64_t)data[i + 1] << 20) & 0x0000000000300000;
+            if(o--) {
+                sum |= ((uint64_t)data[i + 2] << 12) & 0x00000000000f0000;
+                sum |= ((uint64_t)data[i + 2] << 28) & 0x00000000f0000000;
+                if(o--) {
+                    sum |= ((uint64_t)data[i + 3] << 20) & 0x000000000f000000;
+                    sum |= ((uint64_t)data[i + 3] << 34) & 0x0000003c00000000;
+                    if(o--) {
+                        sum |= ((uint64_t)data[i + 4] << 26) & 0x0000000300000000;
+                        sum |= ((uint64_t)data[i + 4] << 42) & 0x0000fc0000000000;
+                        if(o--) {
+                            sum |= ((uint64_t)data[i + 5] << 34) & 0x0000030000000000;
+                            sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
+                        }
+                    }
+                }
+            }
+        }
+        sum += 0x004e004e004e004e;
+#if BYTE_ORDER == BIG_ENDIAN
+        vals[n] = __builtin_bswap64(sum);
+#else
+        vals[n] = sum;
 #endif
-	}
-	uint8_t o = offset;
-	if(o--) {
-		register uint64_t sum = 0x000000000000003f & (data[i] >> 2);
-		sum |= ((uint64_t)data[i] << 14) & 0x000000000000c000;
-		if(o--) {
-			sum |= ((uint64_t)data[i + 1] << 6) & 0x0000000000003f00;
-			sum |= ((uint64_t)data[i + 1] << 20) & 0x0000000000300000;
-			if(o--) {
-				sum |= ((uint64_t)data[i + 2] << 12) & 0x00000000000f0000;
-				sum |= ((uint64_t)data[i + 2] << 28) & 0x00000000f0000000;
-				if(o--) {
-					sum |= ((uint64_t)data[i + 3] << 20) & 0x000000000f000000;
-					sum |= ((uint64_t)data[i + 3] << 34) & 0x0000003c00000000;
-					if(o--) {
-						sum |= ((uint64_t)data[i + 4] << 26) & 0x0000000300000000;
-						sum |= ((uint64_t)data[i + 4] << 42) & 0x0000fc0000000000;
-						if(o--) {
-							sum |= ((uint64_t)data[i + 5] << 34) & 0x0000030000000000;
-							sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
-						}
-					}
-				}
-			}
-		}
-		sum += 0x004e004e004e004e;
-		vals[n] = sum;
 #ifdef DEBUG
-		printf("i: %llu, add sum: %016llx\n", i, sum);
+        printf("i: %llu, add sum: %016llx\n", i, sum);
 #endif
-		encd->data[outlen - 2] = '=';
-		encd->data[outlen - 1] = offset;
-	}
-	return encd;
+        encd->data[outlen - 2] = '=';
+        encd->data[outlen - 1] = offset;
+    }
+    return encd;
 }
 
 LENDAT* decode(const uint8_t* data, const int64_t len) {
-	LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
-	int64_t outlen = len;
-	uint8_t offset = 0;
-	if(data[len-2] == '=') {
-		offset = data[len-1];
-		switch(offset) {	//算上偏移标志字符占用的2字节
-			case 0: break;
-			case 1: outlen -= 4; break;
-			case 2:
-			case 3: outlen -= 6; break;
-			case 4:
-			case 5: outlen -= 8; break;
-			case 6: outlen -= 10; break;
-			default: break;
-		}
-	}
-	outlen = outlen / 8 * 7 + offset;
-	decd->data = (uint8_t*)malloc(outlen);
-	decd->len = outlen;
-	uint64_t* vals = (uint64_t*)data;
-	uint64_t n = 0;
-	int64_t i = 0;
-	for(; i <= outlen - 7; n++) {
-		register uint64_t sum = vals[n] - 0x004e004e004e004e;
-		decd->data[i++] = ((sum & 0x000000000000003f) << 2) | ((sum & 0x000000000000c000) >> 14);
-		decd->data[i++] = ((sum & 0x0000000000003f00) >> 6) | ((sum & 0x0000000000300000) >> 20);
-		decd->data[i++] = ((sum & 0x00000000000f0000) >> 12) | ((sum & 0x00000000f0000000) >> 28);
-		decd->data[i++] = ((sum & 0x000000000f000000) >> 20) | ((sum & 0x0000003c00000000) >> 34);
-		decd->data[i++] = ((sum & 0x0000000300000000) >> 26) | ((sum & 0x0000fc0000000000) >> 42);
-		decd->data[i++] = ((sum & 0x0000030000000000) >> 34) | ((sum & 0x003f000000000000) >> 48);
-		decd->data[i++] = ((sum & 0xff00000000000000) >> 56);
-	}
-	if(offset--) {
-		register uint64_t sum = vals[n] - 0x000000000000004e;
-		decd->data[i++] = ((sum & 0x000000000000003f) << 2) | ((sum & 0x000000000000c000) >> 14);
-		if(offset--) {
-			sum -= 0x00000000004e0000;
-			decd->data[i++] = ((sum & 0x0000000000003f00) >> 6) | ((sum & 0x0000000000300000) >> 20);
-			if(offset--) {
-				decd->data[i++] = ((sum & 0x00000000000f0000) >> 12) | ((sum & 0x00000000f0000000) >> 28);
-				if(offset--) {
-					sum -= 0x0000004e00000000;
-					decd->data[i++] = ((sum & 0x000000000f000000) >> 20) | ((sum & 0x0000003c00000000) >> 34);
-					if(offset--) {
-						decd->data[i++] = ((sum & 0x0000000300000000) >> 26) | ((sum & 0x0000fc0000000000) >> 42);
-						if(offset--) {
-							sum -= 0x004e000000000000;
-							decd->data[i] = ((sum & 0x0000030000000000) >> 34) | ((sum & 0x003f000000000000) >> 48);
-						}
-					}
-				}
-			}
-		}
-	}
-	return decd;
+    LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
+    int64_t outlen = len;
+    uint8_t offset = 0;
+    if(data[len-2] == '=') {
+        offset = data[len-1];
+        switch(offset) {	//算上偏移标志字符占用的2字节
+            case 0: break;
+            case 1: outlen -= 4; break;
+            case 2:
+            case 3: outlen -= 6; break;
+            case 4:
+            case 5: outlen -= 8; break;
+            case 6: outlen -= 10; break;
+            default: break;
+        }
+    }
+    outlen = outlen / 8 * 7 + offset;
+    decd->data = (uint8_t*)malloc(outlen+1); //多出1字节用于循环覆盖
+    decd->len = outlen;
+    uint64_t* vals = (uint64_t*)data;
+    uint64_t n = 0;
+    int64_t i = 0;
+    for(; i <= outlen - 7; n++, i+=7) {
+        register uint64_t sum = 0;
+        register uint64_t shift = htobe64(vals[n]) - 0x4e004e004e004e00;
+        shift <<= 2;
+        sum |= shift & 0xfffc000000000000;
+        shift <<= 2;
+        sum |= shift & 0x0003fff000000000;
+        shift <<= 2;
+        sum |= shift & 0x0000000fffc00000;
+        shift <<= 2;
+        sum |= shift & 0x00000000003fff00;
+        *(uint64_t*)(decd->data+i) = be64toh(sum);
+#ifdef DEBUG
+        printf("i: %llu, add sum: %016llx\n", i, sum);
+#endif
+    }
+    if(offset--) {
+        //这里有读取越界
+#if BYTE_ORDER == BIG_ENDIAN
+        register uint64_t sum = __builtin_bswap64(vals[n]) - 0x000000000000004e;
+#else
+        register uint64_t sum = vals[n] - 0x000000000000004e;
+#endif
+        decd->data[i++] = ((sum & 0x000000000000003f) << 2) | ((sum & 0x000000000000c000) >> 14);
+        if(offset--) {
+            sum -= 0x00000000004e0000;
+            decd->data[i++] = ((sum & 0x0000000000003f00) >> 6) | ((sum & 0x0000000000300000) >> 20);
+            if(offset--) {
+                decd->data[i++] = ((sum & 0x00000000000f0000) >> 12) | ((sum & 0x00000000f0000000) >> 28);
+                if(offset--) {
+                    sum -= 0x0000004e00000000;
+                    decd->data[i++] = ((sum & 0x000000000f000000) >> 20) | ((sum & 0x0000003c00000000) >> 34);
+                    if(offset--) {
+                        decd->data[i++] = ((sum & 0x0000000300000000) >> 26) | ((sum & 0x0000fc0000000000) >> 42);
+                        if(offset--) {
+                            sum -= 0x004e000000000000;
+                            decd->data[i] = ((sum & 0x0000030000000000) >> 34) | ((sum & 0x003f000000000000) >> 48);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return decd;
 }

app/src/main/cpp/base14/64/base1464le.h

@@ -2,7 +2,7 @@
 //fumiama 20210408
 #include <stdint.h>
 
-#define B14BUFSIZ 16384
+#define B14BUFSIZ 1024*1024 // 1M
 struct LENDAT {
     uint8_t* data;
     int64_t len;