mirror of
https://github.com/0x5eal/rbxts-pako.git
synced 2025-04-04 10:50:59 +01:00
added the rest or deflate_* functions
This commit is contained in:
Vitaly Puzrin
parent
7644f9f3db
commit
f643adbbcf
1 changed files with 299 additions and 4 deletions
|
|
@ -631,28 +631,323 @@ function deflate_fast(s, flush) {
|
|||
* evaluation for matches: a match is finally adopted only if there is
|
||||
* no better match at the next window position.
|
||||
*/
|
||||
function deflate_slow(/*s, flush*/) {
|
||||
function deflate_slow(s, flush) {
|
||||
var hash_head; /* head of hash chain */
|
||||
var bflush; /* set if current block must be flushed */
|
||||
|
||||
var max_insert;
|
||||
|
||||
/* Process the input block. */
|
||||
for (;;) {
|
||||
/* Make sure that we always have enough lookahead, except
|
||||
* at the end of the input file. We need MAX_MATCH bytes
|
||||
* for the next match, plus MIN_MATCH bytes to insert the
|
||||
* string following the next match.
|
||||
*/
|
||||
if (s.lookahead < MIN_LOOKAHEAD) {
|
||||
fill_window(s);
|
||||
if (s.lookahead < MIN_LOOKAHEAD && flush === c.Z_NO_FLUSH) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
if (s.lookahead === 0) { break; } /* flush the current block */
|
||||
}
|
||||
|
||||
/* Insert the string window[strstart .. strstart+2] in the
|
||||
* dictionary, and set hash_head to the head of the hash chain:
|
||||
*/
|
||||
hash_head = NIL;
|
||||
if (s.lookahead >= MIN_MATCH) {
|
||||
/*** INSERT_STRING(s, s.strstart, hash_head); ***/
|
||||
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
|
||||
hash_head = (s.head[s.ins_h] & 0xffff);
|
||||
s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
|
||||
s.head[s.ins_h] = s.strstart;
|
||||
/***/
|
||||
}
|
||||
|
||||
/* Find the longest match, discarding those <= prev_length.
|
||||
*/
|
||||
s.prev_length = s.match_length;
|
||||
s.prev_match = s.match_start;
|
||||
s.match_length = MIN_MATCH-1;
|
||||
|
||||
if (hash_head !== NIL && s.prev_length < s.max_lazy_match &&
|
||||
s.strstart - hash_head <= (s.w_size-MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {
|
||||
/* To simplify the code, we prevent matches with the string
|
||||
* of window index 0 (in particular we have to avoid a match
|
||||
* of the string with itself at the start of the input file).
|
||||
*/
|
||||
s.match_length = longest_match(s, hash_head);
|
||||
/* longest_match() sets match_start */
|
||||
|
||||
if (s.match_length <= 5 &&
|
||||
(s.strategy === c.Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {
|
||||
|
||||
/* If prev_match is also MIN_MATCH, match_start is garbage
|
||||
* but we will ignore the current match anyway.
|
||||
*/
|
||||
s.match_length = MIN_MATCH-1;
|
||||
}
|
||||
}
|
||||
/* If there was a match at the previous step and the current
|
||||
* match is not better, output the previous match:
|
||||
*/
|
||||
if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
|
||||
max_insert = s.strstart + s.lookahead - MIN_MATCH;
|
||||
/* Do not insert strings in hash table beyond this. */
|
||||
|
||||
//check_match(s, s.strstart-1, s.prev_match, s.prev_length);
|
||||
|
||||
/***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
|
||||
s.prev_length - MIN_MATCH, bflush);***/
|
||||
bflush = trees._tr_tally(s, s.strstart - 1- s.match_start, s.prev_length - MIN_MATCH);
|
||||
|
||||
/* Insert in hash table all strings up to the end of the match.
|
||||
* strstart-1 and strstart are already inserted. If there is not
|
||||
* enough lookahead, the last two strings are not inserted in
|
||||
* the hash table.
|
||||
*/
|
||||
s.lookahead -= s.prev_length-1;
|
||||
s.prev_length -= 2;
|
||||
do {
|
||||
if (++s.strstart <= max_insert) {
|
||||
/*** INSERT_STRING(s, s.strstart, hash_head); ***/
|
||||
s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
|
||||
hash_head = (s.head[s.ins_h] & 0xffff);
|
||||
s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
|
||||
s.head[s.ins_h] = s.strstart;
|
||||
/***/
|
||||
}
|
||||
} while (--s.prev_length !== 0);
|
||||
s.match_available = 0;
|
||||
s.match_length = MIN_MATCH-1;
|
||||
s.strstart++;
|
||||
|
||||
if (bflush) {
|
||||
/*** FLUSH_BLOCK(s, 0); ***/
|
||||
flush_block_only(s, false);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
/***/
|
||||
}
|
||||
|
||||
} else if (s.match_available) {
|
||||
/* If there was no match at the previous position, output a
|
||||
* single literal. If there was a match but the current match
|
||||
* is longer, truncate the previous match to a single literal.
|
||||
*/
|
||||
//Tracevv((stderr,"%c", s->window[s->strstart-1]));
|
||||
/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
|
||||
bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]);
|
||||
|
||||
if (bflush) {
|
||||
/*** FLUSH_BLOCK(s, 0); ***/
|
||||
flush_block_only(s, false);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
/***/
|
||||
}
|
||||
s.strstart++;
|
||||
s.lookahead--;
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
} else {
|
||||
/* There is no previous match to compare with, wait for
|
||||
* the next step to decide.
|
||||
*/
|
||||
s.match_available = 1;
|
||||
s.strstart++;
|
||||
s.lookahead--;
|
||||
}
|
||||
}
|
||||
//Assert (flush != Z_NO_FLUSH, "no flush?");
|
||||
if (s.match_available) {
|
||||
//Tracevv((stderr,"%c", s->window[s->strstart-1]));
|
||||
/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
|
||||
bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]);
|
||||
|
||||
s.match_available = 0;
|
||||
}
|
||||
s.insert = s.strstart < MIN_MATCH-1 ? s.strstart : MIN_MATCH-1;
|
||||
if (flush === c.Z_FINISH) {
|
||||
/*** FLUSH_BLOCK(s, 1); ***/
|
||||
flush_block_only(s, true);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_FINISH_STARTED;
|
||||
}
|
||||
/***/
|
||||
return BS_FINISH_DONE;
|
||||
}
|
||||
if (s.last_lit) {
|
||||
/*** FLUSH_BLOCK(s, 0); ***/
|
||||
flush_block_only(s, false);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
/***/
|
||||
}
|
||||
|
||||
return BS_BLOCK_DONE;
|
||||
}
|
||||
|
||||
|
||||
/* ===========================================================================
|
||||
* For Z_RLE, simply look for runs of bytes, generate matches only of distance
|
||||
* one. Do not maintain a hash table. (It will be regenerated if this run of
|
||||
* deflate switches away from Z_RLE.)
|
||||
*/
|
||||
function deflate_rle(/*s, flush*/) {
|
||||
function deflate_rle(s, flush) {
|
||||
var bflush; /* set if current block must be flushed */
|
||||
var prev; /* byte at distance one to match */
|
||||
var scan, strend; /* scan goes up to strend for length of run */
|
||||
|
||||
var _win = s.window;
|
||||
|
||||
for (;;) {
|
||||
/* Make sure that we always have enough lookahead, except
|
||||
* at the end of the input file. We need MAX_MATCH bytes
|
||||
* for the longest run, plus one for the unrolled loop.
|
||||
*/
|
||||
if (s.lookahead <= MAX_MATCH) {
|
||||
fill_window(s);
|
||||
if (s.lookahead <= MAX_MATCH && flush === c.Z_NO_FLUSH) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
if (s.lookahead === 0) { break; } /* flush the current block */
|
||||
}
|
||||
|
||||
/* See how many times the previous byte repeats */
|
||||
s.match_length = 0;
|
||||
if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
|
||||
scan = s.strstart - 1;
|
||||
prev = _win[scan];
|
||||
if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
|
||||
strend = s.strstart + MAX_MATCH;
|
||||
do {
|
||||
/*jshint noempty:false*/
|
||||
} while (prev === _win[++scan] && prev === _win[++scan] &&
|
||||
prev === _win[++scan] && prev === _win[++scan] &&
|
||||
prev === _win[++scan] && prev === _win[++scan] &&
|
||||
prev === _win[++scan] && prev === _win[++scan] &&
|
||||
scan < strend);
|
||||
s.match_length = MAX_MATCH - (strend - scan);
|
||||
if (s.match_length > s.lookahead) {
|
||||
s.match_length = s.lookahead;
|
||||
}
|
||||
}
|
||||
//Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
|
||||
}
|
||||
|
||||
/* Emit match if have run of MIN_MATCH or longer, else emit literal */
|
||||
if (s.match_length >= MIN_MATCH) {
|
||||
//check_match(s, s.strstart, s.strstart - 1, s.match_length);
|
||||
|
||||
/*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
|
||||
bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
|
||||
|
||||
s.lookahead -= s.match_length;
|
||||
|
||||
s.lookahead -= s.match_length;
|
||||
s.strstart += s.match_length;
|
||||
s.match_length = 0;
|
||||
} else {
|
||||
/* No match, output a literal byte */
|
||||
//Tracevv((stderr,"%c", s->window[s->strstart]));
|
||||
/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
|
||||
bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
|
||||
|
||||
s.lookahead--;
|
||||
s.strstart++;
|
||||
}
|
||||
if (bflush) {
|
||||
/*** FLUSH_BLOCK(s, 0); ***/
|
||||
flush_block_only(s, false);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
/***/
|
||||
}
|
||||
}
|
||||
s.insert = 0;
|
||||
if (flush === c.Z_FINISH) {
|
||||
/*** FLUSH_BLOCK(s, 1); ***/
|
||||
flush_block_only(s, true);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_FINISH_STARTED;
|
||||
}
|
||||
/***/
|
||||
return BS_FINISH_DONE;
|
||||
}
|
||||
if (s.last_lit) {
|
||||
/*** FLUSH_BLOCK(s, 0); ***/
|
||||
flush_block_only(s, false);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
/***/
|
||||
}
|
||||
return BS_BLOCK_DONE;
|
||||
}
|
||||
|
||||
/* ===========================================================================
|
||||
* For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table.
|
||||
* (It will be regenerated if this run of deflate switches away from Huffman.)
|
||||
*/
|
||||
function deflate_huff(/*s, flush*/) {
|
||||
function deflate_huff(s, flush) {
|
||||
var bflush; /* set if current block must be flushed */
|
||||
|
||||
for (;;) {
|
||||
/* Make sure that we have a literal to write. */
|
||||
if (s.lookahead === 0) {
|
||||
fill_window(s);
|
||||
if (s.lookahead === 0) {
|
||||
if (flush === c.Z_NO_FLUSH) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
break; /* flush the current block */
|
||||
}
|
||||
}
|
||||
|
||||
/* Output a literal byte */
|
||||
s.match_length = 0;
|
||||
//Tracevv((stderr,"%c", s->window[s->strstart]));
|
||||
/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
|
||||
bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
|
||||
s.lookahead--;
|
||||
s.strstart++;
|
||||
if (bflush) {
|
||||
/*** FLUSH_BLOCK(s, 0); ***/
|
||||
flush_block_only(s, false);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
/***/
|
||||
}
|
||||
}
|
||||
s.insert = 0;
|
||||
if (flush === c.Z_FINISH) {
|
||||
/*** FLUSH_BLOCK(s, 1); ***/
|
||||
flush_block_only(s, true);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_FINISH_STARTED;
|
||||
}
|
||||
/***/
|
||||
return BS_FINISH_DONE;
|
||||
}
|
||||
if (s.last_lit) {
|
||||
/*** FLUSH_BLOCK(s, 0); ***/
|
||||
flush_block_only(s, false);
|
||||
if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;
|
||||
}
|
||||
/***/
|
||||
}
|
||||
return BS_BLOCK_DONE;
|
||||
}
|
||||
|
||||
|
||||
/* Values for max_lazy_match, good_match and max_chain_length, depending on
|
||||
* the desired pack level (0..9). The values given below have been tuned to
|
||||
* exclude worst case performance for pathological files. Better values may be
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue