repos/blastem: zlib/deflate.h comparison

comparison zlib/deflate.h @ 2690:9ef72ee5c0b0

Update vendored zlib to 1.3.1

author	Michael Pavone <pavone@retrodev.com>
date	Sun, 15 Jun 2025 15:39:33 -0700
parents	00d788dac91a
children

comparison

equal deleted inserted replaced

-:bd6e33de0972
+:9ef72ee5c0b0
 /* deflate.h -- internal compression state
-* Copyright (C) 1995-2016 Jean-loup Gailly
+* Copyright (C) 1995-2024 Jean-loup Gailly
 * For conditions of distribution and use, see copyright notice in zlib.h
 */
 /* WARNING: this file should *not* be used by applications. It is
 part of the implementation of the compression library and is
 the crc code when it is not needed.  For shared libraries, gzip encoding
 should be left enabled. */
 #ifndef NO_GZIP
 #  define GZIP
 #endif
+/* define LIT_MEM to slightly increase the speed of deflate (order 1% to 2%) at
+the cost of a larger memory footprint */
+/* #define LIT_MEM */
 /* ===========================================================================
 * Internal compression state.
 */
 uch depth[2*L_CODES+1];
 /* Depth of each subtree used as tie breaker for trees of equal frequency
 */
-uchf *l_buf;          /* buffer for literals or lengths */
+#ifdef LIT_MEM
+#   define LIT_BUFS 5
+ushf *d_buf;          /* buffer for distances */
+uchf *l_buf;          /* buffer for literals/lengths */
+#else
+#   define LIT_BUFS 4
+uchf *sym_buf;        /* buffer for distances and literals/lengths */
+#endif
 uInt  lit_bufsize;
 /* Size of match buffer for literals/lengths.  There are 4 reasons for
 * limiting lit_bufsize to 64K:
 *   - frequencies can be kept in 16 bit counters
 *     fast adaptation but have of course the overhead of transmitting
 *     trees more frequently.
 *   - I can't count above 4
 */
-uInt last_lit;      /* running index in l_buf */
+uInt sym_next;      /* running index in symbol buffer */
+uInt sym_end;       /* symbol table full when sym_next reaches this */
-ushf *d_buf;
-/* Buffer for distances. To simplify the code, d_buf and l_buf have
-* the same number of elements. To use different lengths, an extra flag
-* array would be necessary.
-*/
 ulg opt_len;        /* bit length of current block with optimal trees */
 ulg static_len;     /* bit length of current block with static trees */
 uInt matches;       /* number of string matches in current block */
 uInt insert;        /* bytes at end of window left to insert */
 #define WIN_INIT MAX_MATCH
 /* Number of bytes after end of data in window to initialize in order to avoid
 memory checker errors from longest match routines */
 /* in trees.c */
-void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_init(deflate_state *s);
-int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
+int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc);
-void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
+void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf,
-ulg stored_len, int last));
+ulg stored_len, int last);
-void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s);
-void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_align(deflate_state *s);
-void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
+void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf,
-ulg stored_len, int last));
+ulg stored_len, int last);
 #define d_code(dist) \
 ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
 /* Mapping from a distance to a distance code. dist is the distance - 1 and
 * must not have side effects. _dist_code[256] and _dist_code[257] are never
 #else
 extern const uch ZLIB_INTERNAL _length_code[];
 extern const uch ZLIB_INTERNAL _dist_code[];
 #endif
+#ifdef LIT_MEM
 # define _tr_tally_lit(s, c, flush) \
 { uch cc = (c); \
-s->d_buf[s->last_lit] = 0; \
+s->d_buf[s->sym_next] = 0; \
-s->l_buf[s->last_lit++] = cc; \
+s->l_buf[s->sym_next++] = cc; \
 s->dyn_ltree[cc].Freq++; \
-flush = (s->last_lit == s->lit_bufsize-1); \
+flush = (s->sym_next == s->sym_end); \
 }
 # define _tr_tally_dist(s, distance, length, flush) \
 { uch len = (uch)(length); \
 ush dist = (ush)(distance); \
-s->d_buf[s->last_lit] = dist; \
+s->d_buf[s->sym_next] = dist; \
-s->l_buf[s->last_lit++] = len; \
+s->l_buf[s->sym_next++] = len; \
 dist--; \
 s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
 s->dyn_dtree[d_code(dist)].Freq++; \
-flush = (s->last_lit == s->lit_bufsize-1); \
+flush = (s->sym_next == s->sym_end); \
 }
+#else
+# define _tr_tally_lit(s, c, flush) \
+{ uch cc = (c); \
+s->sym_buf[s->sym_next++] = 0; \
+s->sym_buf[s->sym_next++] = 0; \
+s->sym_buf[s->sym_next++] = cc; \
+s->dyn_ltree[cc].Freq++; \
+flush = (s->sym_next == s->sym_end); \
+}
+# define _tr_tally_dist(s, distance, length, flush) \
+{ uch len = (uch)(length); \
+ush dist = (ush)(distance); \
+s->sym_buf[s->sym_next++] = (uch)dist; \
+s->sym_buf[s->sym_next++] = (uch)(dist >> 8); \
+s->sym_buf[s->sym_next++] = len; \
+dist--; \
+s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+s->dyn_dtree[d_code(dist)].Freq++; \
+flush = (s->sym_next == s->sym_end); \
+}
+#endif
 #else
 # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
 # define _tr_tally_dist(s, distance, length, flush) \
 flush = _tr_tally(s, distance, length)
 #endif

Mercurial > repos > blastem

comparison zlib/deflate.h @ 2690:9ef72ee5c0b0