|
@@ -1,466 +0,0 @@
|
|
|
-/*
|
|
|
- * neginf.c
|
|
|
- * neginf -- embedded inflate lib
|
|
|
- *
|
|
|
- * inflate routines
|
|
|
- */
|
|
|
-
|
|
|
-#include <assert.h>
|
|
|
-#include <stdlib.h>
|
|
|
-#include <stdio.h>
|
|
|
-
|
|
|
-#include "neginf.h"
|
|
|
-#include "neginf_priv.h"
|
|
|
-
|
|
|
-typedef void(*mode_fun)() ;
|
|
|
-
|
|
|
-static neginf_state state;
|
|
|
-static const mode_fun mode_tab[mode_count] = {
|
|
|
- &await_block,
|
|
|
- &raw_block_begin,
|
|
|
- &raw_block_begin2,
|
|
|
- &raw_block,
|
|
|
- &fixed_block_begin,
|
|
|
- &huff_block,
|
|
|
- &huff_len_addbits,
|
|
|
- &huff_dist,
|
|
|
- &huff_dist_addbits,
|
|
|
- &dynamic_block_begin,
|
|
|
- &dynamic_read_lc,
|
|
|
- &dynamic_read_lit_len,
|
|
|
- &dynamic_read_dist
|
|
|
-};
|
|
|
-
|
|
|
-void neginf_init(nsize start_pos)
|
|
|
-{
|
|
|
- state.queue_size = 0;
|
|
|
- state.mode = mode_await_block;
|
|
|
- state.last_block = 0;
|
|
|
-#ifdef NEGINF_POS_TRACKING
|
|
|
- state.output_pos = start_pos;
|
|
|
-#endif
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void neginf_process_byte(nbyte byte)
|
|
|
-{
|
|
|
- assert(state.queue_size <= 16);
|
|
|
- state.input_queue |= (byte << state.queue_size);
|
|
|
- state.queue_size += 8;
|
|
|
-
|
|
|
- while(state.queue_size >= 16)
|
|
|
- {
|
|
|
- //printf("qsize=%i mode=%i\n",state.queue_size,state.mode);
|
|
|
- mode_tab[state.mode]();
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef NEGINF_POS_TRACKING
|
|
|
-nsize neginf_output_position()
|
|
|
-{
|
|
|
- return state.output_pos;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-nint lookahead()
|
|
|
-{
|
|
|
- //printf("lookahead\n");
|
|
|
- return state.input_queue;
|
|
|
-}
|
|
|
-
|
|
|
-void consume(ntiny amount)
|
|
|
-{
|
|
|
- //printf("consume %i %i\n",state.queue_size,amount);
|
|
|
- assert(state.queue_size > amount);
|
|
|
- state.input_queue >>= amount;
|
|
|
- state.queue_size -= amount;
|
|
|
-}
|
|
|
-
|
|
|
-void await_block()
|
|
|
-{
|
|
|
- //printf("wait block\n");
|
|
|
- if(state.last_block)
|
|
|
- {
|
|
|
- neginf_cb_completed();
|
|
|
- consume(16);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- nint la = lookahead();
|
|
|
- state.last_block = la & 1;
|
|
|
- consume(3);
|
|
|
- switch(la & 6)
|
|
|
- {
|
|
|
- case 0: // 00 uncompressed
|
|
|
- consume((state.queue_size) & 7); // align to byte
|
|
|
- state.mode = mode_raw_block_begin;
|
|
|
- break;
|
|
|
- case 2: // 01 fixed huffman
|
|
|
- state.mode = mode_fixed_block_begin;
|
|
|
- break;
|
|
|
- case 4: // 10 dynamic huffman
|
|
|
- state.mode = mode_dynamic_block_begin;
|
|
|
- break;
|
|
|
- default:
|
|
|
- assert(0);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void raw_block_begin()
|
|
|
-{
|
|
|
- //printf("raw block begin\n");
|
|
|
- state.raw_size = lookahead() & 0xFFFF; // size of raw block
|
|
|
- consume(16);
|
|
|
- state.mode = mode_raw_block_begin2;
|
|
|
-}
|
|
|
-
|
|
|
-void raw_block_begin2()
|
|
|
-{
|
|
|
- //printf("raw block begin2\n");
|
|
|
- consume(16); // we ignore the inverted size
|
|
|
- state.mode = mode_raw_block;
|
|
|
-}
|
|
|
-
|
|
|
-void raw_block()
|
|
|
-{
|
|
|
- //printf("raw block\n");
|
|
|
- if(state.raw_size == 0)
|
|
|
- {
|
|
|
- state.mode = mode_await_block;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- state.raw_size--;
|
|
|
- neginf_cb_seq_byte(lookahead() & 0xFF);
|
|
|
-#ifdef NEGINF_POS_TRACKING
|
|
|
- state.output_pos++;
|
|
|
-#endif
|
|
|
- consume(8);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void fixed_block_begin()
|
|
|
-{
|
|
|
- //printf("fixed block begin\n");
|
|
|
-
|
|
|
- nint i = 0;
|
|
|
- for(; i < 144; i++)
|
|
|
- state.lit_len_lengths[i] = 8;
|
|
|
- for(; i < 256; i++)
|
|
|
- state.lit_len_lengths[i] = 9;
|
|
|
- for(; i < 280; i++)
|
|
|
- state.lit_len_lengths[i] = 7;
|
|
|
- for(; i < 288; i++)
|
|
|
- state.lit_len_lengths[i] = 8;
|
|
|
-
|
|
|
- ntiny j;
|
|
|
- for(j = 0; i < 32; i++)
|
|
|
- state.dist_lengths[i] = 5;
|
|
|
-
|
|
|
- compute_begins();
|
|
|
- state.mode = mode_huff_block;
|
|
|
-}
|
|
|
-
|
|
|
-void huff_block()
|
|
|
-{
|
|
|
- //printf("huff block\n");
|
|
|
- nint code = lit_len_read();
|
|
|
- if(code == 256)
|
|
|
- {
|
|
|
- state.mode = mode_await_block;
|
|
|
- }
|
|
|
- else if(code < 256)
|
|
|
- {
|
|
|
- neginf_cb_seq_byte(code);
|
|
|
-#ifdef NEGINF_POS_TRACKING
|
|
|
- state.output_pos++;
|
|
|
-#endif
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- state.code = code;
|
|
|
- state.mode = mode_huff_len_addbits;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void huff_len_addbits()
|
|
|
-{
|
|
|
- //printf("huff len addbits\n");
|
|
|
- nint len;
|
|
|
- nint code = state.code;
|
|
|
- nint la = lookahead();
|
|
|
- if(code < 265)
|
|
|
- len = code - 257 + 3;
|
|
|
- else if(code < 269)
|
|
|
- {
|
|
|
- len = (code - 265) * 2 + 11 + (la & 1);
|
|
|
- consume(1);
|
|
|
- }
|
|
|
- else if(code < 273)
|
|
|
- {
|
|
|
- len = (code - 269) * 4 + 19 + (la & 3);
|
|
|
- consume(2);
|
|
|
- }
|
|
|
- else if(code < 277)
|
|
|
- {
|
|
|
- len = (code - 273) * 8 + 35 + (la & 7);
|
|
|
- consume(3);
|
|
|
- }
|
|
|
- else if(code < 281)
|
|
|
- {
|
|
|
- len = (code - 277) * 16 + 67 + (la & 15);
|
|
|
- consume(4);
|
|
|
- }
|
|
|
- else if(code < 285)
|
|
|
- {
|
|
|
- len = (code - 281) * 32 + 131 + (la & 31);
|
|
|
- consume(5);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- len = 258;
|
|
|
- }
|
|
|
- state.match_len = len;
|
|
|
- state.mode = mode_huff_dist;
|
|
|
-}
|
|
|
-
|
|
|
-void huff_dist()
|
|
|
-{
|
|
|
- //printf("huff dist\n");
|
|
|
- state.tcode = dist_read();
|
|
|
- state.mode = mode_huff_dist_addbits;
|
|
|
-}
|
|
|
-
|
|
|
-void huff_dist_addbits()
|
|
|
-{
|
|
|
- //printf("huff addbits\n");
|
|
|
- nint dist;
|
|
|
- ntiny code = state.tcode;
|
|
|
-
|
|
|
- if(code < 4)
|
|
|
- {
|
|
|
- dist = code+1;
|
|
|
- }
|
|
|
- else if(code > 29)
|
|
|
- {
|
|
|
- assert(0);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- nint la = lookahead();
|
|
|
- ntiny len = (code - 2) / 2;
|
|
|
- dist = ((2 + (code & 1)) << len) + 1 + (((1 << len) - 1) & la);
|
|
|
- consume(len);
|
|
|
- }
|
|
|
- neginf_cb_rel_copy(dist, state.match_len);
|
|
|
-#ifdef NEGINF_POS_TRACKING
|
|
|
- state.output_pos += state.match_len;
|
|
|
-#endif
|
|
|
-
|
|
|
- state.mode = mode_huff_block;
|
|
|
-}
|
|
|
-
|
|
|
-void dynamic_block_begin()
|
|
|
-{
|
|
|
- nint j;
|
|
|
- ntiny i;
|
|
|
- //printf("dynamic block begin\n");
|
|
|
- for(j = 0; j < 288; j++)
|
|
|
- state.lit_len_lengths[j] = 0;
|
|
|
- for(i = 0; i < 32; i++)
|
|
|
- state.dist_lengths[i] = 0;
|
|
|
- for(i = 0; i < 19; i++)
|
|
|
- state.hc_lengths[i] = 0;
|
|
|
-
|
|
|
- nint la = lookahead();
|
|
|
- state.hlit = (la & 31) + 257;
|
|
|
- state.hdist = ((la >> 5) & 31) + 1;
|
|
|
- state.hclen = ((la >> 10) & 15) + 4;
|
|
|
- state.torder = 0;
|
|
|
- consume(5+5+4);
|
|
|
- state.mode = mode_dynamic_read_lc;
|
|
|
-}
|
|
|
-
|
|
|
-void dynamic_read_lc()
|
|
|
-{
|
|
|
- //printf("dynamic read lc\n");
|
|
|
- if(state.hclen == 0)
|
|
|
- {
|
|
|
- compute_begin(state.hc_lengths, state.hc_begins, 19);
|
|
|
- state.mode = mode_dynamic_read_lit_len;
|
|
|
- state.order = 0;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- static const ntiny order[19] = {
|
|
|
- 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
|
|
|
- };
|
|
|
- ntiny i = lookahead() & 7;
|
|
|
- state.hc_lengths[order[state.torder]] = i;
|
|
|
- consume(3);
|
|
|
-
|
|
|
- state.torder++;
|
|
|
- state.hclen--;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void dynamic_read_lit_len()
|
|
|
-{
|
|
|
- //printf("dynamic read lit len\n");
|
|
|
- if(state.hlit == 0)
|
|
|
- {
|
|
|
- state.mode = mode_dynamic_read_dist;
|
|
|
- state.order = 0;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- state.hlit -= lc_read(state.lit_len_lengths);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void dynamic_read_dist()
|
|
|
-{
|
|
|
- //printf("dynamic read dist\n");
|
|
|
- if(state.hdist == 0)
|
|
|
- {
|
|
|
- compute_begins();
|
|
|
- state.mode = mode_huff_block;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- state.hdist -= lc_read(state.dist_lengths);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-ntiny lc_read(ntiny * lenghts)
|
|
|
-{
|
|
|
- //printf("read lc\n");
|
|
|
- ntiny code = huff_read(state.hc_lengths, state.hc_begins, 19);
|
|
|
- // this reads 7 bits max so we still have 9 bits left in the buffer
|
|
|
- if(code < 16)
|
|
|
- {
|
|
|
- lenghts[state.order] = code;
|
|
|
- state.order++;
|
|
|
- return 1;
|
|
|
- }
|
|
|
- else if(code == 16)
|
|
|
- {
|
|
|
- ntiny i;
|
|
|
- ntiny copy = (lookahead() & 3) + 3;
|
|
|
- consume(2);
|
|
|
- for(i = 0; i < copy; i++)
|
|
|
- lenghts[state.order + i] = lenghts[state.order - 1];
|
|
|
- state.order += copy;
|
|
|
- return copy;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- ntiny fill;
|
|
|
- ntiny i;
|
|
|
-
|
|
|
- if(code == 17)
|
|
|
- {
|
|
|
- fill = (lookahead() & 7) + 3;
|
|
|
- consume(3);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- fill = (lookahead() & 127) + 11;
|
|
|
- consume(7);
|
|
|
- }
|
|
|
- for(i = 0; i < fill; i++)
|
|
|
- {
|
|
|
- lenghts[state.order] = 0;
|
|
|
- state.order++;
|
|
|
- }
|
|
|
- return fill;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void compute_begins()
|
|
|
-{
|
|
|
- //printf("compute begins\n");
|
|
|
- compute_begin(state.lit_len_lengths, state.lit_len_begins, 288);
|
|
|
- compute_begin(state.dist_lengths, state.dist_begins, 32);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void compute_begin(ntiny * lengths, nint * begins, nint size)
|
|
|
-{
|
|
|
- ntiny j;
|
|
|
- nint i;
|
|
|
- //printf("compute begin\n");
|
|
|
- for(j = 0; j < 14; j++)
|
|
|
- begins[j] = 0;
|
|
|
- for(i = 0; i < size; i++)
|
|
|
- {
|
|
|
- nint len = lengths[i];
|
|
|
- if(len != 0 && len != 15)
|
|
|
- begins[len-1] += 1 << (15 - len);
|
|
|
- }
|
|
|
- nint acc = 0;
|
|
|
- for(j = 0; j < 14; j++)
|
|
|
- {
|
|
|
- nint val = begins[j];
|
|
|
- acc += val;
|
|
|
- begins[j] = acc;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-nint lit_len_read()
|
|
|
-{
|
|
|
- //printf("lit len read\n");
|
|
|
-
|
|
|
- return huff_read(state.lit_len_lengths, state.lit_len_begins, 288);
|
|
|
-}
|
|
|
-
|
|
|
-nint dist_read()
|
|
|
-{
|
|
|
- //printf("dist read\n");
|
|
|
- return huff_read(state.dist_lengths, state.dist_begins, 32);
|
|
|
-}
|
|
|
-
|
|
|
-nint huff_read(ntiny * lenghts, nint * begins, nint size)
|
|
|
-{
|
|
|
- //printf("huff read\n");
|
|
|
- nint code = 0;
|
|
|
- ntiny i;
|
|
|
- for(i = 1; i < 16; i++)
|
|
|
- {
|
|
|
-
|
|
|
- code |= (lookahead() & 1) << (15-i);
|
|
|
- consume(1);
|
|
|
- if(i == 15 || code < begins[i-1])
|
|
|
- break;
|
|
|
- }
|
|
|
- code -= begins[i-2];
|
|
|
- code >>= (15-i);
|
|
|
- nint j;
|
|
|
- for(j = 0; j < size; j++)
|
|
|
- {
|
|
|
- if(lenghts[j] == i)
|
|
|
- {
|
|
|
- if(code == 0)
|
|
|
- return j;
|
|
|
- code--;
|
|
|
- }
|
|
|
- }
|
|
|
- //assert(0);
|
|
|
- return 0; // silent warning
|
|
|
-}
|
|
|
-
|
|
|
-#ifndef NEGINF_USE_SEQ_WRITES
|
|
|
-void neginf_cb_seq_byte(nbyte byte)
|
|
|
-{
|
|
|
- neginf_cb_byte(state.output_pos, byte);
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef NEGINF_USE_REL_COPY
|
|
|
-void neginf_cb_rel_copy(nint distance, nint length)
|
|
|
-{
|
|
|
- neginf_cb_copy(state.output_pos - distance, state.output_pos, length);
|
|
|
-}
|
|
|
-#endif
|