1 /* vi: set sw=4 ts=4: */
3 * Gzip implementation for busybox
5 * Based on GNU gzip Copyright (C) 1992-1993 Jean-loup Gailly.
7 * Originally adjusted for busybox by Charles P. Wright <cpw@unix.asb.com>
8 * "this is a stripped down version of gzip I put into busybox, it does
9 * only standard in to standard out with -9 compression. It also requires
10 * the zcat module for some important functions."
12 * Adjusted further by Erik Andersen <andersen@codepoet.org> to support
13 * files as well as stdin/stdout, and to generally behave itself wrt
14 * command line handling.
16 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
18 /* TODO: full support for -v for DESKTOP
19 * "/usr/bin/gzip -v a bogus aa" should say:
20 a: 85.1% -- replaced with a.gz
21 gzip: bogus: No such file or directory
22 aa: 85.1% -- replaced with aa.gz
25 //config: bool "gzip (19 kb)"
28 //config: gzip is used to compress files.
29 //config: It's probably the most widely used UNIX compression program.
31 //config:config FEATURE_GZIP_LONG_OPTIONS
32 //config: bool "Enable long options"
34 //config: depends on GZIP && LONG_OPTS
36 //config:config GZIP_FAST
37 //config: int "Trade memory for speed (0:small,slow - 2:fast,big)"
40 //config: depends on GZIP
42 //config: Enable big memory options for gzip.
43 //config: 0: small buffers, small hash-tables
44 //config: 1: larger buffers, larger hash-tables
45 //config: 2: larger buffers, largest hash-tables
46 //config: Larger models may give slightly better compression
48 //config:config FEATURE_GZIP_LEVELS
49 //config: bool "Enable compression levels"
51 //config: depends on GZIP
53 //config: Enable support for compression levels 4-9. The default level
54 //config: is 6. If levels 1-3 are specified, 4 is used.
55 //config: If this option is not selected, -N options are ignored and -9
58 //config:config FEATURE_GZIP_DECOMPRESS
59 //config: bool "Enable decompression"
61 //config: depends on GZIP || GUNZIP || ZCAT
63 //config: Enable -d (--decompress) and -t (--test) options for gzip.
64 //config: This will be automatically selected if gunzip or zcat is
67 //applet:IF_GZIP(APPLET(gzip, BB_DIR_BIN, BB_SUID_DROP))
69 //kbuild:lib-$(CONFIG_GZIP) += gzip.o
71 //usage:#define gzip_trivial_usage
72 //usage: "[-cfk" IF_FEATURE_GZIP_DECOMPRESS("dt") IF_FEATURE_GZIP_LEVELS("123456789") "] [FILE]..."
73 //usage:#define gzip_full_usage "\n\n"
74 //usage: "Compress FILEs (or stdin)\n"
75 //usage: IF_FEATURE_GZIP_LEVELS(
76 //usage: "\n -1..9 Compression level"
78 //usage: IF_FEATURE_GZIP_DECOMPRESS(
79 //usage: "\n -d Decompress"
80 //usage: "\n -t Test file integrity"
82 //usage: "\n -c Write to stdout"
83 //usage: "\n -f Force"
84 //usage: "\n -k Keep input files"
86 //usage:#define gzip_example_usage
87 //usage: "$ ls -la /tmp/busybox*\n"
88 //usage: "-rw-rw-r-- 1 andersen andersen 1761280 Apr 14 17:47 /tmp/busybox.tar\n"
89 //usage: "$ gzip /tmp/busybox.tar\n"
90 //usage: "$ ls -la /tmp/busybox*\n"
91 //usage: "-rw-rw-r-- 1 andersen andersen 554058 Apr 14 17:49 /tmp/busybox.tar.gz\n"
94 #include "bb_archive.h"
97 /* ===========================================================================
100 /* Diagnostic functions */
103 # define Assert(cond,msg) { if (!(cond)) bb_error_msg(msg); }
104 # define Trace(x) fprintf x
105 # define Tracev(x) {if (verbose) fprintf x; }
106 # define Tracevv(x) {if (verbose > 1) fprintf x; }
107 # define Tracec(c,x) {if (verbose && (c)) fprintf x; }
108 # define Tracecv(c,x) {if (verbose > 1 && (c)) fprintf x; }
110 # define Assert(cond,msg)
115 # define Tracecv(c,x)
119 /* ===========================================================================
121 #if CONFIG_GZIP_FAST == 0
123 #elif CONFIG_GZIP_FAST == 1
125 #elif CONFIG_GZIP_FAST == 2
128 # error "Invalid CONFIG_GZIP_FAST value"
133 # define INBUFSIZ 0x2000 /* input buffer size */
135 # define INBUFSIZ 0x8000 /* input buffer size */
141 # define OUTBUFSIZ 8192 /* output buffer size */
143 # define OUTBUFSIZ 16384 /* output buffer size */
149 # define DIST_BUFSIZE 0x2000 /* buffer for distances, see trees.c */
151 # define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */
156 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
157 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
158 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
159 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
160 #define COMMENT 0x10 /* bit 4 set: file comment present */
161 #define RESERVED 0xC0 /* bit 6,7: reserved */
163 /* internal file attribute */
164 #define UNKNOWN 0xffff
169 # define WSIZE 0x8000 /* window size--must be a power of two, and */
170 #endif /* at least 32K for zip's deflate method */
173 #define MAX_MATCH 258
174 /* The minimum and maximum match lengths */
176 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
177 /* Minimum amount of lookahead, except at the end of the input file.
178 * See deflate.c for comments about the MIN_MATCH+1.
181 #define MAX_DIST (WSIZE-MIN_LOOKAHEAD)
182 /* In order to simplify the code, particularly on 16 bit machines, match
183 * distances are limited to MAX_DIST instead of WSIZE.
187 # define MAX_PATH_LEN 1024 /* max pathname length */
190 #define seekable() 0 /* force sequential output */
191 #define translate_eol 0 /* no option -a yet */
196 #define INIT_BITS 9 /* Initial number of bits per code */
198 #define BIT_MASK 0x1f /* Mask for 'number of compression bits' */
199 /* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free.
200 * It's a pity that old uncompress does not check bit 0x20. That makes
201 * extension of the format actually undesirable because old compress
202 * would just crash on the new format instead of giving a meaningful
203 * error message. It does check the number of bits, but it's more
204 * helpful to say "unsupported format, get a new version" than
205 * "can only handle 16 bits".
209 # define MAX_SUFFIX MAX_EXT_CHARS
211 # define MAX_SUFFIX 30
215 /* ===========================================================================
216 * Compile with MEDIUM_MEM to reduce the memory requirements or
217 * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
218 * entire input file can be held in memory (not possible on 16 bit systems).
219 * Warning: defining these symbols affects HASH_BITS (see below) and thus
220 * affects the compression ratio. The compressed output
221 * is still correct, and might even be smaller in some cases.
225 # define HASH_BITS 13 /* Number of bits used to hash strings */
228 # define HASH_BITS 14
231 # define HASH_BITS 15
232 /* For portability to 16 bit machines, do not use values above 15. */
235 #define HASH_SIZE (unsigned)(1<<HASH_BITS)
236 #define HASH_MASK (HASH_SIZE-1)
237 #define WMASK (WSIZE-1)
238 /* HASH_SIZE and WSIZE must be powers of two */
240 # define TOO_FAR 4096
242 /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
245 /* ===========================================================================
246 * These types are not really 'char', 'short' and 'long'
249 typedef uint16_t ush;
250 typedef uint32_t ulg;
254 typedef unsigned IPos;
255 /* A Pos is an index in the character window. We use short instead of int to
256 * save space in the various tables. IPos is used only for parameter passing.
260 WINDOW_SIZE = 2 * WSIZE,
261 /* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
262 * input file length plus MIN_LOOKAHEAD.
265 #if !ENABLE_FEATURE_GZIP_LEVELS
267 max_chain_length = 4096,
268 /* To speed up deflation, hash chains are never searched beyond this length.
269 * A higher limit improves compression ratio but degrades the speed.
272 max_lazy_match = 258,
273 /* Attempt to find a better match only when the current match is strictly
274 * smaller than this value. This mechanism is used only for compression
278 max_insert_length = max_lazy_match,
279 /* Insert new strings in the hash table only if the match length
280 * is not greater than this length. This saves time but degrades compression.
281 * max_insert_length is used only for compression levels <= 3.
285 /* Use a faster search when the previous match is longer than this */
287 /* Values for max_lazy_match, good_match and max_chain_length, depending on
288 * the desired pack level (0..9). The values given below have been tuned to
289 * exclude worst case performance for pathological files. Better values may be
290 * found for specific files.
293 nice_match = 258, /* Stop searching when current match exceeds this */
294 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
295 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
298 #endif /* ENABLE_FEATURE_GZIP_LEVELS */
303 /* =========================================================================== */
304 /* global buffers, allocated once */
306 #define DECLARE(type, array, size) \
308 #define ALLOC(type, array, size) \
309 array = xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type))
310 #define FREE(array) \
311 do { free(array); array = NULL; } while (0)
313 /* buffer for literals or lengths */
314 /* DECLARE(uch, l_buf, LIT_BUFSIZE); */
315 DECLARE(uch, l_buf, INBUFSIZ);
317 DECLARE(ush, d_buf, DIST_BUFSIZE);
318 DECLARE(uch, outbuf, OUTBUFSIZ);
320 /* Sliding window. Input bytes are read into the second half of the window,
321 * and move to the first half later to keep a dictionary of at least WSIZE
322 * bytes. With this organization, matches are limited to a distance of
323 * WSIZE-MAX_MATCH bytes, but this ensures that IO is always
324 * performed with a length multiple of the block size. Also, it limits
325 * the window size to 64K, which is quite useful on MSDOS.
326 * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
327 * be less efficient).
329 DECLARE(uch, window, 2L * WSIZE);
331 /* Link to older string with same hash index. To limit the size of this
332 * array to 64K, this link is maintained only for the last 32K strings.
333 * An index in this array is thus a window index modulo 32K.
335 /* DECLARE(Pos, prev, WSIZE); */
336 DECLARE(ush, prev, 1L << BITS);
338 /* Heads of the hash chains or 0. */
339 /* DECLARE(Pos, head, 1<<HASH_BITS); */
340 #define head (G1.prev + WSIZE) /* hash head (see deflate.c) */
342 /* =========================================================================== */
343 /* all members below are zeroed out in pack_gzip() for each next file */
345 uint32_t crc; /* shift register contents */
346 /*uint32_t *crc_32_tab;*/
348 #if ENABLE_FEATURE_GZIP_LEVELS
349 unsigned max_chain_length;
350 unsigned max_lazy_match;
353 #define max_chain_length (G1.max_chain_length)
354 #define max_lazy_match (G1.max_lazy_match)
355 #define good_match (G1.good_match)
356 #define nice_match (G1.nice_match)
359 /* window position at the beginning of the current output block. Gets
360 * negative when the window is moved backwards.
364 unsigned ins_h; /* hash index of string to be inserted */
366 /* Number of bits by which ins_h and del_h must be shifted at each
367 * input step. It must be such that after MIN_MATCH steps, the oldest
368 * byte no longer takes part in the hash key, that is:
369 * H_SHIFT * MIN_MATCH >= HASH_BITS
371 #define H_SHIFT ((HASH_BITS+MIN_MATCH-1) / MIN_MATCH)
373 /* Length of the best match at previous step. Matches not greater than this
374 * are discarded. This is used in the lazy match evaluation.
376 unsigned prev_length;
378 unsigned strstart; /* start of string to insert */
379 unsigned match_start; /* start of matching string */
380 unsigned lookahead; /* number of valid bytes ahead in window */
382 /* number of input bytes */
383 ulg isize; /* only 32 bits stored in .gz file */
385 /* bbox always use stdin/stdout */
386 #define ifd STDIN_FILENO /* input file descriptor */
387 #define ofd STDOUT_FILENO /* output file descriptor */
390 unsigned insize; /* valid bytes in l_buf */
392 unsigned outcnt; /* bytes in output buffer */
393 smallint eofile; /* flag set at end of input file */
395 /* ===========================================================================
396 * Local data used by the "bit string" routines.
399 /* Output buffer. bits are inserted starting at the bottom (least significant
402 unsigned bi_buf; /* was unsigned short */
405 #define BUF_SIZE (int)(8 * sizeof(G1.bi_buf))
407 /* Number of bits used within bi_buf. (bi_buf might be implemented on
408 * more than 16 bits on some systems.)
413 ulg bits_sent; /* bit length of the compressed data */
414 # define DEBUG_bits_sent(v) (void)(G1.bits_sent v)
416 # define DEBUG_bits_sent(v) ((void)0)
420 #define G1 (*(ptr_to_globals - 1))
423 /* ===========================================================================
424 * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
425 * (used for the compressed data only)
427 static void flush_outbuf(void)
432 xwrite(ofd, (char *) G1.outbuf, G1.outcnt);
437 /* ===========================================================================
439 /* put_8bit is used for the compressed output */
440 #define put_8bit(c) \
442 G1.outbuf[G1.outcnt++] = (c); \
443 if (G1.outcnt == OUTBUFSIZ) \
447 /* Output a 16 bit value, lsb first */
448 static void put_16bit(ush w)
450 /* GCC 4.2.1 won't optimize out redundant loads of G1.outcnt
451 * (probably because of fear of aliasing with G1.outbuf[]
452 * stores), do it explicitly:
454 unsigned outcnt = G1.outcnt;
455 uch *dst = &G1.outbuf[outcnt];
457 #if BB_UNALIGNED_MEMACCESS_OK && BB_LITTLE_ENDIAN
458 if (outcnt < OUTBUFSIZ-2) {
460 ush *dst16 = (void*) dst;
461 *dst16 = w; /* unaligned LSB 16-bit store */
462 G1.outcnt = outcnt + 2;
467 G1.outcnt = ++outcnt;
471 if (outcnt < OUTBUFSIZ-2) {
474 G1.outcnt = outcnt + 2;
477 G1.outcnt = ++outcnt;
480 /* Slowpath: we will need to do flush_outbuf() */
481 if (outcnt == OUTBUFSIZ)
482 flush_outbuf(); /* here */
483 put_8bit(w); /* or here */
486 #define OPTIMIZED_PUT_32BIT (CONFIG_GZIP_FAST > 0 && BB_UNALIGNED_MEMACCESS_OK && BB_LITTLE_ENDIAN)
487 static void put_32bit(ulg n)
489 if (OPTIMIZED_PUT_32BIT) {
490 unsigned outcnt = G1.outcnt;
491 if (outcnt < OUTBUFSIZ-4) {
493 ulg *dst32 = (void*) &G1.outbuf[outcnt];
494 *dst32 = n; /* unaligned LSB 32-bit store */
495 //bb_error_msg("%p", dst32); // store alignment debugging
496 G1.outcnt = outcnt + 4;
503 static ALWAYS_INLINE void flush_outbuf_if_32bit_optimized(void)
505 /* If put_32bit() performs 32bit stores && it is used in send_bits() */
506 if (OPTIMIZED_PUT_32BIT && BUF_SIZE > 16)
510 /* ===========================================================================
511 * Run a set of bytes through the crc shift register. If s is a NULL
512 * pointer, then initialize the crc shift register contents instead.
513 * Return the current crc in either case.
515 static void updcrc(uch * s, unsigned n)
517 G1.crc = crc32_block_endian0(G1.crc, s, n, global_crc32_table /*G1.crc_32_tab*/);
521 /* ===========================================================================
522 * Read a new buffer from the current input file, perform end-of-line
523 * translation, and update the crc and input file size.
524 * IN assertion: size >= 2 (for end-of-line translation)
526 static unsigned file_read(void *buf, unsigned size)
530 Assert(G1.insize == 0, "l_buf not empty");
532 len = safe_read(ifd, buf, size);
533 if (len == (unsigned)(-1) || len == 0)
542 /* ===========================================================================
543 * Send a value on a given number of bits.
544 * IN assertion: length <= 16 and value fits in length bits.
546 static void send_bits(unsigned value, unsigned length)
551 Tracev((stderr, " l %2d v %4x ", length, value));
552 Assert(length > 0 && length <= 15, "invalid length");
553 DEBUG_bits_sent(+= length);
555 BUILD_BUG_ON(BUF_SIZE != 32 && BUF_SIZE != 16);
557 new_buf = G1.bi_buf | (value << G1.bi_valid);
558 /* NB: the above may sometimes do "<< 32" shift (undefined)
559 * if check below is changed to "length > BUF_SIZE" instead of >= */
560 length += G1.bi_valid;
562 /* If bi_buf is full */
563 if (length >= BUF_SIZE) {
564 /* ...use (valid) bits from bi_buf and
565 * (BUF_SIZE - bi_valid) bits from value,
566 * leaving (width - (BUF_SIZE-bi_valid)) unused bits in value.
568 value >>= (BUF_SIZE - G1.bi_valid);
569 if (BUF_SIZE == 32) {
578 G1.bi_valid = length;
582 /* ===========================================================================
583 * Reverse the first len bits of a code, using straightforward code (a faster
584 * method would use a table)
585 * IN assertion: 1 <= len <= 15
587 static unsigned bi_reverse(unsigned code, int len)
593 if (--len <= 0) return res;
600 /* ===========================================================================
601 * Write out any remaining bits in an incomplete byte.
603 static void bi_windup(void)
605 unsigned bits = G1.bi_buf;
606 int cnt = G1.bi_valid;
615 DEBUG_bits_sent(= (G1.bits_sent + 7) & ~7);
619 /* ===========================================================================
620 * Copy a stored block to the zip file, storing first the length and its
621 * one's complement if requested.
623 static void copy_block(char *buf, unsigned len, int header)
625 bi_windup(); /* align on byte boundary */
628 unsigned v = ((uint16_t)len) | ((~len) << 16);
630 DEBUG_bits_sent(+= 2 * 16);
632 DEBUG_bits_sent(+= (ulg) len << 3);
636 /* The above can 32-bit misalign outbuf */
637 flush_outbuf_if_32bit_optimized();
641 /* ===========================================================================
642 * Fill the window when the lookahead becomes insufficient.
643 * Updates strstart and lookahead, and sets eofile if end of input file.
644 * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
645 * OUT assertions: at least one byte has been read, or eofile is set;
646 * file reads are performed for at least two bytes (required for the
647 * translate_eol option).
649 static void fill_window(void)
652 unsigned more = WINDOW_SIZE - G1.lookahead - G1.strstart;
653 /* Amount of free space at the end of the window. */
655 /* If the window is almost full and there is insufficient lookahead,
656 * move the upper half to the lower one to make room in the upper half.
658 if (more == (unsigned) -1) {
659 /* Very unlikely, but possible on 16 bit machine if strstart == 0
660 * and lookahead == 1 (input done one byte at time)
663 } else if (G1.strstart >= WSIZE + MAX_DIST) {
664 /* By the IN assertion, the window is not empty so we can't confuse
665 * more == 0 with more == 64K on a 16 bit machine.
667 Assert(WINDOW_SIZE == 2 * WSIZE, "no sliding with BIG_MEM");
669 memcpy(G1.window, G1.window + WSIZE, WSIZE);
670 G1.match_start -= WSIZE;
671 G1.strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */
673 G1.block_start -= WSIZE;
675 for (n = 0; n < HASH_SIZE; n++) {
677 head[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
679 for (n = 0; n < WSIZE; n++) {
681 G1.prev[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
682 /* If n is not on any hash chain, prev[n] is garbage but
683 * its value will never be used.
688 /* At this point, more >= 2 */
690 n = file_read(G1.window + G1.strstart + G1.lookahead, more);
691 if (n == 0 || n == (unsigned) -1) {
698 /* Both users fill window with the same loop: */
699 static void fill_window_if_needed(void)
701 while (G1.lookahead < MIN_LOOKAHEAD && !G1.eofile)
706 /* ===========================================================================
707 * Set match_start to the longest match starting at the given string and
708 * return its length. Matches shorter or equal to prev_length are discarded,
709 * in which case the result is equal to prev_length and match_start is
711 * IN assertions: cur_match is the head of the hash chain for the current
712 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
715 /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or
716 * match.s. The code is functionally equivalent, so you can use the C version
719 static int longest_match(IPos cur_match)
721 unsigned chain_length = max_chain_length; /* max hash chain length */
722 uch *scan = G1.window + G1.strstart; /* current string */
723 uch *match; /* matched string */
724 int len; /* length of current match */
725 int best_len = G1.prev_length; /* best match length so far */
726 IPos limit = G1.strstart > (IPos) MAX_DIST ? G1.strstart - (IPos) MAX_DIST : 0;
727 /* Stop when cur_match becomes <= limit. To simplify the code,
728 * we prevent matches with the string of window index 0.
731 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
732 * It is easy to get rid of this optimization if necessary.
734 #if HASH_BITS < 8 || MAX_MATCH != 258
735 # error Code too clever
737 uch *strend = G1.window + G1.strstart + MAX_MATCH;
738 uch scan_end1 = scan[best_len - 1];
739 uch scan_end = scan[best_len];
741 /* Do not waste too much time if we already have a good match: */
742 if (G1.prev_length >= good_match) {
745 Assert(G1.strstart <= WINDOW_SIZE - MIN_LOOKAHEAD, "insufficient lookahead");
748 Assert(cur_match < G1.strstart, "no future");
749 match = G1.window + cur_match;
751 /* Skip to next match if the match length cannot increase
752 * or if the match length is less than 2:
754 if (match[best_len] != scan_end
755 || match[best_len - 1] != scan_end1
756 || *match != *scan || *++match != scan[1]
761 /* The check at best_len-1 can be removed because it will be made
762 * again later. (This heuristic is not always a win.)
763 * It is not necessary to compare scan[2] and match[2] since they
764 * are always equal when the other bytes match, given that
765 * the hash keys are equal and that HASH_BITS >= 8.
769 /* We check for insufficient lookahead only every 8th comparison;
770 * the 256th check will be made at strstart+258.
773 } while (*++scan == *++match && *++scan == *++match &&
774 *++scan == *++match && *++scan == *++match &&
775 *++scan == *++match && *++scan == *++match &&
776 *++scan == *++match && *++scan == *++match && scan < strend);
778 len = MAX_MATCH - (int) (strend - scan);
779 scan = strend - MAX_MATCH;
781 if (len > best_len) {
782 G1.match_start = cur_match;
784 if (len >= nice_match)
786 scan_end1 = scan[best_len - 1];
787 scan_end = scan[best_len];
789 } while ((cur_match = G1.prev[cur_match & WMASK]) > limit
790 && --chain_length != 0);
797 /* ===========================================================================
798 * Check that the match at match_start is indeed a match.
800 static void check_match(IPos start, IPos match, int length)
802 /* check that the match is indeed a match */
803 if (memcmp(G1.window + match, G1.window + start, length) != 0) {
804 bb_error_msg(" start %d, match %d, length %d", start, match, length);
805 bb_error_msg("invalid match");
808 bb_error_msg("\\[%d,%d]", start - match, length);
810 bb_putchar_stderr(G1.window[start++]);
811 } while (--length != 0);
815 # define check_match(start, match, length) ((void)0)
819 /* trees.c -- output deflated data using Huffman coding
820 * Copyright (C) 1992-1993 Jean-loup Gailly
821 * This is free software; you can redistribute it and/or modify it under the
822 * terms of the GNU General Public License, see the file COPYING.
826 * Encode various sets of source values using variable-length
830 * The PKZIP "deflation" process uses several Huffman trees. The more
831 * common source values are represented by shorter bit sequences.
833 * Each code tree is stored in the ZIP file in a compressed form
834 * which is itself a Huffman encoding of the lengths of
835 * all the code strings (in ascending order by source values).
836 * The actual code strings are reconstructed from the lengths in
837 * the UNZIP process, as described in the "application note"
838 * (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
842 * Data Compression: Techniques and Applications, pp. 53-55.
843 * Lifetime Learning Publications, 1985. ISBN 0-534-03418-7.
846 * Data Compression: Methods and Theory, pp. 49-50.
847 * Computer Science Press, 1988. ISBN 0-7167-8156-5.
851 * Addison-Wesley, 1983. ISBN 0-201-06672-6.
855 * Allocate the match buffer, initialize the various tables [and save
856 * the location of the internal file attribute (ascii/binary) and
857 * method (DEFLATE/STORE) -- deleted in bbox]
859 * void ct_tally(int dist, int lc);
860 * Save the match info and tally the frequency counts.
862 * ulg flush_block(char *buf, ulg stored_len, int eof)
863 * Determine the best encoding for the current block: dynamic trees,
864 * static trees or store, and output the encoded block to the zip
865 * file. Returns the total compressed length for the file so far.
869 /* All codes must not exceed MAX_BITS bits */
871 #define MAX_BL_BITS 7
872 /* Bit length codes must not exceed MAX_BL_BITS bits */
874 #define LENGTH_CODES 29
875 /* number of length codes, not counting the special END_BLOCK code */
878 /* number of literal bytes 0..255 */
880 #define END_BLOCK 256
881 /* end of block literal code */
883 #define L_CODES (LITERALS+1+LENGTH_CODES)
884 /* number of Literal or Length codes, including the END_BLOCK code */
887 /* number of distance codes */
890 /* number of codes used to transfer the bit lengths */
892 /* extra bits for each length code */
893 static const uint8_t extra_lbits[LENGTH_CODES] ALIGN1 = {
894 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
898 /* extra bits for each distance code */
899 static const uint8_t extra_dbits[D_CODES] ALIGN1 = {
900 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
901 10, 10, 11, 11, 12, 12, 13, 13
904 /* extra bits for each bit length code */
905 static const uint8_t extra_blbits[BL_CODES] ALIGN1 = {
906 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
908 /* number of codes at each bit length for an optimal tree */
909 static const uint8_t bl_order[BL_CODES] ALIGN1 = {
910 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
912 #define STORED_BLOCK 0
913 #define STATIC_TREES 1
915 /* The three kinds of block type */
919 # define LIT_BUFSIZE 0x2000
922 # define LIT_BUFSIZE 0x4000
924 # define LIT_BUFSIZE 0x8000
929 # define DIST_BUFSIZE LIT_BUFSIZE
931 /* Sizes of match buffers for literals/lengths and distances. There are
932 * 4 reasons for limiting LIT_BUFSIZE to 64K:
933 * - frequencies can be kept in 16 bit counters
934 * - if compression is not successful for the first block, all input data is
935 * still in the window so we can still emit a stored block even when input
936 * comes from standard input. (This can also be done for all blocks if
937 * LIT_BUFSIZE is not greater than 32K.)
938 * - if compression is not successful for a file smaller than 64K, we can
939 * even emit a stored file instead of a stored block (saving 5 bytes).
940 * - creating new Huffman trees less frequently may not provide fast
941 * adaptation to changes in the input data statistics. (Take for
942 * example a binary file with poorly compressible code followed by
943 * a highly compressible string table.) Smaller buffer sizes give
944 * fast adaptation but have of course the overhead of transmitting trees
946 * - I can't count above 4
947 * The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
948 * memory at the expense of compression). Some optimizations would be possible
949 * if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
952 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
954 /* repeat a zero length 3-10 times (3 bits of repeat count) */
955 #define REPZ_11_138 18
956 /* repeat a zero length 11-138 times (7 bits of repeat count) */
958 /* ===========================================================================
960 /* Data structure describing a single value and its code string. */
961 typedef struct ct_data {
963 ush freq; /* frequency count */
964 ush code; /* bit string */
967 ush dad; /* father node in Huffman tree */
968 ush len; /* length of bit string */
977 #define HEAP_SIZE (2*L_CODES + 1)
978 /* maximum heap size */
980 typedef struct tree_desc {
981 ct_data *dyn_tree; /* the dynamic tree */
982 ct_data *static_tree; /* corresponding static tree or NULL */
983 const uint8_t *extra_bits; /* extra bits for each code or NULL */
984 int extra_base; /* base index for extra_bits */
985 int elems; /* max number of elements in the tree */
986 int max_length; /* max bit length for the codes */
987 int max_code; /* largest code with non zero frequency */
992 ush heap[HEAP_SIZE]; /* heap used to build the Huffman trees */
993 int heap_len; /* number of elements in the heap */
994 int heap_max; /* element of largest frequency */
996 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
997 * The same heap array is used to build all trees.
1000 ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */
1001 ct_data dyn_dtree[2 * D_CODES + 1]; /* distance tree */
1003 ct_data static_ltree[L_CODES + 2];
1005 /* The static literal tree. Since the bit lengths are imposed, there is no
1006 * need for the L_CODES extra codes used during heap construction. However
1007 * The codes 286 and 287 are needed to build a canonical tree (see ct_init
1011 ct_data static_dtree[D_CODES];
1013 /* The static distance tree. (Actually a trivial tree since all codes use
1017 ct_data bl_tree[2 * BL_CODES + 1];
1019 /* Huffman tree for the bit lengths */
1025 ush bl_count[MAX_BITS + 1];
1027 /* The lengths of the bit length codes are sent in order of decreasing
1028 * probability, to avoid transmitting the lengths for unused bit length codes.
1031 uch depth[2 * L_CODES + 1];
1033 /* Depth of each subtree used as tie breaker for trees of equal frequency */
1035 uch length_code[MAX_MATCH - MIN_MATCH + 1];
1037 /* length code for each normalized match length (0 == MIN_MATCH) */
1041 /* distance codes. The first 256 values correspond to the distances
1042 * 3 .. 258, the last 256 values correspond to the top 8 bits of
1043 * the 15 bit distances.
1046 int base_length[LENGTH_CODES];
1048 /* First normalized length for each code (0 = MIN_MATCH) */
1050 int base_dist[D_CODES];
1052 /* First normalized distance for each code (0 = distance of 1) */
1054 uch flag_buf[LIT_BUFSIZE / 8];
1056 /* flag_buf is a bit array distinguishing literals from lengths in
1057 * l_buf, thus indicating the presence or absence of a distance.
1060 unsigned last_lit; /* running index in l_buf */
1061 unsigned last_dist; /* running index in d_buf */
1062 unsigned last_flags; /* running index in flag_buf */
1063 uch flags; /* current flags not yet saved in flag_buf */
1064 uch flag_bit; /* current bit used in flags */
1066 /* bits are filled in flags starting at bit 0 (least significant).
1067 * Note: these flags are overkill in the current code since we don't
1068 * take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
1071 ulg opt_len; /* bit length of current block with optimal trees */
1072 ulg static_len; /* bit length of current block with static trees */
1074 ulg compressed_len; /* total bit length of compressed file */
1077 #define G2ptr ((struct globals2*)(ptr_to_globals))
1081 /* ===========================================================================
1083 static void gen_codes(ct_data * tree, int max_code);
1084 static void build_tree(tree_desc * desc);
1085 static void scan_tree(ct_data * tree, int max_code);
1086 static void send_tree(ct_data * tree, int max_code);
1087 static int build_bl_tree(void);
1088 static void send_all_trees(int lcodes, int dcodes, int blcodes);
1089 static void compress_block(ct_data * ltree, ct_data * dtree);
1093 /* Send a code of the given tree. c and tree must not have side effects */
1094 # define SEND_CODE(c, tree) send_bits(tree[c].Code, tree[c].Len)
1096 # define SEND_CODE(c, tree) \
1098 if (verbose > 1) bb_error_msg("\ncd %3d ", (c)); \
1099 send_bits(tree[c].Code, tree[c].Len); \
1103 #define D_CODE(dist) \
1104 ((dist) < 256 ? G2.dist_code[dist] : G2.dist_code[256 + ((dist)>>7)])
1105 /* Mapping from a distance to a distance code. dist is the distance - 1 and
1106 * must not have side effects. dist_code[256] and dist_code[257] are never
1108 * The arguments must not have side effects.
1112 /* ===========================================================================
1113 * Initialize a new block.
1115 static void init_block(void)
1117 int n; /* iterates over tree elements */
1119 /* Initialize the trees. */
1120 for (n = 0; n < L_CODES; n++)
1121 G2.dyn_ltree[n].Freq = 0;
1122 for (n = 0; n < D_CODES; n++)
1123 G2.dyn_dtree[n].Freq = 0;
1124 for (n = 0; n < BL_CODES; n++)
1125 G2.bl_tree[n].Freq = 0;
1127 G2.dyn_ltree[END_BLOCK].Freq = 1;
1128 G2.opt_len = G2.static_len = 0;
1129 G2.last_lit = G2.last_dist = G2.last_flags = 0;
1135 /* ===========================================================================
1136 * Restore the heap property by moving down the tree starting at node k,
1137 * exchanging a node with the smallest of its two sons if necessary, stopping
1138 * when the heap property is re-established (each father smaller than its
1142 /* Compares to subtrees, using the tree depth as tie breaker when
1143 * the subtrees have equal frequency. This minimizes the worst case length. */
1144 #define SMALLER(tree, n, m) \
1145 (tree[n].Freq < tree[m].Freq \
1146 || (tree[n].Freq == tree[m].Freq && G2.depth[n] <= G2.depth[m]))
1148 static void pqdownheap(ct_data * tree, int k)
1151 int j = k << 1; /* left son of k */
1153 while (j <= G2.heap_len) {
1154 /* Set j to the smallest of the two sons: */
1155 if (j < G2.heap_len && SMALLER(tree, G2.heap[j + 1], G2.heap[j]))
1158 /* Exit if v is smaller than both sons */
1159 if (SMALLER(tree, v, G2.heap[j]))
1162 /* Exchange v with the smallest son */
1163 G2.heap[k] = G2.heap[j];
1166 /* And continue down the tree, setting j to the left son of k */
1173 /* ===========================================================================
1174 * Compute the optimal bit lengths for a tree and update the total bit length
1175 * for the current block.
1176 * IN assertion: the fields freq and dad are set, heap[heap_max] and
1177 * above are the tree nodes sorted by increasing frequency.
1178 * OUT assertions: the field len is set to the optimal bit length, the
1179 * array bl_count contains the frequencies for each bit length.
1180 * The length opt_len is updated; static_len is also updated if stree is
1183 static void gen_bitlen(tree_desc * desc)
1185 ct_data *tree = desc->dyn_tree;
1186 const uint8_t *extra = desc->extra_bits;
1187 int base = desc->extra_base;
1188 int max_code = desc->max_code;
1189 int max_length = desc->max_length;
1190 ct_data *stree = desc->static_tree;
1191 int h; /* heap index */
1192 int n, m; /* iterate over the tree elements */
1193 int bits; /* bit length */
1194 int xbits; /* extra bits */
1195 ush f; /* frequency */
1196 int overflow = 0; /* number of elements with bit length too large */
1198 for (bits = 0; bits <= MAX_BITS; bits++)
1199 G2.bl_count[bits] = 0;
1201 /* In a first pass, compute the optimal bit lengths (which may
1202 * overflow in the case of the bit length tree).
1204 tree[G2.heap[G2.heap_max]].Len = 0; /* root of the heap */
1206 for (h = G2.heap_max + 1; h < HEAP_SIZE; h++) {
1208 bits = tree[tree[n].Dad].Len + 1;
1209 if (bits > max_length) {
1213 tree[n].Len = (ush) bits;
1214 /* We overwrite tree[n].Dad which is no longer needed */
1217 continue; /* not a leaf node */
1219 G2.bl_count[bits]++;
1222 xbits = extra[n - base];
1224 G2.opt_len += (ulg) f *(bits + xbits);
1227 G2.static_len += (ulg) f * (stree[n].Len + xbits);
1232 Trace((stderr, "\nbit length overflow\n"));
1233 /* This happens for example on obj2 and pic of the Calgary corpus */
1235 /* Find the first bit length which could increase: */
1237 bits = max_length - 1;
1238 while (G2.bl_count[bits] == 0)
1240 G2.bl_count[bits]--; /* move one leaf down the tree */
1241 G2.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
1242 G2.bl_count[max_length]--;
1243 /* The brother of the overflow item also moves one step up,
1244 * but this does not affect bl_count[max_length]
1247 } while (overflow > 0);
1249 /* Now recompute all bit lengths, scanning in increasing frequency.
1250 * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
1251 * lengths instead of fixing only the wrong ones. This idea is taken
1252 * from 'ar' written by Haruhiko Okumura.)
1254 for (bits = max_length; bits != 0; bits--) {
1255 n = G2.bl_count[bits];
1260 if (tree[m].Len != (unsigned) bits) {
1261 Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits));
1262 G2.opt_len += ((int32_t) bits - tree[m].Len) * tree[m].Freq;
1271 /* ===========================================================================
1272 * Generate the codes for a given tree and bit counts (which need not be
1274 * IN assertion: the array bl_count contains the bit length statistics for
1275 * the given tree and the field len is set for all tree elements.
1276 * OUT assertion: the field code is set for all tree elements of non
1279 static void gen_codes(ct_data * tree, int max_code)
1281 ush next_code[MAX_BITS + 1]; /* next code value for each bit length */
1282 ush code = 0; /* running code value */
1283 int bits; /* bit index */
1284 int n; /* code index */
1286 /* The distribution counts are first used to generate the code values
1287 * without bit reversal.
1289 for (bits = 1; bits <= MAX_BITS; bits++) {
1290 next_code[bits] = code = (code + G2.bl_count[bits - 1]) << 1;
1292 /* Check that the bit counts in bl_count are consistent. The last code
1295 Assert(code + G2.bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
1296 "inconsistent bit counts");
1297 Tracev((stderr, "\ngen_codes: max_code %d ", max_code));
1299 for (n = 0; n <= max_code; n++) {
1300 int len = tree[n].Len;
1304 /* Now reverse the bits */
1305 tree[n].Code = bi_reverse(next_code[len]++, len);
1307 Tracec(tree != G2.static_ltree,
1308 (stderr, "\nn %3d %c l %2d c %4x (%x) ", n,
1309 (n > ' ' ? n : ' '), len, tree[n].Code,
1310 next_code[len] - 1));
1315 /* ===========================================================================
1316 * Construct one Huffman tree and assigns the code bit strings and lengths.
1317 * Update the total bit length for the current block.
1318 * IN assertion: the field freq is set for all tree elements.
1319 * OUT assertions: the fields len and code are set to the optimal bit length
1320 * and corresponding code. The length opt_len is updated; static_len is
1321 * also updated if stree is not null. The field max_code is set.
1324 /* Remove the smallest element from the heap and recreate the heap with
1325 * one less element. Updates heap and heap_len. */
1328 /* Index within the heap array of least frequent node in the Huffman tree */
1330 #define PQREMOVE(tree, top) \
1332 top = G2.heap[SMALLEST]; \
1333 G2.heap[SMALLEST] = G2.heap[G2.heap_len--]; \
1334 pqdownheap(tree, SMALLEST); \
1337 static void build_tree(tree_desc * desc)
1339 ct_data *tree = desc->dyn_tree;
1340 ct_data *stree = desc->static_tree;
1341 int elems = desc->elems;
1342 int n, m; /* iterate over heap elements */
1343 int max_code = -1; /* largest code with non zero frequency */
1344 int node = elems; /* next internal node of the tree */
1346 /* Construct the initial heap, with least frequent element in
1347 * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
1348 * heap[0] is not used.
1351 G2.heap_max = HEAP_SIZE;
1353 for (n = 0; n < elems; n++) {
1354 if (tree[n].Freq != 0) {
1355 G2.heap[++G2.heap_len] = max_code = n;
1362 /* The pkzip format requires that at least one distance code exists,
1363 * and that at least one bit should be sent even if there is only one
1364 * possible code. So to avoid special checks later on we force at least
1365 * two codes of non zero frequency.
1367 while (G2.heap_len < 2) {
1368 int new = G2.heap[++G2.heap_len] = (max_code < 2 ? ++max_code : 0);
1374 G2.static_len -= stree[new].Len;
1375 /* new is 0 or 1 so it does not have extra bits */
1377 desc->max_code = max_code;
1379 /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
1380 * establish sub-heaps of increasing lengths:
1382 for (n = G2.heap_len / 2; n >= 1; n--)
1383 pqdownheap(tree, n);
1385 /* Construct the Huffman tree by repeatedly combining the least two
1389 PQREMOVE(tree, n); /* n = node of least frequency */
1390 m = G2.heap[SMALLEST]; /* m = node of next least frequency */
1392 G2.heap[--G2.heap_max] = n; /* keep the nodes sorted by frequency */
1393 G2.heap[--G2.heap_max] = m;
1395 /* Create a new node father of n and m */
1396 tree[node].Freq = tree[n].Freq + tree[m].Freq;
1397 G2.depth[node] = MAX(G2.depth[n], G2.depth[m]) + 1;
1398 tree[n].Dad = tree[m].Dad = (ush) node;
1400 if (tree == G2.bl_tree) {
1401 bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)",
1402 node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
1405 /* and insert the new node in the heap */
1406 G2.heap[SMALLEST] = node++;
1407 pqdownheap(tree, SMALLEST);
1408 } while (G2.heap_len >= 2);
1410 G2.heap[--G2.heap_max] = G2.heap[SMALLEST];
1412 /* At this point, the fields freq and dad are set. We can now
1413 * generate the bit lengths.
1415 gen_bitlen((tree_desc *) desc);
1417 /* The field len is now set, we can generate the bit codes */
1418 gen_codes((ct_data *) tree, max_code);
1422 /* ===========================================================================
1423 * Scan a literal or distance tree to determine the frequencies of the codes
1424 * in the bit length tree. Updates opt_len to take into account the repeat
1425 * counts. (The contribution of the bit length codes will be added later
1426 * during the construction of bl_tree.)
1428 static void scan_tree(ct_data * tree, int max_code)
1430 int n; /* iterates over all tree elements */
1431 int prevlen = -1; /* last emitted length */
1432 int curlen; /* length of current code */
1433 int nextlen = tree[0].Len; /* length of next code */
1434 int count = 0; /* repeat count of the current code */
1435 int max_count = 7; /* max repeat count */
1436 int min_count = 4; /* min repeat count */
1442 tree[max_code + 1].Len = 0xffff; /* guard */
1444 for (n = 0; n <= max_code; n++) {
1446 nextlen = tree[n + 1].Len;
1447 if (++count < max_count && curlen == nextlen)
1450 if (count < min_count) {
1451 G2.bl_tree[curlen].Freq += count;
1452 } else if (curlen != 0) {
1453 if (curlen != prevlen)
1454 G2.bl_tree[curlen].Freq++;
1455 G2.bl_tree[REP_3_6].Freq++;
1456 } else if (count <= 10) {
1457 G2.bl_tree[REPZ_3_10].Freq++;
1459 G2.bl_tree[REPZ_11_138].Freq++;
1469 } else if (curlen == nextlen) {
1477 /* ===========================================================================
1478 * Send a literal or distance tree in compressed form, using the codes in
1481 static void send_tree(ct_data * tree, int max_code)
1483 int n; /* iterates over all tree elements */
1484 int prevlen = -1; /* last emitted length */
1485 int curlen; /* length of current code */
1486 int nextlen = tree[0].Len; /* length of next code */
1487 int count = 0; /* repeat count of the current code */
1488 int max_count = 7; /* max repeat count */
1489 int min_count = 4; /* min repeat count */
1491 /* tree[max_code+1].Len = -1; *//* guard already set */
1493 max_count = 138, min_count = 3;
1495 for (n = 0; n <= max_code; n++) {
1497 nextlen = tree[n + 1].Len;
1498 if (++count < max_count && curlen == nextlen) {
1500 } else if (count < min_count) {
1502 SEND_CODE(curlen, G2.bl_tree);
1504 } else if (curlen != 0) {
1505 if (curlen != prevlen) {
1506 SEND_CODE(curlen, G2.bl_tree);
1509 Assert(count >= 3 && count <= 6, " 3_6?");
1510 SEND_CODE(REP_3_6, G2.bl_tree);
1511 send_bits(count - 3, 2);
1512 } else if (count <= 10) {
1513 SEND_CODE(REPZ_3_10, G2.bl_tree);
1514 send_bits(count - 3, 3);
1516 SEND_CODE(REPZ_11_138, G2.bl_tree);
1517 send_bits(count - 11, 7);
1524 } else if (curlen == nextlen) {
1535 /* ===========================================================================
1536 * Construct the Huffman tree for the bit lengths and return the index in
1537 * bl_order of the last bit length code to send.
1539 static int build_bl_tree(void)
1541 int max_blindex; /* index of last bit length code of non zero freq */
1543 /* Determine the bit length frequencies for literal and distance trees */
1544 scan_tree(G2.dyn_ltree, G2.l_desc.max_code);
1545 scan_tree(G2.dyn_dtree, G2.d_desc.max_code);
1547 /* Build the bit length tree: */
1548 build_tree(&G2.bl_desc);
1549 /* opt_len now includes the length of the tree representations, except
1550 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
1553 /* Determine the number of bit length codes to send. The pkzip format
1554 * requires that at least 4 bit length codes be sent. (appnote.txt says
1555 * 3 but the actual value used is 4.)
1557 for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
1558 if (G2.bl_tree[bl_order[max_blindex]].Len != 0)
1561 /* Update opt_len to include the bit length tree and counts */
1562 G2.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
1563 Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", (long)G2.opt_len, (long)G2.static_len));
1569 /* ===========================================================================
1570 * Send the header for a block using dynamic Huffman trees: the counts, the
1571 * lengths of the bit length codes, the literal tree and the distance tree.
1572 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
1574 static void send_all_trees(int lcodes, int dcodes, int blcodes)
1576 int rank; /* index in bl_order */
1578 Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
1579 Assert(lcodes <= L_CODES && dcodes <= D_CODES
1580 && blcodes <= BL_CODES, "too many codes");
1581 Tracev((stderr, "\nbl counts: "));
1582 send_bits(lcodes - 257, 5); /* not +255 as stated in appnote.txt */
1583 send_bits(dcodes - 1, 5);
1584 send_bits(blcodes - 4, 4); /* not -3 as stated in appnote.txt */
1585 for (rank = 0; rank < blcodes; rank++) {
1586 Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
1587 send_bits(G2.bl_tree[bl_order[rank]].Len, 3);
1589 Tracev((stderr, "\nbl tree: sent %ld", (long)G1.bits_sent));
1591 send_tree((ct_data *) G2.dyn_ltree, lcodes - 1); /* send the literal tree */
1592 Tracev((stderr, "\nlit tree: sent %ld", (long)G1.bits_sent));
1594 send_tree((ct_data *) G2.dyn_dtree, dcodes - 1); /* send the distance tree */
1595 Tracev((stderr, "\ndist tree: sent %ld", (long)G1.bits_sent));
1599 /* ===========================================================================
1600 * Save the match info and tally the frequency counts. Return true if
1601 * the current block must be flushed.
1603 static int ct_tally(int dist, int lc)
1605 G1.l_buf[G2.last_lit++] = lc;
1607 /* lc is the unmatched char */
1608 G2.dyn_ltree[lc].Freq++;
1610 /* Here, lc is the match length - MIN_MATCH */
1611 dist--; /* dist = match distance - 1 */
1612 Assert((ush) dist < (ush) MAX_DIST
1613 && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH)
1614 && (ush) D_CODE(dist) < (ush) D_CODES, "ct_tally: bad match"
1617 G2.dyn_ltree[G2.length_code[lc] + LITERALS + 1].Freq++;
1618 G2.dyn_dtree[D_CODE(dist)].Freq++;
1620 G1.d_buf[G2.last_dist++] = dist;
1621 G2.flags |= G2.flag_bit;
1625 /* Output the flags if they fill a byte: */
1626 if ((G2.last_lit & 7) == 0) {
1627 G2.flag_buf[G2.last_flags++] = G2.flags;
1631 /* Try to guess if it is profitable to stop the current block here */
1632 if ((G2.last_lit & 0xfff) == 0) {
1633 /* Compute an upper bound for the compressed length */
1634 ulg out_length = G2.last_lit * 8L;
1635 ulg in_length = (ulg) G1.strstart - G1.block_start;
1638 for (dcode = 0; dcode < D_CODES; dcode++) {
1639 out_length += G2.dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]);
1643 "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
1644 G2.last_lit, G2.last_dist,
1645 (long)in_length, (long)out_length,
1646 100L - out_length * 100L / in_length));
1647 if (G2.last_dist < G2.last_lit / 2 && out_length < in_length / 2)
1650 return (G2.last_lit == LIT_BUFSIZE - 1 || G2.last_dist == DIST_BUFSIZE);
1651 /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
1652 * on 16 bit machines and because stored blocks are restricted to
1657 /* ===========================================================================
1658 * Send the block data compressed using the given Huffman trees
1660 static void compress_block(ct_data * ltree, ct_data * dtree)
1662 unsigned dist; /* distance of matched string */
1663 int lc; /* match length or unmatched char (if dist == 0) */
1664 unsigned lx = 0; /* running index in l_buf */
1665 unsigned dx = 0; /* running index in d_buf */
1666 unsigned fx = 0; /* running index in flag_buf */
1667 uch flag = 0; /* current flags */
1668 unsigned code; /* the code to send */
1669 int extra; /* number of extra bits to send */
1671 if (G2.last_lit != 0) do {
1673 flag = G2.flag_buf[fx++];
1674 lc = G1.l_buf[lx++];
1675 if ((flag & 1) == 0) {
1676 SEND_CODE(lc, ltree); /* send a literal byte */
1677 Tracecv(lc > ' ', (stderr, " '%c' ", lc));
1679 /* Here, lc is the match length - MIN_MATCH */
1680 code = G2.length_code[lc];
1681 SEND_CODE(code + LITERALS + 1, ltree); /* send the length code */
1682 extra = extra_lbits[code];
1684 lc -= G2.base_length[code];
1685 send_bits(lc, extra); /* send the extra length bits */
1687 dist = G1.d_buf[dx++];
1688 /* Here, dist is the match distance - 1 */
1689 code = D_CODE(dist);
1690 Assert(code < D_CODES, "bad d_code");
1692 SEND_CODE(code, dtree); /* send the distance code */
1693 extra = extra_dbits[code];
1695 dist -= G2.base_dist[code];
1696 send_bits(dist, extra); /* send the extra distance bits */
1698 } /* literal or match pair ? */
1700 } while (lx < G2.last_lit);
1702 SEND_CODE(END_BLOCK, ltree);
1706 /* ===========================================================================
1707 * Determine the best encoding for the current block: dynamic trees, static
1708 * trees or store, and output the encoded block to the zip file. This function
1709 * returns the total compressed length for the file so far.
1711 static ulg flush_block(char *buf, ulg stored_len, int eof)
1713 ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
1714 int max_blindex; /* index of last bit length code of non zero freq */
1716 G2.flag_buf[G2.last_flags] = G2.flags; /* Save the flags for the last 8 items */
1718 /* Construct the literal and distance trees */
1719 build_tree(&G2.l_desc);
1720 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", (long)G2.opt_len, (long)G2.static_len));
1722 build_tree(&G2.d_desc);
1723 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", (long)G2.opt_len, (long)G2.static_len));
1724 /* At this point, opt_len and static_len are the total bit lengths of
1725 * the compressed block data, excluding the tree representations.
1728 /* Build the bit length tree for the above two trees, and get the index
1729 * in bl_order of the last bit length code to send.
1731 max_blindex = build_bl_tree();
1733 /* Determine the best encoding. Compute first the block length in bytes */
1734 opt_lenb = (G2.opt_len + 3 + 7) >> 3;
1735 static_lenb = (G2.static_len + 3 + 7) >> 3;
1738 "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
1739 (unsigned long)opt_lenb, (unsigned long)G2.opt_len,
1740 (unsigned long)static_lenb, (unsigned long)G2.static_len,
1741 (unsigned long)stored_len,
1742 G2.last_lit, G2.last_dist));
1744 if (static_lenb <= opt_lenb)
1745 opt_lenb = static_lenb;
1747 /* If compression failed and this is the first and last block,
1748 * and if the zip file can be seeked (to rewrite the local header),
1749 * the whole file is transformed into a stored file:
1751 if (stored_len <= opt_lenb && eof && G2.compressed_len == 0L && seekable()) {
1752 /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
1754 bb_error_msg("block vanished");
1756 G2.compressed_len = stored_len << 3;
1757 copy_block(buf, (unsigned) stored_len, 0); /* without header */
1758 } else if (stored_len + 4 <= opt_lenb && buf != NULL) {
1759 /* 4: two words for the lengths */
1760 /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
1761 * Otherwise we can't have processed more than WSIZE input bytes since
1762 * the last block flush, because compression would have been
1763 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
1764 * transform a block into a stored block.
1766 send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */
1767 G2.compressed_len = ((G2.compressed_len + 3 + 7) & ~7L)
1768 + ((stored_len + 4) << 3);
1769 copy_block(buf, (unsigned) stored_len, 1); /* with header */
1770 } else if (static_lenb == opt_lenb) {
1771 send_bits((STATIC_TREES << 1) + eof, 3);
1772 compress_block((ct_data *) G2.static_ltree, (ct_data *) G2.static_dtree);
1773 G2.compressed_len += 3 + G2.static_len;
1775 send_bits((DYN_TREES << 1) + eof, 3);
1776 send_all_trees(G2.l_desc.max_code + 1, G2.d_desc.max_code + 1,
1778 compress_block((ct_data *) G2.dyn_ltree, (ct_data *) G2.dyn_dtree);
1779 G2.compressed_len += 3 + G2.opt_len;
1781 Assert(G2.compressed_len == G1.bits_sent, "bad compressed size");
1786 G2.compressed_len += 7; /* align on byte boundary */
1788 Tracev((stderr, "\ncomprlen %lu(%lu) ",
1789 (unsigned long)G2.compressed_len >> 3,
1790 (unsigned long)G2.compressed_len - 7 * eof));
1792 return G2.compressed_len >> 3;
1796 /* ===========================================================================
1797 * Update a hash value with the given input byte
1798 * IN assertion: all calls to UPDATE_HASH are made with consecutive
1799 * input characters, so that a running hash key can be computed from the
1800 * previous key instead of complete recalculation each time.
1802 #define UPDATE_HASH(h, c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
1805 /* ===========================================================================
1806 * Same as above, but achieves better compression. We use a lazy
1807 * evaluation for matches: a match is finally adopted only if there is
1808 * no better match at the next window position.
1810 * Processes a new input file and return its compressed length. Sets
1811 * the compressed length, crc, deflate flags and internal file
1815 /* Flush the current block, with given end-of-file flag.
1816 * IN assertion: strstart is set to the end of the current match. */
1817 #define FLUSH_BLOCK(eof) \
1819 G1.block_start >= 0L \
1820 ? (char*)&G1.window[(unsigned)G1.block_start] \
1822 (ulg)G1.strstart - G1.block_start, \
1826 /* Insert string s in the dictionary and set match_head to the previous head
1827 * of the hash chain (the most recent string with same hash key). Return
1828 * the previous length of the hash chain.
1829 * IN assertion: all calls to INSERT_STRING are made with consecutive
1830 * input characters and the first MIN_MATCH bytes of s are valid
1831 * (except for the last MIN_MATCH-1 bytes of the input file). */
1832 #define INSERT_STRING(s, match_head) \
1834 UPDATE_HASH(G1.ins_h, G1.window[(s) + MIN_MATCH-1]); \
1835 G1.prev[(s) & WMASK] = match_head = head[G1.ins_h]; \
1836 head[G1.ins_h] = (s); \
1839 static NOINLINE ulg deflate(void)
1841 IPos hash_head; /* head of hash chain */
1842 IPos prev_match; /* previous match */
1843 int flush; /* set if current block must be flushed */
1844 int match_available = 0; /* set if previous match exists */
1845 unsigned match_length = MIN_MATCH - 1; /* length of best match */
1847 /* Process the input block. */
1848 while (G1.lookahead != 0) {
1849 /* Insert the string window[strstart .. strstart+2] in the
1850 * dictionary, and set hash_head to the head of the hash chain:
1852 INSERT_STRING(G1.strstart, hash_head);
1854 /* Find the longest match, discarding those <= prev_length.
1856 G1.prev_length = match_length;
1857 prev_match = G1.match_start;
1858 match_length = MIN_MATCH - 1;
1860 if (hash_head != 0 && G1.prev_length < max_lazy_match
1861 && G1.strstart - hash_head <= MAX_DIST
1863 /* To simplify the code, we prevent matches with the string
1864 * of window index 0 (in particular we have to avoid a match
1865 * of the string with itself at the start of the input file).
1867 match_length = longest_match(hash_head);
1868 /* longest_match() sets match_start */
1869 if (match_length > G1.lookahead)
1870 match_length = G1.lookahead;
1872 /* Ignore a length 3 match if it is too distant: */
1873 if (match_length == MIN_MATCH && G1.strstart - G1.match_start > TOO_FAR) {
1874 /* If prev_match is also MIN_MATCH, G1.match_start is garbage
1875 * but we will ignore the current match anyway.
1880 /* If there was a match at the previous step and the current
1881 * match is not better, output the previous match:
1883 if (G1.prev_length >= MIN_MATCH && match_length <= G1.prev_length) {
1884 check_match(G1.strstart - 1, prev_match, G1.prev_length);
1885 flush = ct_tally(G1.strstart - 1 - prev_match, G1.prev_length - MIN_MATCH);
1887 /* Insert in hash table all strings up to the end of the match.
1888 * strstart-1 and strstart are already inserted.
1890 G1.lookahead -= G1.prev_length - 1;
1891 G1.prev_length -= 2;
1894 INSERT_STRING(G1.strstart, hash_head);
1895 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
1896 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
1897 * these bytes are garbage, but it does not matter since the
1898 * next lookahead bytes will always be emitted as literals.
1900 } while (--G1.prev_length != 0);
1901 match_available = 0;
1902 match_length = MIN_MATCH - 1;
1906 G1.block_start = G1.strstart;
1908 } else if (match_available) {
1909 /* If there was no match at the previous position, output a
1910 * single literal. If there was a match but the current match
1911 * is longer, truncate the previous match to a single literal.
1913 Tracevv((stderr, "%c", G1.window[G1.strstart - 1]));
1914 if (ct_tally(0, G1.window[G1.strstart - 1])) {
1916 G1.block_start = G1.strstart;
1921 /* There is no previous match to compare with, wait for
1922 * the next step to decide.
1924 match_available = 1;
1928 Assert(G1.strstart <= G1.isize && G1.lookahead <= G1.isize, "a bit too far");
1930 /* Make sure that we always have enough lookahead, except
1931 * at the end of the input file. We need MAX_MATCH bytes
1932 * for the next match, plus MIN_MATCH bytes to insert the
1933 * string following the next match.
1935 fill_window_if_needed();
1937 if (match_available)
1938 ct_tally(0, G1.window[G1.strstart - 1]);
1940 return FLUSH_BLOCK(1); /* eof */
1944 /* ===========================================================================
1945 * Initialize the bit string routines.
1947 static void bi_init(void)
1949 //G1.bi_buf = 0; // globals are zeroed in pack_gzip()
1950 //G1.bi_valid = 0; // globals are zeroed in pack_gzip()
1951 //DEBUG_bits_sent(= 0L); // globals are zeroed in pack_gzip()
1955 /* ===========================================================================
1956 * Initialize the "longest match" routines for a new file
1958 static void lm_init(unsigned *flags16p)
1962 /* Initialize the hash table. */
1963 memset(head, 0, HASH_SIZE * sizeof(*head));
1964 /* prev will be initialized on the fly */
1966 /* speed options for the general purpose bit flag */
1967 *flags16p |= 2; /* FAST 4, SLOW 2 */
1968 /* ??? reduce max_chain_length for binary files */
1970 //G1.strstart = 0; // globals are zeroed in pack_gzip()
1971 //G1.block_start = 0L; // globals are zeroed in pack_gzip()
1973 G1.lookahead = file_read(G1.window,
1974 sizeof(int) <= 2 ? (unsigned) WSIZE : 2 * WSIZE);
1976 if (G1.lookahead == 0 || G1.lookahead == (unsigned) -1) {
1981 //G1.eofile = 0; // globals are zeroed in pack_gzip()
1983 /* Make sure that we always have enough lookahead. This is important
1984 * if input comes from a device such as a tty.
1986 fill_window_if_needed();
1988 //G1.ins_h = 0; // globals are zeroed in pack_gzip()
1989 for (j = 0; j < MIN_MATCH - 1; j++)
1990 UPDATE_HASH(G1.ins_h, G1.window[j]);
1991 /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
1992 * not important since only literal bytes will be emitted.
1997 /* ===========================================================================
1998 * Allocate the match buffer, initialize the various tables and save the
1999 * location of the internal file attribute (ascii/binary) and method
2001 * One callsite in zip()
2003 static void ct_init(void)
2005 int n; /* iterates over tree elements */
2006 int length; /* length value */
2007 int code; /* code value */
2008 int dist; /* distance index */
2010 //G2.compressed_len = 0L; // globals are zeroed in pack_gzip()
2013 if (G2.static_dtree[0].Len != 0)
2014 return; /* ct_init already called */
2017 /* Initialize the mapping length (0..255) -> length code (0..28) */
2019 for (code = 0; code < LENGTH_CODES - 1; code++) {
2020 G2.base_length[code] = length;
2021 for (n = 0; n < (1 << extra_lbits[code]); n++) {
2022 G2.length_code[length++] = code;
2025 Assert(length == 256, "ct_init: length != 256");
2026 /* Note that the length 255 (match length 258) can be represented
2027 * in two different ways: code 284 + 5 bits or code 285, so we
2028 * overwrite length_code[255] to use the best encoding:
2030 G2.length_code[length - 1] = code;
2032 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
2034 for (code = 0; code < 16; code++) {
2035 G2.base_dist[code] = dist;
2036 for (n = 0; n < (1 << extra_dbits[code]); n++) {
2037 G2.dist_code[dist++] = code;
2040 Assert(dist == 256, "ct_init: dist != 256");
2041 dist >>= 7; /* from now on, all distances are divided by 128 */
2042 for (; code < D_CODES; code++) {
2043 G2.base_dist[code] = dist << 7;
2044 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
2045 G2.dist_code[256 + dist++] = code;
2048 Assert(dist == 256, "ct_init: 256+dist != 512");
2050 /* Construct the codes of the static literal tree */
2051 //for (n = 0; n <= MAX_BITS; n++) // globals are zeroed in pack_gzip()
2052 // G2.bl_count[n] = 0;
2056 G2.static_ltree[n++].Len = 8;
2059 //G2.bl_count[8] = 143 + 1;
2061 G2.static_ltree[n++].Len = 9;
2064 //G2.bl_count[9] = 255 - 143;
2066 G2.static_ltree[n++].Len = 7;
2069 //G2.bl_count[7] = 279 - 255;
2071 G2.static_ltree[n++].Len = 8;
2074 //G2.bl_count[8] += 287 - 279;
2075 G2.bl_count[7] = 279 - 255;
2076 G2.bl_count[8] = (143 + 1) + (287 - 279);
2077 G2.bl_count[9] = 255 - 143;
2078 /* Codes 286 and 287 do not exist, but we must include them in the
2079 * tree construction to get a canonical Huffman tree (longest code
2082 gen_codes((ct_data *) G2.static_ltree, L_CODES + 1);
2084 /* The static distance tree is trivial: */
2085 for (n = 0; n < D_CODES; n++) {
2086 G2.static_dtree[n].Len = 5;
2087 G2.static_dtree[n].Code = bi_reverse(n, 5);
2090 /* Initialize the first block of the first file: */
2095 /* ===========================================================================
2096 * Deflate in to out.
2097 * IN assertions: the input and output buffers are cleared.
2099 static void zip(void)
2101 unsigned deflate_flags;
2103 //G1.outcnt = 0; // globals are zeroed in pack_gzip()
2105 /* Write the header to the gzip file. See algorithm.doc for the format */
2106 /* magic header for gzip files: 1F 8B */
2107 /* compression method: 8 (DEFLATED) */
2108 /* general flags: 0 */
2109 put_32bit(0x00088b1f);
2110 put_32bit(0); /* Unix timestamp */
2112 /* Write deflated file to zip file */
2117 deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */
2118 lm_init(&deflate_flags);
2120 put_16bit(deflate_flags | 0x300); /* extra flags. OS id = 3 (Unix) */
2122 /* The above 32-bit misaligns outbuf (10 bytes are stored), flush it */
2123 flush_outbuf_if_32bit_optimized();
2127 /* Write the crc and uncompressed size */
2129 put_32bit(G1.isize);
2135 /* ======================================================================== */
2137 IF_DESKTOP(long long) int FAST_FUNC pack_gzip(transformer_state_t *xstate UNUSED_PARAM)
2139 /* Reinit G1.xxx except pointers to allocated buffers, and entire G2 */
2140 memset(&G1.crc, 0, (sizeof(G1) - offsetof(struct globals, crc)) + sizeof(G2));
2142 /* Clear input and output buffers */
2150 G2.l_desc.dyn_tree = G2.dyn_ltree;
2151 G2.l_desc.static_tree = G2.static_ltree;
2152 G2.l_desc.extra_bits = extra_lbits;
2153 G2.l_desc.extra_base = LITERALS + 1;
2154 G2.l_desc.elems = L_CODES;
2155 G2.l_desc.max_length = MAX_BITS;
2156 //G2.l_desc.max_code = 0;
2157 G2.d_desc.dyn_tree = G2.dyn_dtree;
2158 G2.d_desc.static_tree = G2.static_dtree;
2159 G2.d_desc.extra_bits = extra_dbits;
2160 //G2.d_desc.extra_base = 0;
2161 G2.d_desc.elems = D_CODES;
2162 G2.d_desc.max_length = MAX_BITS;
2163 //G2.d_desc.max_code = 0;
2164 G2.bl_desc.dyn_tree = G2.bl_tree;
2165 //G2.bl_desc.static_tree = NULL;
2166 G2.bl_desc.extra_bits = extra_blbits,
2167 //G2.bl_desc.extra_base = 0;
2168 G2.bl_desc.elems = BL_CODES;
2169 G2.bl_desc.max_length = MAX_BL_BITS;
2170 //G2.bl_desc.max_code = 0;
2173 /* Saving of timestamp is disabled. Why?
2174 * - it is not Y2038-safe.
2175 * - some people want deterministic results
2176 * (normally they'd use -n, but our -n is a nop).
2178 * Per RFC 1952, gzfile.time=0 is "no timestamp".
2179 * If users will demand this to be reinstated,
2180 * implement -n "don't save timestamp".
2184 fstat(STDIN_FILENO, &s);
2192 #if ENABLE_FEATURE_GZIP_LONG_OPTIONS
2193 static const char gzip_longopts[] ALIGN1 =
2194 "stdout\0" No_argument "c"
2195 "to-stdout\0" No_argument "c"
2196 "force\0" No_argument "f"
2197 "verbose\0" No_argument "v"
2198 #if ENABLE_FEATURE_GZIP_DECOMPRESS
2199 "decompress\0" No_argument "d"
2200 "uncompress\0" No_argument "d"
2201 "test\0" No_argument "t"
2203 "quiet\0" No_argument "q"
2204 "fast\0" No_argument "1"
2205 "best\0" No_argument "9"
2206 "no-name\0" No_argument "n"
2211 * Linux kernel build uses gzip -d -n. We accept and ignore -n.
2214 * gzip: do not save the original file name and time stamp.
2215 * (The original name is always saved if the name had to be truncated.)
2216 * gunzip: do not restore the original file name/time even if present
2217 * (remove only the gzip suffix from the compressed file name).
2218 * This option is the default when decompressing.
2220 * gzip: always save the original file name and time stamp (this is the default)
2221 * gunzip: restore the original file name and time stamp if present.
2224 int gzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
2225 #if ENABLE_FEATURE_GZIP_DECOMPRESS
2226 int gzip_main(int argc, char **argv)
2228 int gzip_main(int argc UNUSED_PARAM, char **argv)
2232 #if ENABLE_FEATURE_GZIP_LEVELS
2233 static const struct {
2235 uint8_t chain_shift;
2238 } gzip_level_config[6] = {
2239 {4, 4, 4/2, 16/2}, /* Level 4 */
2240 {8, 5, 16/2, 32/2}, /* Level 5 */
2241 {8, 7, 16/2, 128/2}, /* Level 6 */
2242 {8, 8, 32/2, 128/2}, /* Level 7 */
2243 {32, 10, 128/2, 258/2}, /* Level 8 */
2244 {32, 12, 258/2, 258/2}, /* Level 9 */
2248 SET_PTR_TO_GLOBALS((char *)xzalloc(sizeof(struct globals)+sizeof(struct globals2))
2249 + sizeof(struct globals));
2251 /* Must match bbunzip's constants OPT_STDOUT, OPT_FORCE! */
2252 #if ENABLE_FEATURE_GZIP_LONG_OPTIONS
2253 opt = getopt32long(argv, "cfkv" IF_FEATURE_GZIP_DECOMPRESS("dt") "qn123456789", gzip_longopts);
2255 opt = getopt32(argv, "cfkv" IF_FEATURE_GZIP_DECOMPRESS("dt") "qn123456789");
2257 #if ENABLE_FEATURE_GZIP_DECOMPRESS /* gunzip_main may not be visible... */
2258 if (opt & 0x30) // -d and/or -t
2259 return gunzip_main(argc, argv);
2261 #if ENABLE_FEATURE_GZIP_LEVELS
2262 opt >>= ENABLE_FEATURE_GZIP_DECOMPRESS ? 8 : 6; /* drop cfkv[dt]qn bits */
2264 opt = 1 << 6; /* default: 6 */
2265 opt = ffs(opt >> 4); /* Maps -1..-4 to [0], -5 to [1] ... -9 to [5] */
2266 max_chain_length = 1 << gzip_level_config[opt].chain_shift;
2267 good_match = gzip_level_config[opt].good;
2268 max_lazy_match = gzip_level_config[opt].lazy2 * 2;
2269 nice_match = gzip_level_config[opt].nice2 * 2;
2271 option_mask32 &= 0xf; /* retain only -cfkv */
2273 /* Allocate all global buffers (for DYN_ALLOC option) */
2274 ALLOC(uch, G1.l_buf, INBUFSIZ);
2275 ALLOC(uch, G1.outbuf, OUTBUFSIZ);
2276 ALLOC(ush, G1.d_buf, DIST_BUFSIZE);
2277 ALLOC(uch, G1.window, 2L * WSIZE);
2278 ALLOC(ush, G1.prev, 1L << BITS);
2280 /* Initialize the CRC32 table */
2281 global_crc32_table = crc32_filltable(NULL, 0);
2284 return bbunpack(argv, pack_gzip, append_ext, "gz");