diff options
Diffstat (limited to 'cpan/Compress-Raw-Zlib/zlib-src/trees.c')
| -rw-r--r-- | cpan/Compress-Raw-Zlib/zlib-src/trees.c | 180 |
1 files changed, 79 insertions, 101 deletions
diff --git a/cpan/Compress-Raw-Zlib/zlib-src/trees.c b/cpan/Compress-Raw-Zlib/zlib-src/trees.c index d9c807d561..8c32b214b1 100644 --- a/cpan/Compress-Raw-Zlib/zlib-src/trees.c +++ b/cpan/Compress-Raw-Zlib/zlib-src/trees.c @@ -1,5 +1,5 @@ /* trees.c -- output deflated data using Huffman coding - * Copyright (C) 1995-2010 Jean-loup Gailly + * Copyright (C) 1995-2012 Jean-loup Gailly * detect_data_type() function provided freely by Cosmin Truta, 2006 * For conditions of distribution and use, see copyright notice in zlib.h */ @@ -74,11 +74,6 @@ local const uch bl_order[BL_CODES] * probability, to avoid transmitting the lengths for unused bit length codes. */ -#define Buf_size (8 * 2*sizeof(char)) -/* Number of bits used within bi_buf. (bi_buf might be implemented on - * more than 16 bits on some systems.) - */ - /* =========================================================================== * Local data. These are initialized only once. */ @@ -190,10 +185,10 @@ local void gen_trees_header OF((void)); #ifdef DEBUG local void send_bits OF((deflate_state *s, int value, int length)); -local void send_bits( - deflate_state *s, - int value, - int length) +local void send_bits(s, value, length) + deflate_state *s; + int value; /* value to send */ + int length; /* number of bits */ { Tracevv((stderr," l %2d v %4x ", length, value)); Assert(length > 0 && length <= 15, "invalid length"); @@ -383,8 +378,8 @@ void gen_trees_header() /* =========================================================================== * Initialize the tree data structures for a new zlib stream. */ -void ZLIB_INTERNAL _tr_init( - deflate_state *s) +void ZLIB_INTERNAL _tr_init(s) + deflate_state *s; { tr_static_init(); @@ -399,7 +394,6 @@ void ZLIB_INTERNAL _tr_init( s->bi_buf = 0; s->bi_valid = 0; - s->last_eob_len = 8; /* enough lookahead for inflate */ #ifdef DEBUG s->compressed_len = 0L; s->bits_sent = 0L; @@ -412,8 +406,8 @@ void ZLIB_INTERNAL _tr_init( /* =========================================================================== * Initialize a new block. */ -local void init_block( - deflate_state *s) +local void init_block(s) + deflate_state *s; { int n; /* iterates over tree elements */ @@ -456,10 +450,10 @@ local void init_block( * when the heap property is re-established (each father smaller than its * two sons). */ -local void pqdownheap( - deflate_state *s, - ct_data *tree, - int k) +local void pqdownheap(s, tree, k) + deflate_state *s; + ct_data *tree; /* the tree to restore */ + int k; /* node to move down */ { int v = s->heap[k]; int j = k << 1; /* left son of k */ @@ -491,9 +485,9 @@ local void pqdownheap( * The length opt_len is updated; static_len is also updated if stree is * not null. */ -local void gen_bitlen( - deflate_state *s, - tree_desc *desc) +local void gen_bitlen(s, desc) + deflate_state *s; + tree_desc *desc; /* the tree descriptor */ { ct_data *tree = desc->dyn_tree; int max_code = desc->max_code; @@ -578,10 +572,10 @@ local void gen_bitlen( * OUT assertion: the field code is set for all tree elements of non * zero code length. */ -local void gen_codes ( - ct_data *tree, - int max_code, - ushf *bl_count) +local void gen_codes (tree, max_code, bl_count) + ct_data *tree; /* the tree to decorate */ + int max_code; /* largest code with non zero frequency */ + ushf *bl_count; /* number of codes at each bit length */ { ush next_code[MAX_BITS+1]; /* next code value for each bit length */ ush code = 0; /* running code value */ @@ -620,9 +614,9 @@ local void gen_codes ( * and corresponding code. The length opt_len is updated; static_len is * also updated if stree is not null. The field max_code is set. */ -local void build_tree( - deflate_state *s, - tree_desc *desc) +local void build_tree(s, desc) + deflate_state *s; + tree_desc *desc; /* the tree descriptor */ { ct_data *tree = desc->dyn_tree; const ct_data *stree = desc->stat_desc->static_tree; @@ -708,10 +702,10 @@ local void build_tree( * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. */ -local void scan_tree ( - deflate_state *s, - ct_data *tree, - int max_code) +local void scan_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -753,10 +747,10 @@ local void scan_tree ( * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ -local void send_tree ( - deflate_state *s, - ct_data *tree, - int max_code) +local void send_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -804,8 +798,8 @@ local void send_tree ( * Construct the Huffman tree for the bit lengths and return the index in * bl_order of the last bit length code to send. */ -local int build_bl_tree( - deflate_state *s) +local int build_bl_tree(s) + deflate_state *s; { int max_blindex; /* index of last bit length code of non zero freq */ @@ -839,11 +833,9 @@ local int build_bl_tree( * lengths of the bit length codes, the literal tree and the distance tree. * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ -local void send_all_trees( - deflate_state *s, - int lcodes, - int dcodes, - int blcodes) +local void send_all_trees(s, lcodes, dcodes, blcodes) + deflate_state *s; + int lcodes, dcodes, blcodes; /* number of codes for each tree */ { int rank; /* index in bl_order */ @@ -870,11 +862,11 @@ local void send_all_trees( /* =========================================================================== * Send a stored block */ -void ZLIB_INTERNAL _tr_stored_block( - deflate_state *s, - charf *buf, - ulg stored_len, - int last) +void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ { send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ #ifdef DEBUG @@ -885,18 +877,20 @@ void ZLIB_INTERNAL _tr_stored_block( } /* =========================================================================== + * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) + */ +void ZLIB_INTERNAL _tr_flush_bits(s) + deflate_state *s; +{ + bi_flush(s); +} + +/* =========================================================================== * Send one empty static block to give enough lookahead for inflate. * This takes 10 bits, of which 7 may remain in the bit buffer. - * The current inflate code requires 9 bits of lookahead. If the - * last two codes for the previous block (real code plus EOB) were coded - * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode - * the last real code. In this case we send two empty static blocks instead - * of one. (There are no problems if the previous block is stored or fixed.) - * To simplify the code, we assume the worst case of last real code encoded - * on one bit only. */ -void ZLIB_INTERNAL _tr_align( - deflate_state *s) +void ZLIB_INTERNAL _tr_align(s) + deflate_state *s; { send_bits(s, STATIC_TREES<<1, 3); send_code(s, END_BLOCK, static_ltree); @@ -904,31 +898,17 @@ void ZLIB_INTERNAL _tr_align( s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ #endif bi_flush(s); - /* Of the 10 bits for the empty block, we have already sent - * (10 - bi_valid) bits. The lookahead for the last real code (before - * the EOB of the previous block) was thus at least one plus the length - * of the EOB plus what we have just sent of the empty static block. - */ - if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { - send_bits(s, STATIC_TREES<<1, 3); - send_code(s, END_BLOCK, static_ltree); -#ifdef DEBUG - s->compressed_len += 10L; -#endif - bi_flush(s); - } - s->last_eob_len = 7; } /* =========================================================================== * Determine the best encoding for the current block: dynamic trees, static * trees or store, and output the encoded block to the zip file. */ -void ZLIB_INTERNAL _tr_flush_block( - deflate_state *s, - charf *buf, - ulg stored_len, - int last) +void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block, or NULL if too old */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ { ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ int max_blindex = 0; /* index of last bit length code of non zero freq */ @@ -1025,10 +1005,10 @@ void ZLIB_INTERNAL _tr_flush_block( * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ -int ZLIB_INTERNAL _tr_tally ( - deflate_state *s, - unsigned dist, - unsigned lc) +int ZLIB_INTERNAL _tr_tally (s, dist, lc) + deflate_state *s; + unsigned dist; /* distance of matched string */ + unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ { s->d_buf[s->last_lit] = (ush)dist; s->l_buf[s->last_lit++] = (uch)lc; @@ -1075,10 +1055,10 @@ int ZLIB_INTERNAL _tr_tally ( /* =========================================================================== * Send the block data compressed using the given Huffman trees */ -local void compress_block( - deflate_state *s, - ct_data *ltree, - ct_data *dtree) +local void compress_block(s, ltree, dtree) + deflate_state *s; + ct_data *ltree; /* literal tree */ + ct_data *dtree; /* distance tree */ { unsigned dist; /* distance of matched string */ int lc; /* match length or unmatched char (if dist == 0) */ @@ -1120,7 +1100,6 @@ local void compress_block( } while (lx < s->last_lit); send_code(s, END_BLOCK, ltree); - s->last_eob_len = ltree[END_BLOCK].Len; } /* =========================================================================== @@ -1136,8 +1115,8 @@ local void compress_block( * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). * IN assertion: the fields Freq of dyn_ltree are set. */ -local int detect_data_type( - deflate_state *s) +local int detect_data_type(s) + deflate_state *s; { /* black_mask is the bit mask of black-listed bytes * set bits 0..6, 14..25, and 28..31 @@ -1170,9 +1149,9 @@ local int detect_data_type( * method would use a table) * IN assertion: 1 <= len <= 15 */ -local unsigned bi_reverse( - unsigned code, - int len) +local unsigned bi_reverse(code, len) + unsigned code; /* the value to invert */ + int len; /* its bit length */ { register unsigned res = 0; do { @@ -1185,8 +1164,8 @@ local unsigned bi_reverse( /* =========================================================================== * Flush the bit buffer, keeping at most 7 bits in it. */ -local void bi_flush( - deflate_state *s) +local void bi_flush(s) + deflate_state *s; { if (s->bi_valid == 16) { put_short(s, s->bi_buf); @@ -1202,8 +1181,8 @@ local void bi_flush( /* =========================================================================== * Flush the bit buffer and align the output on a byte boundary */ -local void bi_windup( - deflate_state *s) +local void bi_windup(s) + deflate_state *s; { if (s->bi_valid > 8) { put_short(s, s->bi_buf); @@ -1221,14 +1200,13 @@ local void bi_windup( * Copy a stored block, storing first the length and its * one's complement if requested. */ -local void copy_block( - deflate_state *s, - charf *buf, - unsigned len, - int header) +local void copy_block(s, buf, len, header) + deflate_state *s; + charf *buf; /* the input data */ + unsigned len; /* its length */ + int header; /* true if block header must be written */ { bi_windup(s); /* align on byte boundary */ - s->last_eob_len = 8; /* enough lookahead for inflate */ if (header) { put_short(s, (ush)len); |