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

新的设计，速度快很多

Browse Source
This commit is contained in:
fumiama
2021-04-08 15:34:32 +08:00
parent 2785b6e766
commit 963abc1ec3
13 changed files with 355 additions and 305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
build

4
32/CMakeLists.txt Normal file
View File

@@ -0,0 +1,4 @@
cmake_minimum_required(VERSION 3.0.0)
project(base1432 VERSION 2.0)
add_library(base1432 ./base1432le.c)

151
32/base1432le.c Normal file
View File

@@ -0,0 +1,151 @@
//base1432le.c
//fumiama 20210408
#include <stdio.h>
#include <stdlib.h>
#include "base1432le.h"
//#define DEBUG
LENDAT* encode(const uint8_t* data, const u_int32_t len) {
LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
uint32_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);
#endif
encd->data = (uint8_t*)malloc(outlen + 8); //冗余的8B用于可能的结尾的覆盖
encd->len = outlen;
uint32_t* vals = (uint32_t*)(encd->data);
uint32_t n = 0;
uint32_t i = 0;
for(; i < len; i += 7) {
register uint32_t sum = 0x0000003f & ((uint32_t)data[i] >> 2);
sum |= ((((uint32_t)data[i + 1] >> 2) | (data[i] << 6)) << 8) & 0x0000ff00;
sum |= ((((uint32_t)data[i + 1] << 4) | ((uint32_t)data[i + 2] >> 4)) << 16) & 0x003f0000;
sum |= ((((uint32_t)data[i + 2] << 4) | ((uint32_t)data[i + 3] >> 4)) << 24) & 0xff000000;
sum += 0x004e004e;
vals[n++] = sum;
#ifdef DEBUG
printf("n: %u, add sum: %08x\n", n, sum);
#endif
sum = ((((uint32_t)data[i + 3] << 2) | ((uint32_t)data[i + 4] >> 6))) & 0x0000003f;
sum |= ((((uint32_t)data[i + 4] << 2) | ((uint32_t)data[i + 5] >> 6)) << 8) & 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);
#endif
}
if(offset > 0) {
register uint32_t sum = 0x0000003f & (data[i] >> 2);
sum |= (((uint32_t)data[i] << 6) << 8) & 0x0000c000;
if(offset > 1) {
sum |= (((uint32_t)data[i + 1] >> 2) << 8) & 0x00003f00;
sum |= (((uint32_t)data[i + 1] << 4) << 16) & 0x00300000;
if(offset > 2) {
sum |= (((uint32_t)data[i + 2] >> 4) << 16) & 0x000f0000;
sum |= (((uint32_t)data[i + 2] << 4) << 24) & 0xf0000000;
if(offset == 2) {
sum += 0x004e004e;
vals[n++] = sum;
}
if(offset > 3) {
sum |= (((uint32_t)data[i + 3] >> 4) << 24) & 0x0f000000;
sum += 0x004e004e;
vals[n++] = sum;
sum = (((uint32_t)data[i + 3] << 2)) & 0x0000003c;
if(offset > 4) {
sum |= (((uint32_t)data[i + 4] >> 6)) & 0x00000003;
sum |= (((uint32_t)data[i + 4] << 2) << 8) & 0x0000fc00;
if(offset > 5) {
sum |= (((uint32_t)data[i + 5] >> 6) << 8) & 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 u_int32_t len) {
LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
uint32_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;
uint32_t i = 0;
for(; n < len / 4; 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 > 0) {
register uint32_t sum = vals[n++];
sum -= 0x0000004e;
decd->data[i++] = ((sum & 0x0000003f) << 2) | ((sum & 0x0000c000) >> 14);
if(offset > 1) {
sum -= 0x004e0000;
decd->data[i++] = ((sum & 0x00003f00) >> 6) | ((sum & 0x00300000) >> 20);
if(offset > 2) {
decd->data[i++] = ((sum & 0x000f0000) >> 12) | ((sum & 0xf0000000) >> 28);
if(offset > 3) {
decd->data[i++] = (sum & 0x0f000000) >> 20;
sum = vals[n];
sum -= 0x0000004e;
decd->data[i++] |= (sum & 0x0000003c) >> 2;
if(offset > 4) {
decd->data[i++] = ((sum & 0x00000003) << 6) | ((sum & 0x0000fc00) >> 10);
if(offset > 5) {
sum -= 0x004e0000;
decd->data[i++] = ((sum & 0x00000300) >> 2) | ((sum & 0x003f0000) >> 16);
}
}
}
}
}
}
return decd;
}

13
32/base1432le.h Normal file
View File

@@ -0,0 +1,13 @@
//base1432le.h
//fumiama 20210408
#include <stdint.h>
#define B14BUFSIZ 8192
struct LENDAT {
uint8_t* data;
uint32_t len;
};
typedef struct LENDAT LENDAT;
LENDAT* encode(const uint8_t* data, const u_int32_t len);
LENDAT* decode(const uint8_t* data, const u_int32_t len);

4
64/CMakeLists.txt Normal file
View File

@@ -0,0 +1,4 @@
cmake_minimum_required(VERSION 3.0.0)
project(base1464 VERSION 2.0)
add_library(base1464 ./base1464le.c)

83
64/base1464le.c
View File

@@ -1,4 +1,4 @@
//basex64.c
//base1464le.c
//fumiama 20210407
#include <stdio.h>
#include <stdlib.h>
@@ -6,7 +6,7 @@
//#define DEBUG
LENDAT* encode(const char* data, const u_int64_t len) {
LENDAT* encode(const uint8_t* data, const u_int64_t len) {
LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
uint64_t outlen = len / 7 * 8;
uint8_t offset = len % 7;
@@ -28,7 +28,7 @@ LENDAT* encode(const char* data, const u_int64_t len) {
uint64_t* vals = (uint64_t*)(encd->data);
uint64_t n = 0;
uint64_t i = 0;
for(; i < len - 7; i += 7) {
for(; i < len; i += 7) {
register uint64_t sum = 0x000000000000003f & ((uint64_t)data[i] >> 2);
sum |= ((((uint64_t)data[i + 1] >> 2) | (data[i] << 6)) << 8) & 0x000000000000ff00;
sum |= ((((uint64_t)data[i + 1] << 4) | ((uint64_t)data[i + 2] >> 4)) << 16) & 0x00000000003f0000;
@@ -77,7 +77,7 @@ LENDAT* encode(const char* data, const u_int64_t len) {
return encd;
}
LENDAT* decode(const char* data, const u_int64_t len) {
LENDAT* decode(const uint8_t* data, const u_int64_t len) {
LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
uint64_t outlen = len;
uint8_t offset = 0;
@@ -136,78 +136,3 @@ LENDAT* decode(const char* data, const u_int64_t len) {
}
return decd;
}
void encode_file(const char* input, const char* output) {
FILE* fp = NULL;
fp = fopen(input, "rb");
if(fp) {
FILE* fpo = NULL;
fpo = fopen(output, "wb");
if(fpo) {
char* bufi = (char*)malloc(B14BUFSIZ/7*7);
if(bufi) {
int cnt = 0;
fputc(0xFE, fpo);
fputc(0xFF, fpo);
while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
LENDAT* ld = encode(bufi, cnt);
if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
puts("Write file error!");
exit(EXIT_FAILURE);
}
free(ld);
}
free(bufi);
} else puts("Allocate input buffer error!");
fclose(fpo);
} else puts("Open output file error!");
fclose(fp);
} else puts("Open input file error!");
}
int rm_head(FILE* fp) {
int ch = fgetc(fp);
if(ch == 0xFE) fgetc(fp);
else rewind(fp);
}
void decode_file(const char* input, const char* output) {
FILE* fp = NULL;
fp = fopen(input, "rb");
if(fp) {
FILE* fpo = NULL;
fpo = fopen(output, "wb");
if(fpo) {
char* bufi = (char*)malloc(B14BUFSIZ/8*8);
if(bufi) {
int cnt = 0;
rm_head(fp);
while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
LENDAT* ld = decode(bufi, cnt);
if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
puts("Write file error!");
exit(EXIT_FAILURE);
}
free(ld);
}
free(bufi);
} else puts("Allocate input buffer error!");
fclose(fpo);
} else puts("Open output file error!");
fclose(fp);
} else puts("Open input file error!");
}
#define B1464LE_TEST
#ifdef B1464LE_TEST
int main(int argc, char** argv) {
LENDAT* ld = encode("just a simple test from fumiama", 32);
//puts(ld->data);
LENDAT* le = decode(ld->data, ld->len);
puts(le->data);
if(argc == 4) {
encode_file(argv[1], argv[2]);
decode_file(argv[2], argv[3]);
}
}
#endif

5
64/base1464le.h
View File

@@ -1,3 +1,5 @@
//base1464le.h
//fumiama 20210408
#include <stdint.h>
#define B14BUFSIZ 16384
@@ -6,3 +8,6 @@ struct LENDAT {
uint64_t len;
};
typedef struct LENDAT LENDAT;
LENDAT* encode(const uint8_t* data, const u_int64_t len);
LENDAT* decode(const uint8_t* data, const u_int64_t len);

BIN
64/base1464le.txt
View File

Binary file not shown.

213
64/base1464leo.txt
View File

@@ -1,213 +0,0 @@
//basex64.c
//fumiama 20210407
#include <stdio.h>
#include <stdlib.h>
#include "base1464le.h"
//#define DEBUG
LENDAT* encode(const char* data, const u_int64_t len) {
LENDAT* encd = (LENDAT*)malloc(sizeof(LENDAT));
uint64_t outlen = len / 7 * 8;
uint8_t offset = len % 7;
switch(offset) { //ﯿ下珏<E4B88B><E78F8F><EFBFBD>磏ￗ寗ﯿ卣矯<E58DA3><E79FAF><EFBFBD>3篟<33><E7AF9F><EFBFBD>
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);
#endif
encd->data = (uint8_t*)malloc(outlen + 8); //珟<><E78F9F><EFBFBD>盄8甫翏<E794AB><E7BF8F><EFBFBD>냿ￄ结￿皇믏<E79A87><EBAF8F><EFBFBD>
encd->len = outlen;
uint64_t* vals = (uint64_t*)(encd->data);
uint64_t n = 0;
uint64_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] >> 2) | (data[i] << 6)) << 8) & 0x000000000000ff00;
sum |= ((((uint64_t)data[i + 1] << 4) | ((uint64_t)data[i + 2] >> 4)) << 16) & 0x00000000003f0000;
sum |= ((((uint64_t)data[i + 2] << 4) | ((uint64_t)data[i + 3] >> 4)) << 24) & 0x00000000ff000000;
sum |= ((((uint64_t)data[i + 3] << 2) | ((uint64_t)data[i + 4] >> 6)) << 32) & 0x0000003f00000000;
sum |= ((((uint64_t)data[i + 4] << 2) | ((uint64_t)data[i + 5] >> 6)) << 40) & 0x0000ff0000000000;
sum |= ((uint64_t)data[i + 5] << 48) & 0x003f000000000000;
sum |= ((uint64_t)data[i + 6] << 56) & 0xff00000000000000;
sum += 0x004e004e004e004e;
vals[n++] = sum;
#ifdef DEBUG
printf("i: %llu, add sum: %016llx\n", i, sum);
#endif
}
if(offset > 0) {
register uint64_t sum = 0x000000000000003f & (data[i] >> 2);
sum |= (((uint64_t)data[i] << 6) << 8) & 0x000000000000c000;
if(offset > 1) {
sum |= (((uint64_t)data[i + 1] >> 2) << 8) & 0x0000000000003f00;
sum |= (((uint64_t)data[i + 1] << 4) << 16) & 0x0000000000300000;
if(offset > 2) {
sum |= (((uint64_t)data[i + 2] >> 4) << 16) & 0x00000000000f0000;
sum |= (((uint64_t)data[i + 2] << 4) << 24) & 0x00000000f0000000;
if(offset > 3) {
sum |= (((uint64_t)data[i + 3] >> 4) << 24) & 0x000000000f000000;
sum |= (((uint64_t)data[i + 3] << 2) << 32) & 0x0000003c00000000;
if(offset > 4) {
sum |= (((uint64_t)data[i + 4] >> 6) << 32) & 0x0000000300000000;
sum |= (((uint64_t)data[i + 4] << 2) << 40) & 0x0000fc0000000000;
if(offset > 5) {
sum |= (((uint64_t)data[i + 5] >> 6) << 40) & 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);
#endif
encd->data[outlen - 2] = '=';
encd->data[outlen - 1] = offset;
}
return encd;
}
LENDAT* decode(const char* data, const u_int64_t len) {
LENDAT* decd = (LENDAT*)malloc(sizeof(LENDAT));
uint64_t outlen = len;
uint8_t offset = 0;
if(data[len-2] == '=') {
offset = data[len-1];
switch(offset) { //ￗ介移篏<E7A7BB><E7AF8F><EFBFBD>篟￦口的3ﯿ节
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;
uint64_t i = 0;
for(; n < len / 8; n++) {
register uint64_t sum = vals[n];
sum -= 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 > 0) {
register uint64_t sum = vals[n];
sum -= 0x000000000000004e;
decd->data[i++] = ((sum & 0x000000000000003f) << 2) | ((sum & 0x000000000000c000) >> 14);
if(offset > 1) {
sum -= 0x00000000004e0000;
decd->data[i++] = ((sum & 0x0000000000003f00) >> 6) | ((sum & 0x0000000000300000) >> 20);
if(offset > 2) {
decd->data[i++] = ((sum & 0x00000000000f0000) >> 12) | ((sum & 0x00000000f0000000) >> 28);
if(offset > 3) {
sum -= 0x0000004e00000000;
decd->data[i++] = ((sum & 0x000000000f000000) >> 20) | ((sum & 0x0000003c00000000) >> 34);
if(offset > 4) {
decd->data[i++] = ((sum & 0x0000000300000000) >> 26) | ((sum & 0x0000fc0000000000) >> 42);
if(offset > 5) {
sum -= 0x004e000000000000;
decd->data[i++] = ((sum & 0x0000030000000000) >> 34) | ((sum & 0x003f000000000000) >> 48);
}
}
}
}
}
}
return decd;
}
void encode_file(const char* input, const char* output) {
FILE* fp = NULL;
fp = fopen(input, "rb");
if(fp) {
FILE* fpo = NULL;
fpo = fopen(output, "wb");
if(fpo) {
char* bufi = (char*)malloc(B14BUFSIZ/7*7);
if(bufi) {
int cnt = 0;
fputc(0xFE, fpo);
fputc(0xFF, fpo);
while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
LENDAT* ld = encode(bufi, cnt);
if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
puts("Write file error!");
exit(EXIT_FAILURE);
}
free(ld);
}
free(bufi);
} else puts("Allocate input buffer error!");
fclose(fpo);
} else puts("Open output file error!");
fclose(fp);
} else puts("Open input file error!");
}
int rm_head(FILE* fp) {
int ch = fgetc(fp);
if(ch == 0xFE) fgetc(fp);
else rewind(fp);
}
void decode_file(const char* input, const char* output) {
FILE* fp = NULL;
fp = fopen(input, "rb");
if(fp) {
FILE* fpo = NULL;
fpo = fopen(output, "wb");
if(fpo) {
char* bufi = (char*)malloc(B14BUFSIZ/8*8);
if(bufi) {
int cnt = 0;
rm_head(fp);
while((cnt = fread(bufi, 1, B14BUFSIZ/7*7, fp))) {
LENDAT* ld = decode(bufi, cnt);
if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
puts("Write file error!");
exit(EXIT_FAILURE);
}
free(ld);
}
free(bufi);
} else puts("Allocate input buffer error!");
fclose(fpo);
} else puts("Open output file error!");
fclose(fp);
} else puts("Open input file error!");
}
#define B1464LE_TEST
#ifdef B1464LE_TEST
int main(int argc, char** argv) {
LENDAT* ld = encode("just a simple test from fumiama", 32);
//puts(ld->data);
LENDAT* le = decode(ld->data, ld->len);
puts(le->data);
if(argc == 4) {
encode_file(argv[1], argv[2]);
decode_file(argv[2], argv[3]);
}
}
#endif

14
CMakeLists.txt Normal file
View File

@@ -0,0 +1,14 @@
cmake_minimum_required(VERSION 3.0.0)
project(base16384 VERSION 2.0)
add_executable(base16384 base16384.c)
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
add_definitions("-DCPUBIT64")
add_subdirectory("./64")
target_link_libraries(base16384 base1464)
ELSE()
add_definitions("-DCPUBIT32")
add_subdirectory("./32")
target_link_libraries(base16384 base1432)
ENDIF()

55
README.md
View File

File diff suppressed because one or more lines are too long

105
base16384.c Normal file
View File

@@ -0,0 +1,105 @@
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "base16384.h"
void encode_file(const char* input, const char* output) {
FILE* fp = NULL;
fp = fopen(input, "rb");
if(fp) {
FILE* fpo = NULL;
fpo = fopen(output, "wb");
if(fpo) {
char* bufi = (char*)malloc(B14BUFSIZ/7*7);
if(bufi) {
int cnt = 0;
fputc(0xFE, fpo);
fputc(0xFF, fpo);
fflush(fpo);
while((cnt = fread(bufi, sizeof(char), B14BUFSIZ/7*7, fp))) {
LENDAT* ld = encode(bufi, cnt);
if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
puts("Write file error!");
exit(EXIT_FAILURE);
}
free(ld);
}
free(bufi);
} else puts("Allocate input buffer error!");
fclose(fpo);
} else puts("Open output file error!");
fclose(fp);
} else puts("Open input file error!");
}
int rm_head(FILE* fp) {
int ch = fgetc(fp);
if(ch == 0xFE) fgetc(fp);
else rewind(fp);
}
static int is_next_end(FILE* fp) {
int ch = fgetc(fp);
if(ch == '=') return fgetc(fp);
else {
ungetc(ch, fp);
return 0;
}
}
void decode_file(const char* input, const char* output) {
FILE* fp = NULL;
fp = fopen(input, "rb");
if(fp) {
FILE* fpo = NULL;
fpo = fopen(output, "wb");
if(fpo) {
char* bufi = (char*)malloc(B14BUFSIZ/8*8 + 2); //+2避免漏检结束偏移标志
if(bufi) {
int cnt = 0;
int end = 0;
rm_head(fp);
while((cnt = fread(bufi, sizeof(char), B14BUFSIZ/8*8, fp))) {
if((end = is_next_end(fp))) {
bufi[cnt++] = '=';
bufi[cnt++] = end;
}
LENDAT* ld = decode(bufi, cnt);
if(fwrite(ld->data, ld->len, 1, fpo) <= 0) {
puts("Write file error!");
exit(EXIT_FAILURE);
}
free(ld);
}
free(bufi);
} else puts("Allocate input buffer error!");
fclose(fpo);
} else puts("Open output file error!");
fclose(fp);
} else puts("Open input file error!");
}
unsigned long get_start_ms() {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
}
#define CHOICE argv[1][1]
int main(int argc, char** argv) {
if(argc == 4) {
unsigned long t = get_start_ms();
switch(CHOICE){
case 'e': encode_file(argv[2], argv[3]); break;
case 'd': decode_file(argv[2], argv[3]); break;
default: break;
}
printf("spend time: %lums\n", get_start_ms() - t);
} else {
fputs("Usage: -[e|d] <inputfile> <outputfile>\n", stderr);
fputs("\t-e encode\n", stderr);
fputs("\t-d decode\n", stderr);
exit(EXIT_FAILURE);
}
return 0;
}

12
base16384.h Normal file
View File

@@ -0,0 +1,12 @@
#ifndef CPUBIT32
#ifndef CPUBIT64
#define CPUBIT32
#endif
#endif
#ifdef CPUBIT32
#include "./32/base1432le.h"
#endif
#ifdef CPUBIT64
#include "./64/base1464le.h"
#endif