int main(void)
{
unsigned char outbuf[DICTSIZE];
unsigned char *outbuf_end = outbuf + DICTSIZE;
struct lzw_state enc;
struct lzw_state dec;
for(unsigned n = 0; tests[n]; n++) {
char *input = tests[n];
unsigned compressed[1024];
unsigned char output[1024];
printf(" input: %s\n", input);
lzw_state_init(&enc);
unsigned *comp_curs = &compressed[0];
unsigned complen = 0;
for(unsigned i = 0; input[i]; i++)
comp_curs += lzw_encode(&enc, input[i], comp_curs);
comp_curs += lzw_encode_finish(&enc, comp_curs);
complen = comp_curs - compressed;
printf("compressed: ");
for(unsigned i = 0; i < complen; i++) {
printf("%u (", compressed[i]);
print_dict_item(&enc, compressed[i]);
printf(") ");
}
printf("\n");
memset(output, 0, sizeof(output));
lzw_state_init(&dec);
unsigned char *dec_curs = &output[0];
for(unsigned i = 0; i < complen; i++) {
unsigned char *outbuf_curs = lzw_decode(&dec, compressed[i], outbuf);
memcpy(dec_curs, outbuf_curs, (outbuf_end - outbuf_curs));
dec_curs += (outbuf_end - outbuf_curs);
}
unsigned declen = dec_curs - output;
printf("output: %*s (%u)\n\n", declen, output, declen);
for(unsigned i = 0; input[i]; i++)
assert(input[i] == output[i]);
assert(declen == strlen(input));
}
return 0;
}
void assert_lzw(char *plain) {
memset(enc_buf, 0, sizeof(enc_buf));
memset(res_buf, 0, sizeof(res_buf));
size_t esz = lzw_encode(plain, strlen(plain), enc_buf);
lzw_decode(enc_buf, esz, res_buf);
char *input = plain;
char *output = res_buf;
while (*input) {
if (*input++ != *output++) {
res_buf[4095] = 0;
fprintf(stderr, "\x1b[41mTEST FAILED: %s == %s\x1b[0m\n", plain, res_buf);
failed = true;
return;
}
}
fprintf(stderr, "\x1b[42mTEST PASSED: \"%s\" == \"%s\"\x1b[0m\n", plain, res_buf);
}
void *mgif_play(void *mgif) //dekoduje a zobrazi frame
{
char *pf,*pc,*ff;
int acts,size,act,csize;
void *scr_sav;
int scr_act=-1;
pf=mgif;
acts=*pf++;
size=(*(int *)pf) & 0xffffff;
pf+=3;pc=pf;pf+=size;
if (acts)
do
{
act=*pc++;csize=(*(int *)pc) & 0xffffff;pc+=3;
if (act==MGIF_LZW || act==MGIF_DELTA)
{
ff=lzw_buffer;
lzw_decode(pc,ff);
scr_sav=ff;
scr_act=act;
}
else if (act==MGIF_COPY)
{
scr_sav=ff;scr_act=act;
}
else
{
ff=pc;
show_proc(act,ff,csize);
}
pc+=csize;
}
while (--acts);
if (scr_act!=-1) show_proc(scr_act,scr_sav,csize);
cur_frame+=1;
if (cur_frame==mgif_frames) return NULL;
return pf;
}
int main(int argc, char **argv) {
#if 1
bitstream_t bs = {};
bs.data = malloc(1000000);
memset(bs.data, 0, 1000000);
{
write_bits(&bs, 1, 0b1);
ASSERT_EQ(bs.data[0], 0b00000001);
ASSERT_EQ(bs.bit, 1);
ASSERT_EQ(bs.index, 0);
fprintf(stderr, "\n");
write_bits(&bs, 4, 0b1010);
ASSERT_EQ(bs.data[0], 0b00010101);
ASSERT_EQ(bs.bit, 5);
ASSERT_EQ(bs.index, 0);
fprintf(stderr, "\n");
write_bits(&bs, 3, 0b101);
ASSERT_EQ(bs.data[0], 0b10110101);
ASSERT_EQ(bs.bit, 0);
ASSERT_EQ(bs.index, 1);
fprintf(stderr, "\n");
write_bits(&bs, 5, 0b11011);
ASSERT_EQ(bs.data[0], 0b10110101);
ASSERT_EQ(bs.data[1], 0b00011011);
ASSERT_EQ(bs.bit, 5);
ASSERT_EQ(bs.index, 1);
fprintf(stderr, "\n");
write_bits(&bs, 5, 0b10110);
ASSERT_EQ(bs.data[0], 0b10110101);
ASSERT_EQ(bs.data[1], 0b11011011);
ASSERT_EQ(bs.data[2], 0b00000010);
ASSERT_EQ(bs.bit, 2);
ASSERT_EQ(bs.index, 2);
fprintf(stderr, "\n");
write_bits(&bs, 20, 0xABCDE);
ASSERT_EQ(bs.data[0], 0b10110101);
ASSERT_EQ(bs.data[1], 0b11011011);
ASSERT_EQ(bs.data[2], 0b01111010);
ASSERT_EQ(bs.data[3], 0b11110011);
ASSERT_EQ(bs.data[4], 0b00101010);
ASSERT_EQ(bs.bit, 6);
ASSERT_EQ(bs.index, 4);
fprintf(stderr, "\n");
write_bits(&bs, 1, 0);
ASSERT_EQ(bs.data[0], 0b10110101);
ASSERT_EQ(bs.data[1], 0b11011011);
ASSERT_EQ(bs.data[2], 0b01111010);
ASSERT_EQ(bs.data[3], 0b11110011);
ASSERT_EQ(bs.data[4], 0b00101010);
ASSERT_EQ(bs.bit, 7);
ASSERT_EQ(bs.index, 4);
fprintf(stderr, "\n");
}
{
ASSERT_EQ(extract_bits(0b11011011, 0, 8), 0b11011011);
ASSERT_EQ(extract_bits(0b00000001, 0, 1), 0b1);
ASSERT_EQ(extract_bits(0b11111110, 0, 1), 0b0);
ASSERT_EQ(extract_bits(0b01111111, 7, 8), 0b0);
ASSERT_EQ(extract_bits(0b10000000, 7, 8), 0b1);
ASSERT_EQ(extract_bits(0b11011011, 2, 6), 0b0110);
fprintf(stderr, "\n");
}
bs.index = 0;
bs.bit = 0;
{
ASSERT_EQ(read_bits(&bs, 1), 0b1);
ASSERT_EQ(read_bits(&bs, 4), 0b1010);
ASSERT_EQ(read_bits(&bs, 3), 0b101);
ASSERT_EQ(read_bits(&bs, 5), 0b11011);
ASSERT_EQ(read_bits(&bs, 5), 0b10110);
ASSERT_EQ(read_bits(&bs, 20), 0xABCDE);
ASSERT_EQ(read_bits(&bs, 1), 0);
fprintf(stderr, "\n");
}
assert_lzw("ababcbababaaaaaaa");
assert_lzw("A circular buffer, or ring buffer, is a FIFO container consisting of a fixed-size buffer and head & tail indices. The head index is incremented as items are added and the tail index when items are removed.");
if (failed) {
return 1;
}
#endif
#if 1
// void *ibuff = malloc(10000000);
// memset(ibuff, 0, 10000000);
// void *obuff = malloc(10000000);
// memset(obuff, 0, 10000000);
// int *ebuff = malloc(10000000);
// memset(ebuff, 0, 10000000);
size_t rsz = read(STDIN_FILENO, ibuff, 10000000);
size_t esz = lzw_encode(ibuff, rsz, ebuff);
lzw_decode(ebuff, esz, obuff);
write(STDOUT_FILENO, obuff, rsz);
fprintf(stderr, "input size: %lu; compressed size: %lu; rate: %f\n", rsz, esz, (float)esz/(float)rsz);
#endif
}
