Commit | Line | Data |
---|---|---|
3013fe88 NW |
1 | /* deflate.c -- compress data using the deflation algorithm |
2 | * Copyright (C) 1992-1993 Jean-loup Gailly | |
3 | * This is free software; you can redistribute it and/or modify it under the | |
4 | * terms of the GNU General Public License, see the file COPYING. | |
5 | */ | |
6 | ||
7 | /* | |
8 | * PURPOSE | |
9 | * | |
10 | * Identify new text as repetitions of old text within a fixed- | |
11 | * length sliding window trailing behind the new text. | |
12 | * | |
13 | * DISCUSSION | |
14 | * | |
15 | * The "deflation" process depends on being able to identify portions | |
16 | * of the input text which are identical to earlier input (within a | |
17 | * sliding window trailing behind the input currently being processed). | |
18 | * | |
19 | * The most straightforward technique turns out to be the fastest for | |
20 | * most input files: try all possible matches and select the longest. | |
21 | * The key feature of this algorithm is that insertions into the string | |
22 | * dictionary are very simple and thus fast, and deletions are avoided | |
23 | * completely. Insertions are performed at each input character, whereas | |
24 | * string matches are performed only when the previous match ends. So it | |
25 | * is preferable to spend more time in matches to allow very fast string | |
26 | * insertions and avoid deletions. The matching algorithm for small | |
27 | * strings is inspired from that of Rabin & Karp. A brute force approach | |
28 | * is used to find longer strings when a small match has been found. | |
29 | * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze | |
30 | * (by Leonid Broukhis). | |
31 | * A previous version of this file used a more sophisticated algorithm | |
32 | * (by Fiala and Greene) which is guaranteed to run in linear amortized | |
33 | * time, but has a larger average cost, uses more memory and is patented. | |
34 | * However the F&G algorithm may be faster for some highly redundant | |
35 | * files if the parameter max_chain_length (described below) is too large. | |
36 | * | |
37 | * ACKNOWLEDGEMENTS | |
38 | * | |
39 | * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and | |
40 | * I found it in 'freeze' written by Leonid Broukhis. | |
41 | * Thanks to many info-zippers for bug reports and testing. | |
42 | * | |
43 | * REFERENCES | |
44 | * | |
45 | * APPNOTE.TXT documentation file in PKZIP 1.93a distribution. | |
46 | * | |
47 | * A description of the Rabin and Karp algorithm is given in the book | |
48 | * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. | |
49 | * | |
50 | * Fiala,E.R., and Greene,D.H. | |
51 | * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 | |
52 | * | |
53 | * INTERFACE | |
54 | * | |
55 | * void lm_init (int pack_level, ush *flags) | |
56 | * Initialize the "longest match" routines for a new file | |
57 | * | |
58 | * ulg deflate (void) | |
59 | * Processes a new input file and return its compressed length. Sets | |
60 | * the compressed length, crc, deflate flags and internal file | |
61 | * attributes. | |
62 | */ | |
63 | ||
64 | #include <stdio.h> | |
65 | ||
66 | #include "tailor.h" | |
67 | #include "gzip.h" | |
68 | #include "lzw.h" /* just for consistency checking */ | |
69 | ||
78ed81a3 | 70 | #ifdef RCSID |
71 | static char rcsid[] = "$Id: deflate.c,v 0.15 1993/06/24 10:53:53 jloup Exp $"; | |
3013fe88 NW |
72 | #endif |
73 | ||
74 | /* =========================================================================== | |
75 | * Configuration parameters | |
76 | */ | |
77 | ||
78 | /* Compile with MEDIUM_MEM to reduce the memory requirements or | |
79 | * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the | |
80 | * entire input file can be held in memory (not possible on 16 bit systems). | |
81 | * Warning: defining these symbols affects HASH_BITS (see below) and thus | |
82 | * affects the compression ratio. The compressed output | |
83 | * is still correct, and might even be smaller in some cases. | |
84 | */ | |
85 | ||
86 | #ifdef SMALL_MEM | |
87 | # define HASH_BITS 13 /* Number of bits used to hash strings */ | |
88 | #endif | |
89 | #ifdef MEDIUM_MEM | |
90 | # define HASH_BITS 14 | |
91 | #endif | |
92 | #ifndef HASH_BITS | |
93 | # define HASH_BITS 15 | |
94 | /* For portability to 16 bit machines, do not use values above 15. */ | |
95 | #endif | |
96 | ||
97 | /* To save space (see unlzw.c), we overlay prev+head with tab_prefix and | |
98 | * window with tab_suffix. Check that we can do this: | |
99 | */ | |
78ed81a3 | 100 | #if (WSIZE<<1) > (1<<BITS) |
3013fe88 NW |
101 | error: cannot overlay window with tab_suffix and prev with tab_prefix0 |
102 | #endif | |
103 | #if HASH_BITS > BITS-1 | |
104 | error: cannot overlay head with tab_prefix1 | |
105 | #endif | |
106 | ||
107 | #define HASH_SIZE (unsigned)(1<<HASH_BITS) | |
108 | #define HASH_MASK (HASH_SIZE-1) | |
109 | #define WMASK (WSIZE-1) | |
110 | /* HASH_SIZE and WSIZE must be powers of two */ | |
111 | ||
112 | #define NIL 0 | |
113 | /* Tail of hash chains */ | |
114 | ||
115 | #define FAST 4 | |
116 | #define SLOW 2 | |
117 | /* speed options for the general purpose bit flag */ | |
118 | ||
119 | #ifndef TOO_FAR | |
120 | # define TOO_FAR 4096 | |
121 | #endif | |
122 | /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ | |
123 | ||
124 | /* =========================================================================== | |
125 | * Local data used by the "longest match" routines. | |
126 | */ | |
127 | ||
128 | typedef ush Pos; | |
129 | typedef unsigned IPos; | |
130 | /* A Pos is an index in the character window. We use short instead of int to | |
131 | * save space in the various tables. IPos is used only for parameter passing. | |
132 | */ | |
133 | ||
134 | /* DECLARE(uch, window, 2L*WSIZE); */ | |
135 | /* Sliding window. Input bytes are read into the second half of the window, | |
136 | * and move to the first half later to keep a dictionary of at least WSIZE | |
137 | * bytes. With this organization, matches are limited to a distance of | |
138 | * WSIZE-MAX_MATCH bytes, but this ensures that IO is always | |
139 | * performed with a length multiple of the block size. Also, it limits | |
140 | * the window size to 64K, which is quite useful on MSDOS. | |
141 | * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would | |
142 | * be less efficient). | |
143 | */ | |
144 | ||
145 | /* DECLARE(Pos, prev, WSIZE); */ | |
146 | /* Link to older string with same hash index. To limit the size of this | |
147 | * array to 64K, this link is maintained only for the last 32K strings. | |
148 | * An index in this array is thus a window index modulo 32K. | |
149 | */ | |
150 | ||
151 | /* DECLARE(Pos, head, 1<<HASH_BITS); */ | |
152 | /* Heads of the hash chains or NIL. */ | |
153 | ||
154 | ulg window_size = (ulg)2*WSIZE; | |
155 | /* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the | |
156 | * input file length plus MIN_LOOKAHEAD. | |
157 | */ | |
158 | ||
159 | long block_start; | |
160 | /* window position at the beginning of the current output block. Gets | |
161 | * negative when the window is moved backwards. | |
162 | */ | |
163 | ||
164 | local unsigned ins_h; /* hash index of string to be inserted */ | |
165 | ||
166 | #define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH) | |
167 | /* Number of bits by which ins_h and del_h must be shifted at each | |
168 | * input step. It must be such that after MIN_MATCH steps, the oldest | |
169 | * byte no longer takes part in the hash key, that is: | |
170 | * H_SHIFT * MIN_MATCH >= HASH_BITS | |
171 | */ | |
172 | ||
173 | unsigned int near prev_length; | |
174 | /* Length of the best match at previous step. Matches not greater than this | |
175 | * are discarded. This is used in the lazy match evaluation. | |
176 | */ | |
177 | ||
178 | unsigned near strstart; /* start of string to insert */ | |
179 | unsigned near match_start; /* start of matching string */ | |
180 | local int eofile; /* flag set at end of input file */ | |
181 | local unsigned lookahead; /* number of valid bytes ahead in window */ | |
182 | ||
183 | unsigned near max_chain_length; | |
184 | /* To speed up deflation, hash chains are never searched beyond this length. | |
185 | * A higher limit improves compression ratio but degrades the speed. | |
186 | */ | |
187 | ||
188 | local unsigned int max_lazy_match; | |
189 | /* Attempt to find a better match only when the current match is strictly | |
78ed81a3 | 190 | * smaller than this value. This mechanism is used only for compression |
191 | * levels >= 4. | |
3013fe88 | 192 | */ |
78ed81a3 | 193 | #define max_insert_length max_lazy_match |
194 | /* Insert new strings in the hash table only if the match length | |
195 | * is not greater than this length. This saves time but degrades compression. | |
196 | * max_insert_length is used only for compression levels <= 3. | |
197 | */ | |
198 | ||
199 | local int compr_level; | |
200 | /* compression level (1..9) */ | |
3013fe88 | 201 | |
78ed81a3 | 202 | unsigned near good_match; |
3013fe88 NW |
203 | /* Use a faster search when the previous match is longer than this */ |
204 | ||
205 | ||
206 | /* Values for max_lazy_match, good_match and max_chain_length, depending on | |
207 | * the desired pack level (0..9). The values given below have been tuned to | |
208 | * exclude worst case performance for pathological files. Better values may be | |
209 | * found for specific files. | |
210 | */ | |
211 | ||
212 | typedef struct config { | |
213 | ush good_length; /* reduce lazy search above this match length */ | |
214 | ush max_lazy; /* do not perform lazy search above this match length */ | |
215 | ush nice_length; /* quit search above this match length */ | |
216 | ush max_chain; | |
217 | } config; | |
218 | ||
219 | #ifdef FULL_SEARCH | |
220 | # define nice_match MAX_MATCH | |
221 | #else | |
222 | int near nice_match; /* Stop searching when current match exceeds this */ | |
223 | #endif | |
224 | ||
225 | local config configuration_table[10] = { | |
226 | /* good lazy nice chain */ | |
227 | /* 0 */ {0, 0, 0, 0}, /* store only */ | |
78ed81a3 | 228 | /* 1 */ {4, 4, 8, 4}, /* maximum speed, no lazy matches */ |
229 | /* 2 */ {4, 5, 16, 8}, | |
230 | /* 3 */ {4, 6, 32, 32}, | |
231 | ||
232 | /* 4 */ {4, 4, 16, 16}, /* lazy matches */ | |
233 | /* 5 */ {8, 16, 32, 32}, | |
234 | /* 6 */ {8, 16, 128, 128}, | |
235 | /* 7 */ {8, 32, 128, 256}, | |
3013fe88 NW |
236 | /* 8 */ {32, 128, 258, 1024}, |
237 | /* 9 */ {32, 258, 258, 4096}}; /* maximum compression */ | |
238 | ||
78ed81a3 | 239 | /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 |
240 | * For deflate_fast() (levels <= 3) good is ignored and lazy has a different | |
241 | * meaning. | |
3013fe88 NW |
242 | */ |
243 | ||
244 | #define EQUAL 0 | |
245 | /* result of memcmp for equal strings */ | |
246 | ||
247 | /* =========================================================================== | |
248 | * Prototypes for local functions. | |
249 | */ | |
250 | local void fill_window OF((void)); | |
78ed81a3 | 251 | local ulg deflate_fast OF((void)); |
252 | ||
3013fe88 NW |
253 | int longest_match OF((IPos cur_match)); |
254 | #ifdef ASMV | |
255 | void match_init OF((void)); /* asm code initialization */ | |
256 | #endif | |
257 | ||
258 | #ifdef DEBUG | |
259 | local void check_match OF((IPos start, IPos match, int length)); | |
260 | #endif | |
261 | ||
262 | /* =========================================================================== | |
263 | * Update a hash value with the given input byte | |
264 | * IN assertion: all calls to to UPDATE_HASH are made with consecutive | |
265 | * input characters, so that a running hash key can be computed from the | |
266 | * previous key instead of complete recalculation each time. | |
267 | */ | |
268 | #define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK) | |
269 | ||
270 | /* =========================================================================== | |
271 | * Insert string s in the dictionary and set match_head to the previous head | |
272 | * of the hash chain (the most recent string with same hash key). Return | |
273 | * the previous length of the hash chain. | |
274 | * IN assertion: all calls to to INSERT_STRING are made with consecutive | |
275 | * input characters and the first MIN_MATCH bytes of s are valid | |
276 | * (except for the last MIN_MATCH-1 bytes of the input file). | |
277 | */ | |
278 | #define INSERT_STRING(s, match_head) \ | |
279 | (UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]), \ | |
280 | prev[(s) & WMASK] = match_head = head[ins_h], \ | |
281 | head[ins_h] = (s)) | |
282 | ||
283 | /* =========================================================================== | |
284 | * Initialize the "longest match" routines for a new file | |
285 | */ | |
286 | void lm_init (pack_level, flags) | |
287 | int pack_level; /* 0: store, 1: best speed, 9: best compression */ | |
288 | ush *flags; /* general purpose bit flag */ | |
289 | { | |
290 | register unsigned j; | |
291 | ||
292 | if (pack_level < 1 || pack_level > 9) error("bad pack level"); | |
78ed81a3 | 293 | compr_level = pack_level; |
3013fe88 NW |
294 | |
295 | /* Initialize the hash table. */ | |
296 | #if defined(MAXSEG_64K) && HASH_BITS == 15 | |
297 | for (j = 0; j < HASH_SIZE; j++) head[j] = NIL; | |
298 | #else | |
299 | memzero((char*)head, HASH_SIZE*sizeof(*head)); | |
300 | #endif | |
301 | /* prev will be initialized on the fly */ | |
302 | ||
303 | /* Set the default configuration parameters: | |
304 | */ | |
305 | max_lazy_match = configuration_table[pack_level].max_lazy; | |
306 | good_match = configuration_table[pack_level].good_length; | |
307 | #ifndef FULL_SEARCH | |
308 | nice_match = configuration_table[pack_level].nice_length; | |
309 | #endif | |
310 | max_chain_length = configuration_table[pack_level].max_chain; | |
311 | if (pack_level == 1) { | |
312 | *flags |= FAST; | |
313 | } else if (pack_level == 9) { | |
314 | *flags |= SLOW; | |
315 | } | |
316 | /* ??? reduce max_chain_length for binary files */ | |
317 | ||
318 | strstart = 0; | |
319 | block_start = 0L; | |
320 | #ifdef ASMV | |
321 | match_init(); /* initialize the asm code */ | |
322 | #endif | |
323 | ||
324 | lookahead = read_buf((char*)window, | |
325 | sizeof(int) <= 2 ? (unsigned)WSIZE : 2*WSIZE); | |
326 | ||
327 | if (lookahead == 0 || lookahead == (unsigned)EOF) { | |
328 | eofile = 1, lookahead = 0; | |
329 | return; | |
330 | } | |
331 | eofile = 0; | |
332 | /* Make sure that we always have enough lookahead. This is important | |
333 | * if input comes from a device such as a tty. | |
334 | */ | |
335 | while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); | |
336 | ||
337 | ins_h = 0; | |
338 | for (j=0; j<MIN_MATCH-1; j++) UPDATE_HASH(ins_h, window[j]); | |
339 | /* If lookahead < MIN_MATCH, ins_h is garbage, but this is | |
340 | * not important since only literal bytes will be emitted. | |
341 | */ | |
342 | } | |
343 | ||
344 | /* =========================================================================== | |
345 | * Set match_start to the longest match starting at the given string and | |
346 | * return its length. Matches shorter or equal to prev_length are discarded, | |
347 | * in which case the result is equal to prev_length and match_start is | |
348 | * garbage. | |
349 | * IN assertions: cur_match is the head of the hash chain for the current | |
350 | * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 | |
351 | */ | |
352 | #ifndef ASMV | |
353 | /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or | |
354 | * match.s. The code is functionally equivalent, so you can use the C version | |
355 | * if desired. | |
356 | */ | |
357 | int longest_match(cur_match) | |
358 | IPos cur_match; /* current match */ | |
359 | { | |
360 | unsigned chain_length = max_chain_length; /* max hash chain length */ | |
361 | register uch *scan = window + strstart; /* current string */ | |
362 | register uch *match; /* matched string */ | |
363 | register int len; /* length of current match */ | |
364 | int best_len = prev_length; /* best match length so far */ | |
365 | IPos limit = strstart > (IPos)MAX_DIST ? strstart - (IPos)MAX_DIST : NIL; | |
366 | /* Stop when cur_match becomes <= limit. To simplify the code, | |
367 | * we prevent matches with the string of window index 0. | |
368 | */ | |
369 | ||
370 | /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. | |
371 | * It is easy to get rid of this optimization if necessary. | |
372 | */ | |
373 | #if HASH_BITS < 8 || MAX_MATCH != 258 | |
374 | error: Code too clever | |
375 | #endif | |
376 | ||
377 | #ifdef UNALIGNED_OK | |
378 | /* Compare two bytes at a time. Note: this is not always beneficial. | |
379 | * Try with and without -DUNALIGNED_OK to check. | |
380 | */ | |
381 | register uch *strend = window + strstart + MAX_MATCH - 1; | |
382 | register ush scan_start = *(ush*)scan; | |
383 | register ush scan_end = *(ush*)(scan+best_len-1); | |
384 | #else | |
385 | register uch *strend = window + strstart + MAX_MATCH; | |
386 | register uch scan_end1 = scan[best_len-1]; | |
387 | register uch scan_end = scan[best_len]; | |
388 | #endif | |
389 | ||
390 | /* Do not waste too much time if we already have a good match: */ | |
391 | if (prev_length >= good_match) { | |
392 | chain_length >>= 2; | |
393 | } | |
394 | Assert(strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead"); | |
395 | ||
396 | do { | |
397 | Assert(cur_match < strstart, "no future"); | |
398 | match = window + cur_match; | |
399 | ||
400 | /* Skip to next match if the match length cannot increase | |
401 | * or if the match length is less than 2: | |
402 | */ | |
403 | #if (defined(UNALIGNED_OK) && MAX_MATCH == 258) | |
404 | /* This code assumes sizeof(unsigned short) == 2. Do not use | |
405 | * UNALIGNED_OK if your compiler uses a different size. | |
406 | */ | |
407 | if (*(ush*)(match+best_len-1) != scan_end || | |
408 | *(ush*)match != scan_start) continue; | |
409 | ||
410 | /* It is not necessary to compare scan[2] and match[2] since they are | |
411 | * always equal when the other bytes match, given that the hash keys | |
412 | * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at | |
413 | * strstart+3, +5, ... up to strstart+257. We check for insufficient | |
414 | * lookahead only every 4th comparison; the 128th check will be made | |
415 | * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is | |
416 | * necessary to put more guard bytes at the end of the window, or | |
417 | * to check more often for insufficient lookahead. | |
418 | */ | |
419 | scan++, match++; | |
420 | do { | |
421 | } while (*(ush*)(scan+=2) == *(ush*)(match+=2) && | |
422 | *(ush*)(scan+=2) == *(ush*)(match+=2) && | |
423 | *(ush*)(scan+=2) == *(ush*)(match+=2) && | |
424 | *(ush*)(scan+=2) == *(ush*)(match+=2) && | |
425 | scan < strend); | |
426 | /* The funny "do {}" generates better code on most compilers */ | |
427 | ||
428 | /* Here, scan <= window+strstart+257 */ | |
429 | Assert(scan <= window+(unsigned)(window_size-1), "wild scan"); | |
430 | if (*scan == *match) scan++; | |
431 | ||
432 | len = (MAX_MATCH - 1) - (int)(strend-scan); | |
433 | scan = strend - (MAX_MATCH-1); | |
434 | ||
435 | #else /* UNALIGNED_OK */ | |
436 | ||
437 | if (match[best_len] != scan_end || | |
438 | match[best_len-1] != scan_end1 || | |
439 | *match != *scan || | |
440 | *++match != scan[1]) continue; | |
441 | ||
442 | /* The check at best_len-1 can be removed because it will be made | |
443 | * again later. (This heuristic is not always a win.) | |
444 | * It is not necessary to compare scan[2] and match[2] since they | |
445 | * are always equal when the other bytes match, given that | |
446 | * the hash keys are equal and that HASH_BITS >= 8. | |
447 | */ | |
448 | scan += 2, match++; | |
449 | ||
450 | /* We check for insufficient lookahead only every 8th comparison; | |
451 | * the 256th check will be made at strstart+258. | |
452 | */ | |
453 | do { | |
454 | } while (*++scan == *++match && *++scan == *++match && | |
455 | *++scan == *++match && *++scan == *++match && | |
456 | *++scan == *++match && *++scan == *++match && | |
457 | *++scan == *++match && *++scan == *++match && | |
458 | scan < strend); | |
459 | ||
460 | len = MAX_MATCH - (int)(strend - scan); | |
461 | scan = strend - MAX_MATCH; | |
462 | ||
463 | #endif /* UNALIGNED_OK */ | |
464 | ||
465 | if (len > best_len) { | |
466 | match_start = cur_match; | |
467 | best_len = len; | |
468 | if (len >= nice_match) break; | |
469 | #ifdef UNALIGNED_OK | |
470 | scan_end = *(ush*)(scan+best_len-1); | |
471 | #else | |
472 | scan_end1 = scan[best_len-1]; | |
473 | scan_end = scan[best_len]; | |
474 | #endif | |
475 | } | |
476 | } while ((cur_match = prev[cur_match & WMASK]) > limit | |
477 | && --chain_length != 0); | |
478 | ||
479 | return best_len; | |
480 | } | |
481 | #endif /* ASMV */ | |
482 | ||
483 | #ifdef DEBUG | |
484 | /* =========================================================================== | |
485 | * Check that the match at match_start is indeed a match. | |
486 | */ | |
487 | local void check_match(start, match, length) | |
488 | IPos start, match; | |
489 | int length; | |
490 | { | |
491 | /* check that the match is indeed a match */ | |
492 | if (memcmp((char*)window + match, | |
493 | (char*)window + start, length) != EQUAL) { | |
494 | fprintf(stderr, | |
495 | " start %d, match %d, length %d\n", | |
496 | start, match, length); | |
497 | error("invalid match"); | |
498 | } | |
499 | if (verbose > 1) { | |
500 | fprintf(stderr,"\\[%d,%d]", start-match, length); | |
501 | do { putc(window[start++], stderr); } while (--length != 0); | |
502 | } | |
503 | } | |
504 | #else | |
505 | # define check_match(start, match, length) | |
506 | #endif | |
507 | ||
508 | /* =========================================================================== | |
509 | * Fill the window when the lookahead becomes insufficient. | |
510 | * Updates strstart and lookahead, and sets eofile if end of input file. | |
511 | * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0 | |
512 | * OUT assertions: at least one byte has been read, or eofile is set; | |
513 | * file reads are performed for at least two bytes (required for the | |
514 | * translate_eol option). | |
515 | */ | |
516 | local void fill_window() | |
517 | { | |
518 | register unsigned n, m; | |
519 | unsigned more = (unsigned)(window_size - (ulg)lookahead - (ulg)strstart); | |
520 | /* Amount of free space at the end of the window. */ | |
521 | ||
522 | /* If the window is almost full and there is insufficient lookahead, | |
523 | * move the upper half to the lower one to make room in the upper half. | |
524 | */ | |
525 | if (more == (unsigned)EOF) { | |
526 | /* Very unlikely, but possible on 16 bit machine if strstart == 0 | |
527 | * and lookahead == 1 (input done one byte at time) | |
528 | */ | |
529 | more--; | |
530 | } else if (strstart >= WSIZE+MAX_DIST) { | |
531 | /* By the IN assertion, the window is not empty so we can't confuse | |
532 | * more == 0 with more == 64K on a 16 bit machine. | |
533 | */ | |
534 | Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM"); | |
535 | ||
536 | memcpy((char*)window, (char*)window+WSIZE, (unsigned)WSIZE); | |
537 | match_start -= WSIZE; | |
538 | strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */ | |
539 | ||
540 | block_start -= (long) WSIZE; | |
541 | ||
542 | for (n = 0; n < HASH_SIZE; n++) { | |
543 | m = head[n]; | |
544 | head[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL); | |
545 | } | |
546 | for (n = 0; n < WSIZE; n++) { | |
547 | m = prev[n]; | |
548 | prev[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL); | |
549 | /* If n is not on any hash chain, prev[n] is garbage but | |
550 | * its value will never be used. | |
551 | */ | |
552 | } | |
553 | more += WSIZE; | |
554 | } | |
555 | /* At this point, more >= 2 */ | |
556 | if (!eofile) { | |
557 | n = read_buf((char*)window+strstart+lookahead, more); | |
558 | if (n == 0 || n == (unsigned)EOF) { | |
559 | eofile = 1; | |
560 | } else { | |
561 | lookahead += n; | |
562 | } | |
563 | } | |
564 | } | |
565 | ||
566 | /* =========================================================================== | |
567 | * Flush the current block, with given end-of-file flag. | |
568 | * IN assertion: strstart is set to the end of the current match. | |
569 | */ | |
570 | #define FLUSH_BLOCK(eof) \ | |
571 | flush_block(block_start >= 0L ? (char*)&window[(unsigned)block_start] : \ | |
572 | (char*)NULL, (long)strstart - block_start, (eof)) | |
573 | ||
574 | /* =========================================================================== | |
78ed81a3 | 575 | * Processes a new input file and return its compressed length. This |
576 | * function does not perform lazy evaluationof matches and inserts | |
577 | * new strings in the dictionary only for unmatched strings or for short | |
578 | * matches. It is used only for the fast compression options. | |
3013fe88 | 579 | */ |
78ed81a3 | 580 | local ulg deflate_fast() |
3013fe88 NW |
581 | { |
582 | IPos hash_head; /* head of the hash chain */ | |
583 | int flush; /* set if current block must be flushed */ | |
584 | unsigned match_length = 0; /* length of best match */ | |
585 | ||
586 | prev_length = MIN_MATCH-1; | |
587 | while (lookahead != 0) { | |
588 | /* Insert the string window[strstart .. strstart+2] in the | |
589 | * dictionary, and set hash_head to the head of the hash chain: | |
590 | */ | |
591 | INSERT_STRING(strstart, hash_head); | |
592 | ||
593 | /* Find the longest match, discarding those <= prev_length. | |
594 | * At this point we have always match_length < MIN_MATCH | |
595 | */ | |
596 | if (hash_head != NIL && strstart - hash_head <= MAX_DIST) { | |
597 | /* To simplify the code, we prevent matches with the string | |
598 | * of window index 0 (in particular we have to avoid a match | |
599 | * of the string with itself at the start of the input file). | |
600 | */ | |
601 | match_length = longest_match (hash_head); | |
602 | /* longest_match() sets match_start */ | |
603 | if (match_length > lookahead) match_length = lookahead; | |
604 | } | |
605 | if (match_length >= MIN_MATCH) { | |
606 | check_match(strstart, match_start, match_length); | |
607 | ||
608 | flush = ct_tally(strstart-match_start, match_length - MIN_MATCH); | |
609 | ||
610 | lookahead -= match_length; | |
78ed81a3 | 611 | |
612 | /* Insert new strings in the hash table only if the match length | |
613 | * is not too large. This saves time but degrades compression. | |
614 | */ | |
615 | if (match_length <= max_insert_length) { | |
616 | match_length--; /* string at strstart already in hash table */ | |
617 | do { | |
618 | strstart++; | |
619 | INSERT_STRING(strstart, hash_head); | |
620 | /* strstart never exceeds WSIZE-MAX_MATCH, so there are | |
621 | * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH | |
622 | * these bytes are garbage, but it does not matter since | |
623 | * the next lookahead bytes will be emitted as literals. | |
624 | */ | |
625 | } while (--match_length != 0); | |
626 | strstart++; | |
627 | } else { | |
628 | strstart += match_length; | |
629 | match_length = 0; | |
630 | ins_h = window[strstart]; | |
631 | UPDATE_HASH(ins_h, window[strstart+1]); | |
632 | #if MIN_MATCH != 3 | |
633 | Call UPDATE_HASH() MIN_MATCH-3 more times | |
634 | #endif | |
635 | } | |
3013fe88 NW |
636 | } else { |
637 | /* No match, output a literal byte */ | |
78ed81a3 | 638 | Tracevv((stderr,"%c",window[strstart])); |
3013fe88 NW |
639 | flush = ct_tally (0, window[strstart]); |
640 | lookahead--; | |
78ed81a3 | 641 | strstart++; |
3013fe88 | 642 | } |
3013fe88 NW |
643 | if (flush) FLUSH_BLOCK(0), block_start = strstart; |
644 | ||
645 | /* Make sure that we always have enough lookahead, except | |
646 | * at the end of the input file. We need MAX_MATCH bytes | |
647 | * for the next match, plus MIN_MATCH bytes to insert the | |
648 | * string following the next match. | |
649 | */ | |
650 | while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); | |
651 | ||
652 | } | |
653 | return FLUSH_BLOCK(1); /* eof */ | |
654 | } | |
78ed81a3 | 655 | |
3013fe88 NW |
656 | /* =========================================================================== |
657 | * Same as above, but achieves better compression. We use a lazy | |
658 | * evaluation for matches: a match is finally adopted only if there is | |
659 | * no better match at the next window position. | |
660 | */ | |
661 | ulg deflate() | |
662 | { | |
663 | IPos hash_head; /* head of hash chain */ | |
664 | IPos prev_match; /* previous match */ | |
665 | int flush; /* set if current block must be flushed */ | |
666 | int match_available = 0; /* set if previous match exists */ | |
667 | register unsigned match_length = MIN_MATCH-1; /* length of best match */ | |
668 | #ifdef DEBUG | |
669 | extern long isize; /* byte length of input file, for debug only */ | |
670 | #endif | |
671 | ||
78ed81a3 | 672 | if (compr_level <= 3) return deflate_fast(); /* optimized for speed */ |
673 | ||
3013fe88 NW |
674 | /* Process the input block. */ |
675 | while (lookahead != 0) { | |
676 | /* Insert the string window[strstart .. strstart+2] in the | |
677 | * dictionary, and set hash_head to the head of the hash chain: | |
678 | */ | |
679 | INSERT_STRING(strstart, hash_head); | |
680 | ||
681 | /* Find the longest match, discarding those <= prev_length. | |
682 | */ | |
683 | prev_length = match_length, prev_match = match_start; | |
684 | match_length = MIN_MATCH-1; | |
685 | ||
686 | if (hash_head != NIL && prev_length < max_lazy_match && | |
687 | strstart - hash_head <= MAX_DIST) { | |
688 | /* To simplify the code, we prevent matches with the string | |
689 | * of window index 0 (in particular we have to avoid a match | |
690 | * of the string with itself at the start of the input file). | |
691 | */ | |
692 | match_length = longest_match (hash_head); | |
693 | /* longest_match() sets match_start */ | |
694 | if (match_length > lookahead) match_length = lookahead; | |
695 | ||
696 | /* Ignore a length 3 match if it is too distant: */ | |
697 | if (match_length == MIN_MATCH && strstart-match_start > TOO_FAR){ | |
698 | /* If prev_match is also MIN_MATCH, match_start is garbage | |
699 | * but we will ignore the current match anyway. | |
700 | */ | |
701 | match_length--; | |
702 | } | |
703 | } | |
704 | /* If there was a match at the previous step and the current | |
705 | * match is not better, output the previous match: | |
706 | */ | |
707 | if (prev_length >= MIN_MATCH && match_length <= prev_length) { | |
708 | ||
709 | check_match(strstart-1, prev_match, prev_length); | |
710 | ||
711 | flush = ct_tally(strstart-1-prev_match, prev_length - MIN_MATCH); | |
712 | ||
713 | /* Insert in hash table all strings up to the end of the match. | |
714 | * strstart-1 and strstart are already inserted. | |
715 | */ | |
716 | lookahead -= prev_length-1; | |
717 | prev_length -= 2; | |
718 | do { | |
719 | strstart++; | |
720 | INSERT_STRING(strstart, hash_head); | |
721 | /* strstart never exceeds WSIZE-MAX_MATCH, so there are | |
722 | * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH | |
723 | * these bytes are garbage, but it does not matter since the | |
724 | * next lookahead bytes will always be emitted as literals. | |
725 | */ | |
726 | } while (--prev_length != 0); | |
727 | match_available = 0; | |
728 | match_length = MIN_MATCH-1; | |
729 | strstart++; | |
730 | if (flush) FLUSH_BLOCK(0), block_start = strstart; | |
731 | ||
732 | } else if (match_available) { | |
733 | /* If there was no match at the previous position, output a | |
734 | * single literal. If there was a match but the current match | |
735 | * is longer, truncate the previous match to a single literal. | |
736 | */ | |
737 | Tracevv((stderr,"%c",window[strstart-1])); | |
738 | if (ct_tally (0, window[strstart-1])) { | |
739 | FLUSH_BLOCK(0), block_start = strstart; | |
740 | } | |
741 | strstart++; | |
742 | lookahead--; | |
743 | } else { | |
744 | /* There is no previous match to compare with, wait for | |
745 | * the next step to decide. | |
746 | */ | |
747 | match_available = 1; | |
748 | strstart++; | |
749 | lookahead--; | |
750 | } | |
751 | Assert (strstart <= isize && lookahead <= isize, "a bit too far"); | |
752 | ||
753 | /* Make sure that we always have enough lookahead, except | |
754 | * at the end of the input file. We need MAX_MATCH bytes | |
755 | * for the next match, plus MIN_MATCH bytes to insert the | |
756 | * string following the next match. | |
757 | */ | |
758 | while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window(); | |
759 | } | |
760 | if (match_available) ct_tally (0, window[strstart-1]); | |
761 | ||
762 | return FLUSH_BLOCK(1); /* eof */ | |
763 | } |