fumiama/android-base16384
1
0
Fork 0
mirror of https://github.com/fumiama/android-base16384.git synced 2026-06-11 21:50:39 +08:00
Code Activity

v3.2.1

Browse Source 
1. 修复32位加密错误
2. 优化性能
This commit is contained in:
fumiama
2021-10-29 22:56:36 +08:00
parent bcc392ad73
commit 311f836731
8 changed files with 321 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
app/build.gradle
View File

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

BIN
app/release/app-release.aab
View File

Binary file not shown.

BIN
app/release/app-release.apk
View File

Binary file not shown.

4
app/release/output-metadata.json
View File

@@ -10,8 +10,8 @@
{ {
"type": "SINGLE", "type": "SINGLE",
"filters": [], "filters": [],
"versionCode": 14, "versionCode": 15,
"versionName": "3.1", "versionName": "3.2",
"outputFile": "app-release.apk" "outputFile": "app-release.apk"
} }
] ]

293
app/src/main/cpp/base14/32/base1432le.c
View File

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

2
app/src/main/cpp/base14/32/base1432le.h
View File

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

273
app/src/main/cpp/base14/64/base1464le.c
View File

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

2
app/src/main/cpp/base14/64/base1464le.h
View File

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