third_party/zlib/trees.c - Issue 2690623003: Update zlib to 1.2.11

Unified Diff: third_party/zlib/trees.c

Issue 2690623003: Update zlib to 1.2.11 (Closed)

Patch Set: Drop the inflater change, improve the deflater comment Created 3 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: third_party/zlib/trees.c

diff --git a/third_party/zlib/trees.c b/third_party/zlib/trees.c

index 1fd7759ef004c66fd920873efb030eda5d1eafe0..50cf4b4571cfec347ce5891b76fcb6675fcb580d 100644

--- a/third_party/zlib/trees.c

+++ b/third_party/zlib/trees.c

@@ -1,5 +1,5 @@

/* trees.c -- output deflated data using Huffman coding

* detect_data_type() function provided freely by Cosmin Truta, 2006

* For conditions of distribution and use, see copyright notice in zlib.h

@@ -36,7 +36,7 @@

#include "deflate.h"

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

# include <ctype.h>

#endif

@@ -122,13 +122,13 @@ struct static_tree_desc_s {

int max_length; /* max bit length for the codes */

};

-local static_tree_desc static_l_desc =

+local const static_tree_desc static_l_desc =

{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};

-local static_tree_desc static_d_desc =

+local const static_tree_desc static_d_desc =

{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};

-local static_tree_desc static_bl_desc =

+local const static_tree_desc static_bl_desc =

{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};

/* ===========================================================================

@@ -152,18 +152,16 @@ local int detect_data_type OF((deflate_state *s));

local unsigned bi_reverse OF((unsigned value, int length));

local void bi_windup OF((deflate_state *s));

local void bi_flush OF((deflate_state *s));

-local void copy_block OF((deflate_state *s, charf *buf, unsigned len,

- int header));

#ifdef GEN_TREES_H

local void gen_trees_header OF((void));

#endif

-#ifndef DEBUG

+#ifndef ZLIB_DEBUG

# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)

/* Send a code of the given tree. c and tree must not have side effects */

-#else /* DEBUG */

+#else /* !ZLIB_DEBUG */

# define send_code(s, c, tree) \

{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \

send_bits(s, tree[c].Code, tree[c].Len); }

@@ -182,7 +180,7 @@ local void gen_trees_header OF((void));

* Send a value on a given number of bits.

* IN assertion: length <= 16 and value fits in length bits.

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

local void send_bits OF((deflate_state *s, int value, int length));

local void send_bits(s, value, length)

@@ -208,12 +206,12 @@ local void send_bits(s, value, length)

s->bi_valid += length;

}

-#else /* !DEBUG */

+#else /* !ZLIB_DEBUG */

#define send_bits(s, value, length) \

{ int len = length;\

if (s->bi_valid > (int)Buf_size - len) {\

- int val = value;\

+ int val = (int)value;\

s->bi_buf |= (ush)val << s->bi_valid;\

put_short(s, s->bi_buf);\

s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\

@@ -223,7 +221,7 @@ local void send_bits(s, value, length)

s->bi_valid += len;\

}

-#endif /* DEBUG */

+#endif /* ZLIB_DEBUG */

/* the arguments must not have side effects */

@@ -317,7 +315,7 @@ local void tr_static_init()

* Genererate the file trees.h describing the static trees.

#ifdef GEN_TREES_H

-# ifndef DEBUG

+# ifndef ZLIB_DEBUG

# include <stdio.h>

# endif

@@ -394,7 +392,7 @@ void ZLIB_INTERNAL _tr_init(s)

s->bi_buf = 0;

s->bi_valid = 0;

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

s->compressed_len = 0L;

s->bits_sent = 0L;

#endif

@@ -522,12 +520,12 @@ local void gen_bitlen(s, desc)

xbits = 0;

if (n >= base) xbits = extra[n-base];

f = tree[n].Freq;

- s->opt_len += (ulg)f * (bits + xbits);

- if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);

+ s->opt_len += (ulg)f * (unsigned)(bits + xbits);

+ if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);

}

if (overflow == 0) return;

- Trace((stderr,"\nbit length overflow\n"));

+ Tracev((stderr,"\nbit length overflow\n"));

/* This happens for example on obj2 and pic of the Calgary corpus */

/* Find the first bit length which could increase: */

@@ -554,9 +552,8 @@ local void gen_bitlen(s, desc)

m = s->heap[--h];

if (m > max_code) continue;

if ((unsigned) tree[m].Len != (unsigned) bits) {

- Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));

- s->opt_len += ((long)bits - (long)tree[m].Len)

- *(long)tree[m].Freq;

+ Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));

+ s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;

tree[m].Len = (ush)bits;

}

n--;

@@ -578,7 +575,7 @@ local void gen_codes (tree, max_code, bl_count)

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 */

+ unsigned code = 0; /* running code value */

int bits; /* bit index */

int n; /* code index */

@@ -586,7 +583,8 @@ local void gen_codes (tree, max_code, bl_count)

* without bit reversal.

for (bits = 1; bits <= MAX_BITS; bits++) {

- next_code[bits] = code = (code + bl_count[bits-1]) << 1;

+ code = (code + bl_count[bits-1]) << 1;

+ next_code[bits] = (ush)code;

}

/* Check that the bit counts in bl_count are consistent. The last code

* must be all ones.

@@ -599,7 +597,7 @@ local void gen_codes (tree, max_code, bl_count)

int len = tree[n].Len;

if (len == 0) continue;

/* Now reverse the bits */

- tree[n].Code = bi_reverse(next_code[len]++, len);

+ tree[n].Code = (ush)bi_reverse(next_code[len]++, len);

Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",

n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));

@@ -821,7 +819,7 @@ local int build_bl_tree(s)

if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;

}

/* Update opt_len to include the bit length tree and counts */

- s->opt_len += 3*(max_blindex+1) + 5+5+4;

+ s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;

Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",

s->opt_len, s->static_len));

@@ -869,11 +867,17 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)

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

+ bi_windup(s); /* align on byte boundary */

+ put_short(s, (ush)stored_len);

+ put_short(s, (ush)~stored_len);

+ zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);

+ s->pending += stored_len;

+#ifdef ZLIB_DEBUG

s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;

s->compressed_len += (stored_len + 4) << 3;

+ s->bits_sent += 2*16;

+ s->bits_sent += stored_len<<3;

#endif

- copy_block(s, buf, (unsigned)stored_len, 1); /* with header */

}

/* ===========================================================================

@@ -894,7 +898,7 @@ void ZLIB_INTERNAL _tr_align(s)

{

send_bits(s, STATIC_TREES<<1, 3);

send_code(s, END_BLOCK, static_ltree);

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

s->compressed_len += 10L; /* 3 for block type, 7 for EOB */

#endif

bi_flush(s);

@@ -902,7 +906,7 @@ void ZLIB_INTERNAL _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.

+ * trees or store, and write out the encoded block.

void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)

deflate_state *s;

@@ -974,7 +978,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)

send_bits(s, (STATIC_TREES<<1)+last, 3);

compress_block(s, (const ct_data *)static_ltree,

(const ct_data *)static_dtree);

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

s->compressed_len += 3 + s->static_len;

#endif

} else {

@@ -983,7 +987,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)

max_blindex+1);

compress_block(s, (const ct_data *)s->dyn_ltree,

(const ct_data *)s->dyn_dtree);

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

s->compressed_len += 3 + s->opt_len;

#endif

}

@@ -995,7 +999,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)

if (last) {

bi_windup(s);

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

s->compressed_len += 7; /* align on byte boundary */

#endif

}

@@ -1090,7 +1094,7 @@ local void compress_block(s, ltree, dtree)

send_code(s, code, dtree); /* send the distance code */

extra = extra_dbits[code];

if (extra != 0) {

- dist -= base_dist[code];

+ dist -= (unsigned)base_dist[code];

send_bits(s, dist, extra); /* send the extra distance bits */

}

} /* literal or match pair ? */

@@ -1193,34 +1197,7 @@ local void bi_windup(s)

}

s->bi_buf = 0;

s->bi_valid = 0;

-#ifdef DEBUG

+#ifdef ZLIB_DEBUG

s->bits_sent = (s->bits_sent+7) & ~7;

#endif

}

-/* ===========================================================================

- * Copy a stored block, storing first the length and its

- * one's complement if requested.

- */

-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 */

- if (header) {

- put_short(s, (ush)len);

- put_short(s, (ush)~len);

-#ifdef DEBUG

- s->bits_sent += 2*16;

-#endif

- }

-#ifdef DEBUG

- s->bits_sent += (ulg)len<<3;

-#endif

- while (len--) {

- put_byte(s, *buf++);

- }

« no previous file with comments | « third_party/zlib/simd_stub.c ('k') | third_party/zlib/uncompr.c » ('j') | no next file with comments »