aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h
diff options
context:
space:
mode:
authorDavid Walter Seikel2013-01-13 18:54:10 +1000
committerDavid Walter Seikel2013-01-13 18:54:10 +1000
commit959831f4ef5a3e797f576c3de08cd65032c997ad (patch)
treee7351908be5995f0b325b2ebeaa02d5a34b82583 /libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h
parentAdd info about changes to Irrlicht. (diff)
downloadSledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.zip
SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.gz
SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.bz2
SledjHamr-959831f4ef5a3e797f576c3de08cd65032c997ad.tar.xz
Remove damned ancient DOS line endings from Irrlicht. Hopefully I did not go overboard.
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h')
-rw-r--r--libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h692
1 files changed, 346 insertions, 346 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h b/libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h
index 256caca..fbac44d 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h
+++ b/libraries/irrlicht-1.8/source/Irrlicht/zlib/deflate.h
@@ -1,346 +1,346 @@
1/* deflate.h -- internal compression state 1/* deflate.h -- internal compression state
2 * Copyright (C) 1995-2012 Jean-loup Gailly 2 * Copyright (C) 1995-2012 Jean-loup Gailly
3 * For conditions of distribution and use, see copyright notice in zlib.h 3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */ 4 */
5 5
6/* WARNING: this file should *not* be used by applications. It is 6/* WARNING: this file should *not* be used by applications. It is
7 part of the implementation of the compression library and is 7 part of the implementation of the compression library and is
8 subject to change. Applications should only use zlib.h. 8 subject to change. Applications should only use zlib.h.
9 */ 9 */
10 10
11/* @(#) $Id$ */ 11/* @(#) $Id$ */
12 12
13#ifndef DEFLATE_H 13#ifndef DEFLATE_H
14#define DEFLATE_H 14#define DEFLATE_H
15 15
16#include "zutil.h" 16#include "zutil.h"
17 17
18/* define NO_GZIP when compiling if you want to disable gzip header and 18/* define NO_GZIP when compiling if you want to disable gzip header and
19 trailer creation by deflate(). NO_GZIP would be used to avoid linking in 19 trailer creation by deflate(). NO_GZIP would be used to avoid linking in
20 the crc code when it is not needed. For shared libraries, gzip encoding 20 the crc code when it is not needed. For shared libraries, gzip encoding
21 should be left enabled. */ 21 should be left enabled. */
22#ifndef NO_GZIP 22#ifndef NO_GZIP
23# define GZIP 23# define GZIP
24#endif 24#endif
25 25
26/* =========================================================================== 26/* ===========================================================================
27 * Internal compression state. 27 * Internal compression state.
28 */ 28 */
29 29
30#define LENGTH_CODES 29 30#define LENGTH_CODES 29
31/* number of length codes, not counting the special END_BLOCK code */ 31/* number of length codes, not counting the special END_BLOCK code */
32 32
33#define LITERALS 256 33#define LITERALS 256
34/* number of literal bytes 0..255 */ 34/* number of literal bytes 0..255 */
35 35
36#define L_CODES (LITERALS+1+LENGTH_CODES) 36#define L_CODES (LITERALS+1+LENGTH_CODES)
37/* number of Literal or Length codes, including the END_BLOCK code */ 37/* number of Literal or Length codes, including the END_BLOCK code */
38 38
39#define D_CODES 30 39#define D_CODES 30
40/* number of distance codes */ 40/* number of distance codes */
41 41
42#define BL_CODES 19 42#define BL_CODES 19
43/* number of codes used to transfer the bit lengths */ 43/* number of codes used to transfer the bit lengths */
44 44
45#define HEAP_SIZE (2*L_CODES+1) 45#define HEAP_SIZE (2*L_CODES+1)
46/* maximum heap size */ 46/* maximum heap size */
47 47
48#define MAX_BITS 15 48#define MAX_BITS 15
49/* All codes must not exceed MAX_BITS bits */ 49/* All codes must not exceed MAX_BITS bits */
50 50
51#define Buf_size 16 51#define Buf_size 16
52/* size of bit buffer in bi_buf */ 52/* size of bit buffer in bi_buf */
53 53
54#define INIT_STATE 42 54#define INIT_STATE 42
55#define EXTRA_STATE 69 55#define EXTRA_STATE 69
56#define NAME_STATE 73 56#define NAME_STATE 73
57#define COMMENT_STATE 91 57#define COMMENT_STATE 91
58#define HCRC_STATE 103 58#define HCRC_STATE 103
59#define BUSY_STATE 113 59#define BUSY_STATE 113
60#define FINISH_STATE 666 60#define FINISH_STATE 666
61/* Stream status */ 61/* Stream status */
62 62
63 63
64/* Data structure describing a single value and its code string. */ 64/* Data structure describing a single value and its code string. */
65typedef struct ct_data_s { 65typedef struct ct_data_s {
66 union { 66 union {
67 ush freq; /* frequency count */ 67 ush freq; /* frequency count */
68 ush code; /* bit string */ 68 ush code; /* bit string */
69 } fc; 69 } fc;
70 union { 70 union {
71 ush dad; /* father node in Huffman tree */ 71 ush dad; /* father node in Huffman tree */
72 ush len; /* length of bit string */ 72 ush len; /* length of bit string */
73 } dl; 73 } dl;
74} FAR ct_data; 74} FAR ct_data;
75 75
76#define Freq fc.freq 76#define Freq fc.freq
77#define Code fc.code 77#define Code fc.code
78#define Dad dl.dad 78#define Dad dl.dad
79#define Len dl.len 79#define Len dl.len
80 80
81typedef struct static_tree_desc_s static_tree_desc; 81typedef struct static_tree_desc_s static_tree_desc;
82 82
83typedef struct tree_desc_s { 83typedef struct tree_desc_s {
84 ct_data *dyn_tree; /* the dynamic tree */ 84 ct_data *dyn_tree; /* the dynamic tree */
85 int max_code; /* largest code with non zero frequency */ 85 int max_code; /* largest code with non zero frequency */
86 static_tree_desc *stat_desc; /* the corresponding static tree */ 86 static_tree_desc *stat_desc; /* the corresponding static tree */
87} FAR tree_desc; 87} FAR tree_desc;
88 88
89typedef ush Pos; 89typedef ush Pos;
90typedef Pos FAR Posf; 90typedef Pos FAR Posf;
91typedef unsigned IPos; 91typedef unsigned IPos;
92 92
93/* A Pos is an index in the character window. We use short instead of int to 93/* A Pos is an index in the character window. We use short instead of int to
94 * save space in the various tables. IPos is used only for parameter passing. 94 * save space in the various tables. IPos is used only for parameter passing.
95 */ 95 */
96 96
97typedef struct internal_state { 97typedef struct internal_state {
98 z_streamp strm; /* pointer back to this zlib stream */ 98 z_streamp strm; /* pointer back to this zlib stream */
99 int status; /* as the name implies */ 99 int status; /* as the name implies */
100 Bytef *pending_buf; /* output still pending */ 100 Bytef *pending_buf; /* output still pending */
101 ulg pending_buf_size; /* size of pending_buf */ 101 ulg pending_buf_size; /* size of pending_buf */
102 Bytef *pending_out; /* next pending byte to output to the stream */ 102 Bytef *pending_out; /* next pending byte to output to the stream */
103 uInt pending; /* nb of bytes in the pending buffer */ 103 uInt pending; /* nb of bytes in the pending buffer */
104 int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ 104 int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
105 gz_headerp gzhead; /* gzip header information to write */ 105 gz_headerp gzhead; /* gzip header information to write */
106 uInt gzindex; /* where in extra, name, or comment */ 106 uInt gzindex; /* where in extra, name, or comment */
107 Byte method; /* STORED (for zip only) or DEFLATED */ 107 Byte method; /* STORED (for zip only) or DEFLATED */
108 int last_flush; /* value of flush param for previous deflate call */ 108 int last_flush; /* value of flush param for previous deflate call */
109 109
110 /* used by deflate.c: */ 110 /* used by deflate.c: */
111 111
112 uInt w_size; /* LZ77 window size (32K by default) */ 112 uInt w_size; /* LZ77 window size (32K by default) */
113 uInt w_bits; /* log2(w_size) (8..16) */ 113 uInt w_bits; /* log2(w_size) (8..16) */
114 uInt w_mask; /* w_size - 1 */ 114 uInt w_mask; /* w_size - 1 */
115 115
116 Bytef *window; 116 Bytef *window;
117 /* Sliding window. Input bytes are read into the second half of the window, 117 /* Sliding window. Input bytes are read into the second half of the window,
118 * and move to the first half later to keep a dictionary of at least wSize 118 * and move to the first half later to keep a dictionary of at least wSize
119 * bytes. With this organization, matches are limited to a distance of 119 * bytes. With this organization, matches are limited to a distance of
120 * wSize-MAX_MATCH bytes, but this ensures that IO is always 120 * wSize-MAX_MATCH bytes, but this ensures that IO is always
121 * performed with a length multiple of the block size. Also, it limits 121 * performed with a length multiple of the block size. Also, it limits
122 * the window size to 64K, which is quite useful on MSDOS. 122 * the window size to 64K, which is quite useful on MSDOS.
123 * To do: use the user input buffer as sliding window. 123 * To do: use the user input buffer as sliding window.
124 */ 124 */
125 125
126 ulg window_size; 126 ulg window_size;
127 /* Actual size of window: 2*wSize, except when the user input buffer 127 /* Actual size of window: 2*wSize, except when the user input buffer
128 * is directly used as sliding window. 128 * is directly used as sliding window.
129 */ 129 */
130 130
131 Posf *prev; 131 Posf *prev;
132 /* Link to older string with same hash index. To limit the size of this 132 /* Link to older string with same hash index. To limit the size of this
133 * array to 64K, this link is maintained only for the last 32K strings. 133 * array to 64K, this link is maintained only for the last 32K strings.
134 * An index in this array is thus a window index modulo 32K. 134 * An index in this array is thus a window index modulo 32K.
135 */ 135 */
136 136
137 Posf *head; /* Heads of the hash chains or NIL. */ 137 Posf *head; /* Heads of the hash chains or NIL. */
138 138
139 uInt ins_h; /* hash index of string to be inserted */ 139 uInt ins_h; /* hash index of string to be inserted */
140 uInt hash_size; /* number of elements in hash table */ 140 uInt hash_size; /* number of elements in hash table */
141 uInt hash_bits; /* log2(hash_size) */ 141 uInt hash_bits; /* log2(hash_size) */
142 uInt hash_mask; /* hash_size-1 */ 142 uInt hash_mask; /* hash_size-1 */
143 143
144 uInt hash_shift; 144 uInt hash_shift;
145 /* Number of bits by which ins_h must be shifted at each input 145 /* Number of bits by which ins_h must be shifted at each input
146 * step. It must be such that after MIN_MATCH steps, the oldest 146 * step. It must be such that after MIN_MATCH steps, the oldest
147 * byte no longer takes part in the hash key, that is: 147 * byte no longer takes part in the hash key, that is:
148 * hash_shift * MIN_MATCH >= hash_bits 148 * hash_shift * MIN_MATCH >= hash_bits
149 */ 149 */
150 150
151 long block_start; 151 long block_start;
152 /* Window position at the beginning of the current output block. Gets 152 /* Window position at the beginning of the current output block. Gets
153 * negative when the window is moved backwards. 153 * negative when the window is moved backwards.
154 */ 154 */
155 155
156 uInt match_length; /* length of best match */ 156 uInt match_length; /* length of best match */
157 IPos prev_match; /* previous match */ 157 IPos prev_match; /* previous match */
158 int match_available; /* set if previous match exists */ 158 int match_available; /* set if previous match exists */
159 uInt strstart; /* start of string to insert */ 159 uInt strstart; /* start of string to insert */
160 uInt match_start; /* start of matching string */ 160 uInt match_start; /* start of matching string */
161 uInt lookahead; /* number of valid bytes ahead in window */ 161 uInt lookahead; /* number of valid bytes ahead in window */
162 162
163 uInt prev_length; 163 uInt prev_length;
164 /* Length of the best match at previous step. Matches not greater than this 164 /* Length of the best match at previous step. Matches not greater than this
165 * are discarded. This is used in the lazy match evaluation. 165 * are discarded. This is used in the lazy match evaluation.
166 */ 166 */
167 167
168 uInt max_chain_length; 168 uInt max_chain_length;
169 /* To speed up deflation, hash chains are never searched beyond this 169 /* To speed up deflation, hash chains are never searched beyond this
170 * length. A higher limit improves compression ratio but degrades the 170 * length. A higher limit improves compression ratio but degrades the
171 * speed. 171 * speed.
172 */ 172 */
173 173
174 uInt max_lazy_match; 174 uInt max_lazy_match;
175 /* Attempt to find a better match only when the current match is strictly 175 /* Attempt to find a better match only when the current match is strictly
176 * smaller than this value. This mechanism is used only for compression 176 * smaller than this value. This mechanism is used only for compression
177 * levels >= 4. 177 * levels >= 4.
178 */ 178 */
179# define max_insert_length max_lazy_match 179# define max_insert_length max_lazy_match
180 /* Insert new strings in the hash table only if the match length is not 180 /* Insert new strings in the hash table only if the match length is not
181 * greater than this length. This saves time but degrades compression. 181 * greater than this length. This saves time but degrades compression.
182 * max_insert_length is used only for compression levels <= 3. 182 * max_insert_length is used only for compression levels <= 3.
183 */ 183 */
184 184
185 int level; /* compression level (1..9) */ 185 int level; /* compression level (1..9) */
186 int strategy; /* favor or force Huffman coding*/ 186 int strategy; /* favor or force Huffman coding*/
187 187
188 uInt good_match; 188 uInt good_match;
189 /* Use a faster search when the previous match is longer than this */ 189 /* Use a faster search when the previous match is longer than this */
190 190
191 int nice_match; /* Stop searching when current match exceeds this */ 191 int nice_match; /* Stop searching when current match exceeds this */
192 192
193 /* used by trees.c: */ 193 /* used by trees.c: */
194 /* Didn't use ct_data typedef below to suppress compiler warning */ 194 /* Didn't use ct_data typedef below to suppress compiler warning */
195 struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ 195 struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
196 struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ 196 struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
197 struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ 197 struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
198 198
199 struct tree_desc_s l_desc; /* desc. for literal tree */ 199 struct tree_desc_s l_desc; /* desc. for literal tree */
200 struct tree_desc_s d_desc; /* desc. for distance tree */ 200 struct tree_desc_s d_desc; /* desc. for distance tree */
201 struct tree_desc_s bl_desc; /* desc. for bit length tree */ 201 struct tree_desc_s bl_desc; /* desc. for bit length tree */
202 202
203 ush bl_count[MAX_BITS+1]; 203 ush bl_count[MAX_BITS+1];
204 /* number of codes at each bit length for an optimal tree */ 204 /* number of codes at each bit length for an optimal tree */
205 205
206 int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ 206 int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
207 int heap_len; /* number of elements in the heap */ 207 int heap_len; /* number of elements in the heap */
208 int heap_max; /* element of largest frequency */ 208 int heap_max; /* element of largest frequency */
209 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. 209 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
210 * The same heap array is used to build all trees. 210 * The same heap array is used to build all trees.
211 */ 211 */
212 212
213 uch depth[2*L_CODES+1]; 213 uch depth[2*L_CODES+1];
214 /* Depth of each subtree used as tie breaker for trees of equal frequency 214 /* Depth of each subtree used as tie breaker for trees of equal frequency
215 */ 215 */
216 216
217 uchf *l_buf; /* buffer for literals or lengths */ 217 uchf *l_buf; /* buffer for literals or lengths */
218 218
219 uInt lit_bufsize; 219 uInt lit_bufsize;
220 /* Size of match buffer for literals/lengths. There are 4 reasons for 220 /* Size of match buffer for literals/lengths. There are 4 reasons for
221 * limiting lit_bufsize to 64K: 221 * limiting lit_bufsize to 64K:
222 * - frequencies can be kept in 16 bit counters 222 * - frequencies can be kept in 16 bit counters
223 * - if compression is not successful for the first block, all input 223 * - if compression is not successful for the first block, all input
224 * data is still in the window so we can still emit a stored block even 224 * data is still in the window so we can still emit a stored block even
225 * when input comes from standard input. (This can also be done for 225 * when input comes from standard input. (This can also be done for
226 * all blocks if lit_bufsize is not greater than 32K.) 226 * all blocks if lit_bufsize is not greater than 32K.)
227 * - if compression is not successful for a file smaller than 64K, we can 227 * - if compression is not successful for a file smaller than 64K, we can
228 * even emit a stored file instead of a stored block (saving 5 bytes). 228 * even emit a stored file instead of a stored block (saving 5 bytes).
229 * This is applicable only for zip (not gzip or zlib). 229 * This is applicable only for zip (not gzip or zlib).
230 * - creating new Huffman trees less frequently may not provide fast 230 * - creating new Huffman trees less frequently may not provide fast
231 * adaptation to changes in the input data statistics. (Take for 231 * adaptation to changes in the input data statistics. (Take for
232 * example a binary file with poorly compressible code followed by 232 * example a binary file with poorly compressible code followed by
233 * a highly compressible string table.) Smaller buffer sizes give 233 * a highly compressible string table.) Smaller buffer sizes give
234 * fast adaptation but have of course the overhead of transmitting 234 * fast adaptation but have of course the overhead of transmitting
235 * trees more frequently. 235 * trees more frequently.
236 * - I can't count above 4 236 * - I can't count above 4
237 */ 237 */
238 238
239 uInt last_lit; /* running index in l_buf */ 239 uInt last_lit; /* running index in l_buf */
240 240
241 ushf *d_buf; 241 ushf *d_buf;
242 /* Buffer for distances. To simplify the code, d_buf and l_buf have 242 /* Buffer for distances. To simplify the code, d_buf and l_buf have
243 * the same number of elements. To use different lengths, an extra flag 243 * the same number of elements. To use different lengths, an extra flag
244 * array would be necessary. 244 * array would be necessary.
245 */ 245 */
246 246
247 ulg opt_len; /* bit length of current block with optimal trees */ 247 ulg opt_len; /* bit length of current block with optimal trees */
248 ulg static_len; /* bit length of current block with static trees */ 248 ulg static_len; /* bit length of current block with static trees */
249 uInt matches; /* number of string matches in current block */ 249 uInt matches; /* number of string matches in current block */
250 uInt insert; /* bytes at end of window left to insert */ 250 uInt insert; /* bytes at end of window left to insert */
251 251
252#ifdef DEBUG 252#ifdef DEBUG
253 ulg compressed_len; /* total bit length of compressed file mod 2^32 */ 253 ulg compressed_len; /* total bit length of compressed file mod 2^32 */
254 ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ 254 ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
255#endif 255#endif
256 256
257 ush bi_buf; 257 ush bi_buf;
258 /* Output buffer. bits are inserted starting at the bottom (least 258 /* Output buffer. bits are inserted starting at the bottom (least
259 * significant bits). 259 * significant bits).
260 */ 260 */
261 int bi_valid; 261 int bi_valid;
262 /* Number of valid bits in bi_buf. All bits above the last valid bit 262 /* Number of valid bits in bi_buf. All bits above the last valid bit
263 * are always zero. 263 * are always zero.
264 */ 264 */
265 265
266 ulg high_water; 266 ulg high_water;
267 /* High water mark offset in window for initialized bytes -- bytes above 267 /* High water mark offset in window for initialized bytes -- bytes above
268 * this are set to zero in order to avoid memory check warnings when 268 * this are set to zero in order to avoid memory check warnings when
269 * longest match routines access bytes past the input. This is then 269 * longest match routines access bytes past the input. This is then
270 * updated to the new high water mark. 270 * updated to the new high water mark.
271 */ 271 */
272 272
273} FAR deflate_state; 273} FAR deflate_state;
274 274
275/* Output a byte on the stream. 275/* Output a byte on the stream.
276 * IN assertion: there is enough room in pending_buf. 276 * IN assertion: there is enough room in pending_buf.
277 */ 277 */
278#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} 278#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
279 279
280 280
281#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) 281#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
282/* Minimum amount of lookahead, except at the end of the input file. 282/* Minimum amount of lookahead, except at the end of the input file.
283 * See deflate.c for comments about the MIN_MATCH+1. 283 * See deflate.c for comments about the MIN_MATCH+1.
284 */ 284 */
285 285
286#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) 286#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
287/* In order to simplify the code, particularly on 16 bit machines, match 287/* In order to simplify the code, particularly on 16 bit machines, match
288 * distances are limited to MAX_DIST instead of WSIZE. 288 * distances are limited to MAX_DIST instead of WSIZE.
289 */ 289 */
290 290
291#define WIN_INIT MAX_MATCH 291#define WIN_INIT MAX_MATCH
292/* Number of bytes after end of data in window to initialize in order to avoid 292/* Number of bytes after end of data in window to initialize in order to avoid
293 memory checker errors from longest match routines */ 293 memory checker errors from longest match routines */
294 294
295 /* in trees.c */ 295 /* in trees.c */
296void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); 296void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
297int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); 297int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
298void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, 298void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
299 ulg stored_len, int last)); 299 ulg stored_len, int last));
300void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); 300void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
301void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); 301void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
302void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, 302void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
303 ulg stored_len, int last)); 303 ulg stored_len, int last));
304 304
305#define d_code(dist) \ 305#define d_code(dist) \
306 ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) 306 ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
307/* Mapping from a distance to a distance code. dist is the distance - 1 and 307/* Mapping from a distance to a distance code. dist is the distance - 1 and
308 * must not have side effects. _dist_code[256] and _dist_code[257] are never 308 * must not have side effects. _dist_code[256] and _dist_code[257] are never
309 * used. 309 * used.
310 */ 310 */
311 311
312#ifndef DEBUG 312#ifndef DEBUG
313/* Inline versions of _tr_tally for speed: */ 313/* Inline versions of _tr_tally for speed: */
314 314
315#if defined(GEN_TREES_H) || !defined(STDC) 315#if defined(GEN_TREES_H) || !defined(STDC)
316 extern uch ZLIB_INTERNAL _length_code[]; 316 extern uch ZLIB_INTERNAL _length_code[];
317 extern uch ZLIB_INTERNAL _dist_code[]; 317 extern uch ZLIB_INTERNAL _dist_code[];
318#else 318#else
319 extern const uch ZLIB_INTERNAL _length_code[]; 319 extern const uch ZLIB_INTERNAL _length_code[];
320 extern const uch ZLIB_INTERNAL _dist_code[]; 320 extern const uch ZLIB_INTERNAL _dist_code[];
321#endif 321#endif
322 322
323# define _tr_tally_lit(s, c, flush) \ 323# define _tr_tally_lit(s, c, flush) \
324 { uch cc = (c); \ 324 { uch cc = (c); \
325 s->d_buf[s->last_lit] = 0; \ 325 s->d_buf[s->last_lit] = 0; \
326 s->l_buf[s->last_lit++] = cc; \ 326 s->l_buf[s->last_lit++] = cc; \
327 s->dyn_ltree[cc].Freq++; \ 327 s->dyn_ltree[cc].Freq++; \
328 flush = (s->last_lit == s->lit_bufsize-1); \ 328 flush = (s->last_lit == s->lit_bufsize-1); \
329 } 329 }
330# define _tr_tally_dist(s, distance, length, flush) \ 330# define _tr_tally_dist(s, distance, length, flush) \
331 { uch len = (length); \ 331 { uch len = (length); \
332 ush dist = (distance); \ 332 ush dist = (distance); \
333 s->d_buf[s->last_lit] = dist; \ 333 s->d_buf[s->last_lit] = dist; \
334 s->l_buf[s->last_lit++] = len; \ 334 s->l_buf[s->last_lit++] = len; \
335 dist--; \ 335 dist--; \
336 s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ 336 s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
337 s->dyn_dtree[d_code(dist)].Freq++; \ 337 s->dyn_dtree[d_code(dist)].Freq++; \
338 flush = (s->last_lit == s->lit_bufsize-1); \ 338 flush = (s->last_lit == s->lit_bufsize-1); \
339 } 339 }
340#else 340#else
341# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) 341# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
342# define _tr_tally_dist(s, distance, length, flush) \ 342# define _tr_tally_dist(s, distance, length, flush) \
343 flush = _tr_tally(s, distance, length) 343 flush = _tr_tally(s, distance, length)
344#endif 344#endif
345 345
346#endif /* DEFLATE_H */ 346#endif /* DEFLATE_H */
generated by cgit v1.1 at 2024-07-12 02:39:28 +0000