/* 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
*/
/*
#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");
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++) {
/* ===========================================================================
* 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;
s->bi_valid = 0;
s->last_eob_len = 8; /* enough lookahead for inflate */
#ifdef __WXDEBUG__
+ s->compressed_len = 0L;
s->bits_sent = 0L;
#endif
/* ===========================================================================
* 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 */
* 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 */
* 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;
* 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 */
* 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.
*/
+#if defined(__VISAGECPP__) /* Visualage can't handle this antiquated interface */
+local void build_tree(deflate_state* s, tree_desc* desc)
+#else
local void build_tree(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
+#endif
{
ct_data *tree = desc->dyn_tree;
const ct_data *stree = desc->stat_desc->static_tree;
* 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 */
* 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 */
* 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 */
* 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 */
/* ===========================================================================
* 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 */
}
* 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
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;
/* ===========================================================================
* 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 */
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
#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;
/* ===========================================================================
* 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) */
* 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;
* 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 {
/* ===========================================================================
* 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);
/* ===========================================================================
* 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);
* 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;
projects / wxWidgets.git / blobdiff