X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/197dd9af26230291b156c504506fed47a4d7420b..de628f984b1f5f57995d9ca3c26dfe79fa3dae59:/src/zlib/trees.c diff --git a/src/zlib/trees.c b/src/zlib/trees.c index 524c675870..d37dff4951 100644 --- a/src/zlib/trees.c +++ b/src/zlib/trees.c @@ -1,6 +1,6 @@ /* trees.c -- output deflated data using Huffman coding - * Copyright (C) 1995-1998 Jean-loup Gailly - * For conditions of distribution and use, see copyright notice in zlib.h + * Copyright (C) 1995-2002 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h */ /* @@ -189,10 +189,14 @@ local void gen_trees_header OF((void)); #ifdef __WXDEBUG__ local void send_bits OF((deflate_state *s, int value, int length)); +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void send_bits(deflate_state* s, int value, int length) +#else local void send_bits(s, value, length) deflate_state *s; int value; /* value to send */ int length; /* number of bits */ +#endif { Tracevv((stderr," l %2d v %4x ", length, value)); Assert(length > 0 && length <= 15, "invalid length"); @@ -250,6 +254,13 @@ local void tr_static_init() if (static_init_done) return; + /* For some embedded targets, global variables are not initialized: */ + static_l_desc.static_tree = static_ltree; + static_l_desc.extra_bits = extra_lbits; + static_d_desc.static_tree = static_dtree; + static_d_desc.extra_bits = extra_dbits; + static_bl_desc.extra_bits = extra_blbits; + /* Initialize the mapping length (0..255) -> length code (0..28) */ length = 0; for (code = 0; code < LENGTH_CODES-1; code++) { @@ -373,13 +384,15 @@ void gen_trees_header() /* =========================================================================== * Initialize the tree data structures for a new zlib stream. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +void _tr_init(deflate_state* s) +#else void _tr_init(s) deflate_state *s; +#endif { tr_static_init(); - s->compressed_len = 0L; - s->l_desc.dyn_tree = s->dyn_ltree; s->l_desc.stat_desc = &static_l_desc; @@ -393,6 +406,7 @@ void _tr_init(s) s->bi_valid = 0; s->last_eob_len = 8; /* enough lookahead for inflate */ #ifdef __WXDEBUG__ + s->compressed_len = 0L; s->bits_sent = 0L; #endif @@ -403,8 +417,12 @@ void _tr_init(s) /* =========================================================================== * Initialize a new block. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void init_block(deflate_state* s) +#else local void init_block(s) deflate_state *s; +#endif { int n; /* iterates over tree elements */ @@ -447,10 +465,14 @@ local void init_block(s) * when the heap property is re-established (each father smaller than its * two sons). */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void pqdownheap(deflate_state* s, ct_data* tree, int k) +#else local void pqdownheap(s, tree, k) deflate_state *s; ct_data *tree; /* the tree to restore */ int k; /* node to move down */ +#endif { int v = s->heap[k]; int j = k << 1; /* left son of k */ @@ -482,9 +504,13 @@ local void pqdownheap(s, tree, k) * The length opt_len is updated; static_len is also updated if stree is * not null. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void gen_bitlen(deflate_state* s, tree_desc* desc) +#else local void gen_bitlen(s, desc) deflate_state *s; tree_desc *desc; /* the tree descriptor */ +#endif { ct_data *tree = desc->dyn_tree; int max_code = desc->max_code; @@ -569,10 +595,14 @@ local void gen_bitlen(s, desc) * OUT assertion: the field code is set for all tree elements of non * zero code length. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void gen_codes (ct_data* tree, int max_code, ushf* bl_count) +#else 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 */ +#endif { ush next_code[MAX_BITS+1]; /* next code value for each bit length */ ush code = 0; /* running code value */ @@ -588,7 +618,7 @@ local void gen_codes (tree, max_code, bl_count) /* Check that the bit counts in bl_count are consistent. The last code * must be all ones. */ - Assert (code + bl_count[MAX_BITS]-1 == (ush)(1<dyn_tree; const ct_data *stree = desc->stat_desc->static_tree; @@ -698,10 +732,14 @@ local void build_tree(s, desc) * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void scan_tree (deflate_state* s, ct_data* tree, int max_code) +#else 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 */ +#endif { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -743,10 +781,14 @@ local void scan_tree (s, tree, max_code) * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void send_tree (deflate_state* s, ct_data* tree, int max_code) +#else 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 */ +#endif { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -794,8 +836,12 @@ local void send_tree (s, tree, max_code) * Construct the Huffman tree for the bit lengths and return the index in * bl_order of the last bit length code to send. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local int build_bl_tree( deflate_state* s) +#else local int build_bl_tree(s) deflate_state *s; +#endif { int max_blindex; /* index of last bit length code of non zero freq */ @@ -829,9 +875,13 @@ local int build_bl_tree(s) * lengths of the bit length codes, the literal tree and the distance tree. * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void send_all_trees(deflate_state* s, int lcodes, int dcodes, int blcodes) +#else local void send_all_trees(s, lcodes, dcodes, blcodes) deflate_state *s; int lcodes, dcodes, blcodes; /* number of codes for each tree */ +#endif { int rank; /* index in bl_order */ @@ -858,16 +908,21 @@ local void send_all_trees(s, lcodes, dcodes, blcodes) /* =========================================================================== * Send a stored block */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +void _tr_stored_block(deflate_state* s, charf* buf, ulg stored_len, int eof) +#else void _tr_stored_block(s, buf, stored_len, eof) deflate_state *s; charf *buf; /* input block */ ulg stored_len; /* length of input block */ int eof; /* true if this is the last block for a file */ +#endif { send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ +#ifdef __WXDEBUG__ s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; s->compressed_len += (stored_len + 4) << 3; - +#endif copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ } @@ -882,12 +937,18 @@ void _tr_stored_block(s, buf, stored_len, eof) * To simplify the code, we assume the worst case of last real code encoded * on one bit only. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +void _tr_align(deflate_state* s) +#else void _tr_align(s) deflate_state *s; +#endif { send_bits(s, STATIC_TREES<<1, 3); send_code(s, END_BLOCK, static_ltree); +#ifdef __WXDEBUG__ 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 @@ -897,7 +958,9 @@ void _tr_align(s) 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 __WXDEBUG__ s->compressed_len += 10L; +#endif bi_flush(s); } s->last_eob_len = 7; @@ -905,14 +968,17 @@ void _tr_align(s) /* =========================================================================== * Determine the best encoding for the current block: dynamic trees, static - * trees or store, and output the encoded block to the zip file. This function - * returns the total compressed length for the file so far. + * trees or store, and output the encoded block to the zip file. */ -ulg _tr_flush_block(s, buf, stored_len, eof) +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +void _tr_flush_block(deflate_state* s, charf* buf, ulg stored_len, int eof) +#else +void _tr_flush_block(s, buf, stored_len, eof) deflate_state *s; charf *buf; /* input block, or NULL if too old */ ulg stored_len; /* length of input block */ int eof; /* true if this is the last block for a file */ +#endif { 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 */ @@ -955,25 +1021,6 @@ ulg _tr_flush_block(s, buf, stored_len, eof) opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ } - /* If compression failed and this is the first and last block, - * and if the .zip file can be seeked (to rewrite the local header), - * the whole file is transformed into a stored file: - */ -#ifdef STORED_FILE_OK -# ifdef FORCE_STORED_FILE - if (eof && s->compressed_len == 0L) { /* force stored file */ -# else - if (stored_len <= opt_lenb && eof && s->compressed_len==0L && seekable()) { -# endif - /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */ - if (buf == (charf*)0) error ("block vanished"); - - copy_block(buf, (unsigned)stored_len, 0); /* without header */ - s->compressed_len = stored_len << 3; - s->method = STORED; - } else -#endif /* STORED_FILE_OK */ - #ifdef FORCE_STORED if (buf != (char*)0) { /* force stored block */ #else @@ -995,35 +1042,46 @@ ulg _tr_flush_block(s, buf, stored_len, eof) #endif send_bits(s, (STATIC_TREES<<1)+eof, 3); compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); +#ifdef __WXDEBUG__ s->compressed_len += 3 + s->static_len; +#endif } else { send_bits(s, (DYN_TREES<<1)+eof, 3); send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, max_blindex+1); compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); +#ifdef __WXDEBUG__ s->compressed_len += 3 + s->opt_len; +#endif } Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uLong implemented on 32 bits. + */ init_block(s); if (eof) { bi_windup(s); +#ifdef __WXDEBUG__ s->compressed_len += 7; /* align on byte boundary */ +#endif } Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, s->compressed_len-7*eof)); - - return s->compressed_len >> 3; } /* =========================================================================== * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +int _tr_tally (deflate_state* s, unsigned dist, unsigned lc) +#else int _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) */ +#endif { s->d_buf[s->last_lit] = (ush)dist; s->l_buf[s->last_lit++] = (uch)lc; @@ -1070,10 +1128,14 @@ int _tr_tally (s, dist, lc) /* =========================================================================== * Send the block data compressed using the given Huffman trees */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void compress_block(deflate_state* s, ct_data* ltree, ct_data* dtree) +#else local void compress_block(s, ltree, dtree) deflate_state *s; ct_data *ltree; /* literal tree */ ct_data *dtree; /* distance tree */ +#endif { unsigned dist; /* distance of matched string */ int lc; /* match length or unmatched char (if dist == 0) */ @@ -1109,7 +1171,7 @@ local void compress_block(s, ltree, dtree) } /* literal or match pair ? */ /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ - Assert((unsigned)s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow"); + Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow"); } while (lx < s->last_lit); @@ -1123,8 +1185,12 @@ local void compress_block(s, ltree, dtree) * IN assertion: the fields freq of dyn_ltree are set and the total of all * frequencies does not exceed 64K (to fit in an int on 16 bit machines). */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void set_data_type(deflate_state* s) +#else local void set_data_type(s) deflate_state *s; +#endif { int n = 0; unsigned ascii_freq = 0; @@ -1140,9 +1206,13 @@ local void set_data_type(s) * method would use a table) * IN assertion: 1 <= len <= 15 */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local unsigned bi_reverse(unsigned code, int len) +#else local unsigned bi_reverse(code, len) unsigned code; /* the value to invert */ int len; /* its bit length */ +#endif { register unsigned res = 0; do { @@ -1155,8 +1225,12 @@ local unsigned bi_reverse(code, len) /* =========================================================================== * Flush the bit buffer, keeping at most 7 bits in it. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void bi_flush(deflate_state* s) +#else local void bi_flush(s) deflate_state *s; +#endif { if (s->bi_valid == 16) { put_short(s, s->bi_buf); @@ -1172,8 +1246,12 @@ local void bi_flush(s) /* =========================================================================== * Flush the bit buffer and align the output on a byte boundary */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void bi_windup(deflate_state* s) +#else local void bi_windup(s) deflate_state *s; +#endif { if (s->bi_valid > 8) { put_short(s, s->bi_buf); @@ -1191,17 +1269,21 @@ local void bi_windup(s) * Copy a stored block, storing first the length and its * one's complement if requested. */ +#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */ +local void copy_block(deflate_state* s, charf* buf, unsigned len, int header) +#else 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 */ +#endif { bi_windup(s); /* align on byte boundary */ s->last_eob_len = 8; /* enough lookahead for inflate */ if (header) { - put_short(s, (ush)len); + put_short(s, (ush)len); put_short(s, (ush)~len); #ifdef __WXDEBUG__ s->bits_sent += 2*16;