fumiama/android-base16384
1
0
Fork 0
mirror of https://github.com/fumiama/android-base16384.git synced 2026-06-06 02:30:30 +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"
minSdkVersion 23
targetSdkVersion 31
versionCode 15
versionName '3.2'
versionCode 16
versionName '3.2.1'
resConfigs "zh", "en"
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",
"filters": [],
"versionCode": 14,
"versionName": "3.1",
"versionCode": 15,
"versionName": "3.2",
"outputFile": "app-release.apk"
}
]

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

@@ -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;
}

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

@@ -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;

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

@@ -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;
}

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

@@ -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;