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 tarball for details.
19 /* TODO: full support for -v for DESKTOP
20 /usr/bin/gzip -v a bogus aa
21 a: 85.1% -- replaced with a.gz
22 gzip: bogus: No such file or directory
23 aa: 85.1% -- replaced with aa.gz
31 /* ===========================================================================
34 /* Diagnostic functions */
36 # define Assert(cond,msg) {if(!(cond)) bb_error_msg(msg);}
37 # define Trace(x) fprintf x
38 # define Tracev(x) {if (verbose) fprintf x ;}
39 # define Tracevv(x) {if (verbose > 1) fprintf x ;}
40 # define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
41 # define Tracecv(c,x) {if (verbose > 1 && (c)) fprintf x ;}
43 # define Assert(cond,msg)
52 /* ===========================================================================
56 /* Compression methods (see algorithm.doc) */
57 /* Only STORED and DEFLATED are supported by this BusyBox module */
59 /* methods 4 to 7 reserved */
64 # define INBUFSIZ 0x2000 /* input buffer size */
66 # define INBUFSIZ 0x8000 /* input buffer size */
71 #define INBUF_EXTRA 64 /* required by unlzw() */
75 # define OUTBUFSIZ 8192 /* output buffer size */
77 # define OUTBUFSIZ 16384 /* output buffer size */
81 #define OUTBUF_EXTRA 2048 /* required by unlzw() */
85 # define DIST_BUFSIZE 0x2000 /* buffer for distances, see trees.c */
87 # define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */
92 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
93 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
94 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
95 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
96 #define COMMENT 0x10 /* bit 4 set: file comment present */
97 #define RESERVED 0xC0 /* bit 6,7: reserved */
99 /* internal file attribute */
100 #define UNKNOWN 0xffff
105 # define WSIZE 0x8000 /* window size--must be a power of two, and */
106 #endif /* at least 32K for zip's deflate method */
109 #define MAX_MATCH 258
110 /* The minimum and maximum match lengths */
112 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
113 /* Minimum amount of lookahead, except at the end of the input file.
114 * See deflate.c for comments about the MIN_MATCH+1.
117 #define MAX_DIST (WSIZE-MIN_LOOKAHEAD)
118 /* In order to simplify the code, particularly on 16 bit machines, match
119 * distances are limited to MAX_DIST instead of WSIZE.
123 # define MAX_PATH_LEN 1024 /* max pathname length */
126 #define seekable() 0 /* force sequential output */
127 #define translate_eol 0 /* no option -a yet */
132 #define INIT_BITS 9 /* Initial number of bits per code */
134 #define BIT_MASK 0x1f /* Mask for 'number of compression bits' */
135 /* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free.
136 * It's a pity that old uncompress does not check bit 0x20. That makes
137 * extension of the format actually undesirable because old compress
138 * would just crash on the new format instead of giving a meaningful
139 * error message. It does check the number of bits, but it's more
140 * helpful to say "unsupported format, get a new version" than
141 * "can only handle 16 bits".
145 # define MAX_SUFFIX MAX_EXT_CHARS
147 # define MAX_SUFFIX 30
151 /* ===========================================================================
152 * Compile with MEDIUM_MEM to reduce the memory requirements or
153 * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
154 * entire input file can be held in memory (not possible on 16 bit systems).
155 * Warning: defining these symbols affects HASH_BITS (see below) and thus
156 * affects the compression ratio. The compressed output
157 * is still correct, and might even be smaller in some cases.
161 # define HASH_BITS 13 /* Number of bits used to hash strings */
164 # define HASH_BITS 14
167 # define HASH_BITS 15
168 /* For portability to 16 bit machines, do not use values above 15. */
171 #define HASH_SIZE (unsigned)(1<<HASH_BITS)
172 #define HASH_MASK (HASH_SIZE-1)
173 #define WMASK (WSIZE-1)
174 /* HASH_SIZE and WSIZE must be powers of two */
176 # define TOO_FAR 4096
178 /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
181 /* ===========================================================================
183 typedef unsigned char uch;
184 typedef unsigned short ush;
185 typedef unsigned long ulg;
188 /* ===========================================================================
189 * Local data used by the "longest match" routines.
192 typedef unsigned IPos;
194 /* A Pos is an index in the character window. We use short instead of int to
195 * save space in the various tables. IPos is used only for parameter passing.
198 #define DECLARE(type, array, size)\
200 #define ALLOC(type, array, size) { \
201 array = xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type)); \
204 #define FREE(array) { \
209 static long block_start;
211 /* window position at the beginning of the current output block. Gets
212 * negative when the window is moved backwards.
215 static unsigned ins_h; /* hash index of string to be inserted */
217 #define H_SHIFT ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH)
218 /* Number of bits by which ins_h and del_h must be shifted at each
219 * input step. It must be such that after MIN_MATCH steps, the oldest
220 * byte no longer takes part in the hash key, that is:
221 * H_SHIFT * MIN_MATCH >= HASH_BITS
224 static unsigned int prev_length;
226 /* Length of the best match at previous step. Matches not greater than this
227 * are discarded. This is used in the lazy match evaluation.
230 static unsigned strstart; /* start of string to insert */
231 static unsigned match_start; /* start of matching string */
232 static int eofile; /* flag set at end of input file */
233 static unsigned lookahead; /* number of valid bytes ahead in window */
236 WINDOW_SIZE = 2 * WSIZE,
237 /* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
238 * input file length plus MIN_LOOKAHEAD.
241 max_chain_length = 4096,
242 /* To speed up deflation, hash chains are never searched beyond this length.
243 * A higher limit improves compression ratio but degrades the speed.
246 max_lazy_match = 258,
247 /* Attempt to find a better match only when the current match is strictly
248 * smaller than this value. This mechanism is used only for compression
252 max_insert_length = max_lazy_match,
253 /* Insert new strings in the hash table only if the match length
254 * is not greater than this length. This saves time but degrades compression.
255 * max_insert_length is used only for compression levels <= 3.
259 /* Use a faster search when the previous match is longer than this */
261 /* Values for max_lazy_match, good_match and max_chain_length, depending on
262 * the desired pack level (0..9). The values given below have been tuned to
263 * exclude worst case performance for pathological files. Better values may be
264 * found for specific files.
267 nice_match = 258 /* Stop searching when current match exceeds this */
268 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
269 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
275 /* ===========================================================================
277 static void fill_window(void);
279 static int longest_match(IPos cur_match);
282 static void check_match(IPos start, IPos match, int length);
287 static int ct_tally(int dist, int lc);
288 static ulg flush_block(char *buf, ulg stored_len, int eof);
292 /* To save memory for 16 bit systems, some arrays are overlaid between
293 * the various modules:
294 * deflate: prev+head window d_buf l_buf outbuf
295 * unlzw: tab_prefix tab_suffix stack inbuf outbuf
297 * For compression, input is done in window[]. For decompression, output
298 * is done in window except for unlzw.
300 /* To save space (see unlzw.c), we overlay prev+head with tab_prefix and
301 * window with tab_suffix. Check that we can do this:
303 #if (WSIZE<<1) > (1<<BITS)
304 # error cannot overlay window with tab_suffix and prev with tab_prefix0
306 #if HASH_BITS > BITS-1
307 # error cannot overlay head with tab_prefix1
310 //#define tab_suffix window
311 //#define tab_prefix prev /* hash link (see deflate.c) */
312 #define head (prev+WSIZE) /* hash head (see deflate.c) */
314 /* DECLARE(uch, window, 2L*WSIZE); */
315 /* Sliding window. Input bytes are read into the second half of the window,
316 * and move to the first half later to keep a dictionary of at least WSIZE
317 * bytes. With this organization, matches are limited to a distance of
318 * WSIZE-MAX_MATCH bytes, but this ensures that IO is always
319 * performed with a length multiple of the block size. Also, it limits
320 * the window size to 64K, which is quite useful on MSDOS.
321 * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
322 * be less efficient).
325 /* DECLARE(Pos, prev, WSIZE); */
326 /* Link to older string with same hash index. To limit the size of this
327 * array to 64K, this link is maintained only for the last 32K strings.
328 * An index in this array is thus a window index modulo 32K.
331 /* DECLARE(Pos, head, 1<<HASH_BITS); */
332 /* Heads of the hash chains or 0. */
334 DECLARE(uch, inbuf, INBUFSIZ + INBUF_EXTRA); //remove + XX_EXTRA (unlzw)??
335 DECLARE(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
336 DECLARE(ush, d_buf, DIST_BUFSIZE);
337 DECLARE(uch, window, 2L * WSIZE);
338 DECLARE(ush, prev, 1L << BITS);
340 static long isize; /* number of input bytes */
342 static int foreground; /* set if program run in foreground */
343 static int method = DEFLATED; /* compression method */
344 static int exit_code; /* program exit code */
345 static long time_stamp; /* original time stamp (modification time) */
346 static char z_suffix[MAX_SUFFIX + 1]; /* default suffix (can be set with --suffix) */
348 static int ifd; /* input file descriptor */
349 static int ofd; /* output file descriptor */
351 static unsigned insize; /* valid bytes in inbuf */
353 static unsigned outcnt; /* bytes in output buffer */
355 static uint32_t *crc_32_tab;
358 /* ===========================================================================
359 * Local data used by the "bit string" routines.
362 static int zfile; /* output gzip file */
364 static unsigned short bi_buf;
366 /* Output buffer. bits are inserted starting at the bottom (least significant
371 #define BUF_SIZE (8 * sizeof(bi_buf))
372 /* Number of bits used within bi_buf. (bi_buf might be implemented on
373 * more than 16 bits on some systems.)
378 /* Current input function. Set to mem_read for in-memory compression */
381 static ulg bits_sent; /* bit length of the compressed data */
385 /* ===========================================================================
386 * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
387 * (used for the compressed data only)
389 static void flush_outbuf(void)
394 xwrite(ofd, (char *) outbuf, outcnt);
399 /* ===========================================================================
401 /* put_8bit is used for the compressed output */
402 #define put_8bit(c) \
404 outbuf[outcnt++] = (c); \
405 if (outcnt == OUTBUFSIZ) flush_outbuf(); \
408 /* Output a 16 bit value, lsb first */
409 static void put_16bit(ush w)
411 if (outcnt < OUTBUFSIZ - 2) {
412 outbuf[outcnt++] = w;
413 outbuf[outcnt++] = w >> 8;
420 static void put_32bit(ulg n)
426 /* put_header_byte is used for the compressed output
427 * - for the initial 4 bytes that can't overflow the buffer.
429 #define put_header_byte(c) \
431 outbuf[outcnt++] = (c); \
435 /* ===========================================================================
436 * Clear input and output buffers
438 static void clear_bufs(void)
448 /* ===========================================================================
449 * Run a set of bytes through the crc shift register. If s is a NULL
450 * pointer, then initialize the crc shift register contents instead.
451 * Return the current crc in either case.
453 static uint32_t crc; /* shift register contents */
454 static uint32_t updcrc(uch * s, unsigned n)
458 c = crc_32_tab[(uch)(c ^ *s++)] ^ (c >> 8);
466 /* ===========================================================================
467 * Read a new buffer from the current input file, perform end-of-line
468 * translation, and update the crc and input file size.
469 * IN assertion: size >= 2 (for end-of-line translation)
471 static unsigned file_read(void *buf, unsigned size)
475 Assert(insize == 0, "inbuf not empty");
477 len = safe_read(ifd, buf, size);
478 if (len == (unsigned)(-1) || len == 0)
487 /* ===========================================================================
488 * Initialize the bit string routines.
490 static void bi_init(int zipfile)
501 /* ===========================================================================
502 * Send a value on a given number of bits.
503 * IN assertion: length <= 16 and value fits in length bits.
505 static void send_bits(int value, int length)
508 Tracev((stderr, " l %2d v %4x ", length, value));
509 Assert(length > 0 && length <= 15, "invalid length");
512 /* If not enough room in bi_buf, use (valid) bits from bi_buf and
513 * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
514 * unused bits in value.
516 if (bi_valid > (int) BUF_SIZE - length) {
517 bi_buf |= (value << bi_valid);
519 bi_buf = (ush) value >> (BUF_SIZE - bi_valid);
520 bi_valid += length - BUF_SIZE;
522 bi_buf |= value << bi_valid;
528 /* ===========================================================================
529 * Reverse the first len bits of a code, using straightforward code (a faster
530 * method would use a table)
531 * IN assertion: 1 <= len <= 15
533 static unsigned bi_reverse(unsigned code, int len)
539 if (--len <= 0) return res;
546 /* ===========================================================================
547 * Write out any remaining bits in an incomplete byte.
549 static void bi_windup(void)
553 } else if (bi_valid > 0) {
559 bits_sent = (bits_sent + 7) & ~7;
564 /* ===========================================================================
565 * Copy a stored block to the zip file, storing first the length and its
566 * one's complement if requested.
568 static void copy_block(char *buf, unsigned len, int header)
570 bi_windup(); /* align on byte boundary */
580 bits_sent += (ulg) len << 3;
588 /* ===========================================================================
589 * Update a hash value with the given input byte
590 * IN assertion: all calls to to UPDATE_HASH are made with consecutive
591 * input characters, so that a running hash key can be computed from the
592 * previous key instead of complete recalculation each time.
594 #define UPDATE_HASH(h, c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
597 /* ===========================================================================
598 * Initialize the "longest match" routines for a new file
600 static void lm_init(ush * flags)
604 /* Initialize the hash table. */
605 memset(head, 0, HASH_SIZE * sizeof(*head));
606 /* prev will be initialized on the fly */
608 /*speed options for the general purpose bit flag */
609 *flags |= 2; /* FAST 4, SLOW 2 */
610 /* ??? reduce max_chain_length for binary files */
615 lookahead = file_read(window,
616 sizeof(int) <= 2 ? (unsigned) WSIZE : 2 * WSIZE);
618 if (lookahead == 0 || lookahead == (unsigned) -1) {
624 /* Make sure that we always have enough lookahead. This is important
625 * if input comes from a device such as a tty.
627 while (lookahead < MIN_LOOKAHEAD && !eofile)
631 for (j = 0; j < MIN_MATCH - 1; j++)
632 UPDATE_HASH(ins_h, window[j]);
633 /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
634 * not important since only literal bytes will be emitted.
638 /* ===========================================================================
639 * Set match_start to the longest match starting at the given string and
640 * return its length. Matches shorter or equal to prev_length are discarded,
641 * in which case the result is equal to prev_length and match_start is
643 * IN assertions: cur_match is the head of the hash chain for the current
644 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
647 /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or
648 * match.s. The code is functionally equivalent, so you can use the C version
651 static int longest_match(IPos cur_match)
653 unsigned chain_length = max_chain_length; /* max hash chain length */
654 uch *scan = window + strstart; /* current string */
655 uch *match; /* matched string */
656 int len; /* length of current match */
657 int best_len = prev_length; /* best match length so far */
658 IPos limit = strstart > (IPos) MAX_DIST ? strstart - (IPos) MAX_DIST : 0;
659 /* Stop when cur_match becomes <= limit. To simplify the code,
660 * we prevent matches with the string of window index 0.
663 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
664 * It is easy to get rid of this optimization if necessary.
666 #if HASH_BITS < 8 || MAX_MATCH != 258
667 # error Code too clever
669 uch *strend = window + strstart + MAX_MATCH;
670 uch scan_end1 = scan[best_len - 1];
671 uch scan_end = scan[best_len];
673 /* Do not waste too much time if we already have a good match: */
674 if (prev_length >= good_match) {
677 Assert(strstart <= WINDOW_SIZE - MIN_LOOKAHEAD, "insufficient lookahead");
680 Assert(cur_match < strstart, "no future");
681 match = window + cur_match;
683 /* Skip to next match if the match length cannot increase
684 * or if the match length is less than 2:
686 if (match[best_len] != scan_end ||
687 match[best_len - 1] != scan_end1 ||
688 *match != *scan || *++match != scan[1])
691 /* The check at best_len-1 can be removed because it will be made
692 * again later. (This heuristic is not always a win.)
693 * It is not necessary to compare scan[2] and match[2] since they
694 * are always equal when the other bytes match, given that
695 * the hash keys are equal and that HASH_BITS >= 8.
699 /* We check for insufficient lookahead only every 8th comparison;
700 * the 256th check will be made at strstart+258.
703 } while (*++scan == *++match && *++scan == *++match &&
704 *++scan == *++match && *++scan == *++match &&
705 *++scan == *++match && *++scan == *++match &&
706 *++scan == *++match && *++scan == *++match && scan < strend);
708 len = MAX_MATCH - (int) (strend - scan);
709 scan = strend - MAX_MATCH;
711 if (len > best_len) {
712 match_start = cur_match;
714 if (len >= nice_match)
716 scan_end1 = scan[best_len - 1];
717 scan_end = scan[best_len];
719 } while ((cur_match = prev[cur_match & WMASK]) > limit
720 && --chain_length != 0);
727 /* ===========================================================================
728 * Check that the match at match_start is indeed a match.
730 static void check_match(IPos start, IPos match, int length)
732 /* check that the match is indeed a match */
733 if (memcmp(window + match, window + start, length) != 0) {
734 bb_error_msg(" start %d, match %d, length %d", start, match, length);
735 bb_error_msg("invalid match");
738 bb_error_msg("\\[%d,%d]", start - match, length);
740 putc(window[start++], stderr);
741 } while (--length != 0);
745 # define check_match(start, match, length) ((void)0)
749 /* ===========================================================================
750 * Fill the window when the lookahead becomes insufficient.
751 * Updates strstart and lookahead, and sets eofile if end of input file.
752 * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
753 * OUT assertions: at least one byte has been read, or eofile is set;
754 * file reads are performed for at least two bytes (required for the
755 * translate_eol option).
757 static void fill_window(void)
760 unsigned more = WINDOW_SIZE - lookahead - strstart;
761 /* Amount of free space at the end of the window. */
763 /* If the window is almost full and there is insufficient lookahead,
764 * move the upper half to the lower one to make room in the upper half.
766 if (more == (unsigned) -1) {
767 /* Very unlikely, but possible on 16 bit machine if strstart == 0
768 * and lookahead == 1 (input done one byte at time)
771 } else if (strstart >= WSIZE + MAX_DIST) {
772 /* By the IN assertion, the window is not empty so we can't confuse
773 * more == 0 with more == 64K on a 16 bit machine.
775 Assert(WINDOW_SIZE == 2 * WSIZE, "no sliding with BIG_MEM");
777 memcpy(window, window + WSIZE, WSIZE);
778 match_start -= WSIZE;
779 strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */
781 block_start -= WSIZE;
783 for (n = 0; n < HASH_SIZE; n++) {
785 head[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
787 for (n = 0; n < WSIZE; n++) {
789 prev[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
790 /* If n is not on any hash chain, prev[n] is garbage but
791 * its value will never be used.
796 /* At this point, more >= 2 */
798 n = file_read(window + strstart + lookahead, more);
799 if (n == 0 || n == (unsigned) -1) {
808 /* ===========================================================================
809 * Same as above, but achieves better compression. We use a lazy
810 * evaluation for matches: a match is finally adopted only if there is
811 * no better match at the next window position.
813 * Processes a new input file and return its compressed length. Sets
814 * the compressed length, crc, deflate flags and internal file
818 /* Flush the current block, with given end-of-file flag.
819 * IN assertion: strstart is set to the end of the current match. */
820 #define FLUSH_BLOCK(eof) \
823 ? (char*)&window[(unsigned)block_start] \
825 (long)strstart - block_start, \
829 /* Insert string s in the dictionary and set match_head to the previous head
830 * of the hash chain (the most recent string with same hash key). Return
831 * the previous length of the hash chain.
832 * IN assertion: all calls to to INSERT_STRING are made with consecutive
833 * input characters and the first MIN_MATCH bytes of s are valid
834 * (except for the last MIN_MATCH-1 bytes of the input file). */
835 #define INSERT_STRING(s, match_head) \
837 UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]); \
838 prev[(s) & WMASK] = match_head = head[ins_h]; \
842 static ulg deflate(void)
844 IPos hash_head; /* head of hash chain */
845 IPos prev_match; /* previous match */
846 int flush; /* set if current block must be flushed */
847 int match_available = 0; /* set if previous match exists */
848 unsigned match_length = MIN_MATCH - 1; /* length of best match */
850 /* Process the input block. */
851 while (lookahead != 0) {
852 /* Insert the string window[strstart .. strstart+2] in the
853 * dictionary, and set hash_head to the head of the hash chain:
855 INSERT_STRING(strstart, hash_head);
857 /* Find the longest match, discarding those <= prev_length.
859 prev_length = match_length, prev_match = match_start;
860 match_length = MIN_MATCH - 1;
862 if (hash_head != 0 && prev_length < max_lazy_match
863 && strstart - hash_head <= MAX_DIST
865 /* To simplify the code, we prevent matches with the string
866 * of window index 0 (in particular we have to avoid a match
867 * of the string with itself at the start of the input file).
869 match_length = longest_match(hash_head);
870 /* longest_match() sets match_start */
871 if (match_length > lookahead)
872 match_length = lookahead;
874 /* Ignore a length 3 match if it is too distant: */
875 if (match_length == MIN_MATCH && strstart - match_start > TOO_FAR) {
876 /* If prev_match is also MIN_MATCH, match_start is garbage
877 * but we will ignore the current match anyway.
882 /* If there was a match at the previous step and the current
883 * match is not better, output the previous match:
885 if (prev_length >= MIN_MATCH && match_length <= prev_length) {
886 check_match(strstart - 1, prev_match, prev_length);
887 flush = ct_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
889 /* Insert in hash table all strings up to the end of the match.
890 * strstart-1 and strstart are already inserted.
892 lookahead -= prev_length - 1;
896 INSERT_STRING(strstart, hash_head);
897 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
898 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
899 * these bytes are garbage, but it does not matter since the
900 * next lookahead bytes will always be emitted as literals.
902 } while (--prev_length != 0);
904 match_length = MIN_MATCH - 1;
908 block_start = strstart;
910 } else if (match_available) {
911 /* If there was no match at the previous position, output a
912 * single literal. If there was a match but the current match
913 * is longer, truncate the previous match to a single literal.
915 Tracevv((stderr, "%c", window[strstart - 1]));
916 if (ct_tally(0, window[strstart - 1])) {
918 block_start = strstart;
923 /* There is no previous match to compare with, wait for
924 * the next step to decide.
930 Assert(strstart <= isize && lookahead <= isize, "a bit too far");
932 /* Make sure that we always have enough lookahead, except
933 * at the end of the input file. We need MAX_MATCH bytes
934 * for the next match, plus MIN_MATCH bytes to insert the
935 * string following the next match.
937 while (lookahead < MIN_LOOKAHEAD && !eofile)
941 ct_tally(0, window[strstart - 1]);
943 return FLUSH_BLOCK(1); /* eof */
945 /* trees.c -- output deflated data using Huffman coding
946 * Copyright (C) 1992-1993 Jean-loup Gailly
947 * This is free software; you can redistribute it and/or modify it under the
948 * terms of the GNU General Public License, see the file COPYING.
952 * Encode various sets of source values using variable-length
956 * The PKZIP "deflation" process uses several Huffman trees. The more
957 * common source values are represented by shorter bit sequences.
959 * Each code tree is stored in the ZIP file in a compressed form
960 * which is itself a Huffman encoding of the lengths of
961 * all the code strings (in ascending order by source values).
962 * The actual code strings are reconstructed from the lengths in
963 * the UNZIP process, as described in the "application note"
964 * (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
968 * Data Compression: Techniques and Applications, pp. 53-55.
969 * Lifetime Learning Publications, 1985. ISBN 0-534-03418-7.
972 * Data Compression: Methods and Theory, pp. 49-50.
973 * Computer Science Press, 1988. ISBN 0-7167-8156-5.
977 * Addison-Wesley, 1983. ISBN 0-201-06672-6.
980 * void ct_init(ush *attr, int *methodp)
981 * Allocate the match buffer, initialize the various tables and save
982 * the location of the internal file attribute (ascii/binary) and
983 * method (DEFLATE/STORE)
985 * void ct_tally(int dist, int lc);
986 * Save the match info and tally the frequency counts.
988 * long flush_block (char *buf, ulg stored_len, int eof)
989 * Determine the best encoding for the current block: dynamic trees,
990 * static trees or store, and output the encoded block to the zip
991 * file. Returns the total compressed length for the file so far.
994 /* ===========================================================================
999 /* All codes must not exceed MAX_BITS bits */
1001 #define MAX_BL_BITS 7
1002 /* Bit length codes must not exceed MAX_BL_BITS bits */
1004 #define LENGTH_CODES 29
1005 /* number of length codes, not counting the special END_BLOCK code */
1007 #define LITERALS 256
1008 /* number of literal bytes 0..255 */
1010 #define END_BLOCK 256
1011 /* end of block literal code */
1013 #define L_CODES (LITERALS+1+LENGTH_CODES)
1014 /* number of Literal or Length codes, including the END_BLOCK code */
1017 /* number of distance codes */
1020 /* number of codes used to transfer the bit lengths */
1022 typedef uch extra_bits_t;
1024 /* extra bits for each length code */
1025 static const extra_bits_t extra_lbits[LENGTH_CODES]= {
1026 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
1030 /* extra bits for each distance code */
1031 static const extra_bits_t extra_dbits[D_CODES] = {
1032 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
1033 10, 10, 11, 11, 12, 12, 13, 13
1036 /* extra bits for each bit length code */
1037 static const extra_bits_t extra_blbits[BL_CODES] = {
1038 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
1040 #define STORED_BLOCK 0
1041 #define STATIC_TREES 1
1043 /* The three kinds of block type */
1047 # define LIT_BUFSIZE 0x2000
1050 # define LIT_BUFSIZE 0x4000
1052 # define LIT_BUFSIZE 0x8000
1056 #ifndef DIST_BUFSIZE
1057 # define DIST_BUFSIZE LIT_BUFSIZE
1059 /* Sizes of match buffers for literals/lengths and distances. There are
1060 * 4 reasons for limiting LIT_BUFSIZE to 64K:
1061 * - frequencies can be kept in 16 bit counters
1062 * - if compression is not successful for the first block, all input data is
1063 * still in the window so we can still emit a stored block even when input
1064 * comes from standard input. (This can also be done for all blocks if
1065 * LIT_BUFSIZE is not greater than 32K.)
1066 * - if compression is not successful for a file smaller than 64K, we can
1067 * even emit a stored file instead of a stored block (saving 5 bytes).
1068 * - creating new Huffman trees less frequently may not provide fast
1069 * adaptation to changes in the input data statistics. (Take for
1070 * example a binary file with poorly compressible code followed by
1071 * a highly compressible string table.) Smaller buffer sizes give
1072 * fast adaptation but have of course the overhead of transmitting trees
1074 * - I can't count above 4
1075 * The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
1076 * memory at the expense of compression). Some optimizations would be possible
1077 * if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
1079 #if LIT_BUFSIZE > INBUFSIZ
1080 #error cannot overlay l_buf and inbuf
1083 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
1084 #define REPZ_3_10 17
1085 /* repeat a zero length 3-10 times (3 bits of repeat count) */
1086 #define REPZ_11_138 18
1087 /* repeat a zero length 11-138 times (7 bits of repeat count) */
1089 /* ===========================================================================
1093 /* Data structure describing a single value and its code string. */
1094 typedef struct ct_data {
1096 ush freq; /* frequency count */
1097 ush code; /* bit string */
1100 ush dad; /* father node in Huffman tree */
1101 ush len; /* length of bit string */
1105 #define Freq fc.freq
1106 #define Code fc.code
1110 #define HEAP_SIZE (2*L_CODES+1)
1111 /* maximum heap size */
1113 static ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */
1114 static ct_data dyn_dtree[2 * D_CODES + 1]; /* distance tree */
1116 static ct_data static_ltree[L_CODES + 2];
1118 /* The static literal tree. Since the bit lengths are imposed, there is no
1119 * need for the L_CODES extra codes used during heap construction. However
1120 * The codes 286 and 287 are needed to build a canonical tree (see ct_init
1124 static ct_data static_dtree[D_CODES];
1126 /* The static distance tree. (Actually a trivial tree since all codes use
1130 static ct_data bl_tree[2 * BL_CODES + 1];
1132 /* Huffman tree for the bit lengths */
1134 typedef struct tree_desc {
1135 ct_data *dyn_tree; /* the dynamic tree */
1136 ct_data *static_tree; /* corresponding static tree or NULL */
1137 const extra_bits_t *extra_bits; /* extra bits for each code or NULL */
1138 int extra_base; /* base index for extra_bits */
1139 int elems; /* max number of elements in the tree */
1140 int max_length; /* max bit length for the codes */
1141 int max_code; /* largest code with non zero frequency */
1144 static tree_desc l_desc = {
1145 dyn_ltree, static_ltree, extra_lbits,
1146 LITERALS + 1, L_CODES, MAX_BITS, 0
1149 static tree_desc d_desc = {
1150 dyn_dtree, static_dtree, extra_dbits, 0, D_CODES, MAX_BITS, 0
1153 static tree_desc bl_desc = {
1154 bl_tree, NULL, extra_blbits, 0, BL_CODES, MAX_BL_BITS, 0
1158 static ush bl_count[MAX_BITS + 1];
1160 /* number of codes at each bit length for an optimal tree */
1162 static const uch bl_order[BL_CODES] = {
1163 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
1166 /* The lengths of the bit length codes are sent in order of decreasing
1167 * probability, to avoid transmitting the lengths for unused bit length codes.
1170 static int heap[2 * L_CODES + 1]; /* heap used to build the Huffman trees */
1171 static int heap_len; /* number of elements in the heap */
1172 static int heap_max; /* element of largest frequency */
1174 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
1175 * The same heap array is used to build all trees.
1178 static uch depth[2 * L_CODES + 1];
1180 /* Depth of each subtree used as tie breaker for trees of equal frequency */
1182 static uch length_code[MAX_MATCH - MIN_MATCH + 1];
1184 /* length code for each normalized match length (0 == MIN_MATCH) */
1186 static uch dist_code[512];
1188 /* distance codes. The first 256 values correspond to the distances
1189 * 3 .. 258, the last 256 values correspond to the top 8 bits of
1190 * the 15 bit distances.
1193 static int base_length[LENGTH_CODES];
1195 /* First normalized length for each code (0 = MIN_MATCH) */
1197 static int base_dist[D_CODES];
1199 /* First normalized distance for each code (0 = distance of 1) */
1202 /* DECLARE(uch, l_buf, LIT_BUFSIZE); buffer for literals or lengths */
1204 /* DECLARE(ush, d_buf, DIST_BUFSIZE); buffer for distances */
1206 static uch flag_buf[(LIT_BUFSIZE / 8)];
1208 /* flag_buf is a bit array distinguishing literals from lengths in
1209 * l_buf, thus indicating the presence or absence of a distance.
1212 static unsigned last_lit; /* running index in l_buf */
1213 static unsigned last_dist; /* running index in d_buf */
1214 static unsigned last_flags; /* running index in flag_buf */
1215 static uch flags; /* current flags not yet saved in flag_buf */
1216 static uch flag_bit; /* current bit used in flags */
1218 /* bits are filled in flags starting at bit 0 (least significant).
1219 * Note: these flags are overkill in the current code since we don't
1220 * take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
1223 static ulg opt_len; /* bit length of current block with optimal trees */
1224 static ulg static_len; /* bit length of current block with static trees */
1226 static ulg compressed_len; /* total bit length of compressed file */
1229 static ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */
1230 static int *file_method; /* pointer to DEFLATE or STORE */
1232 /* ===========================================================================
1234 static void init_block(void);
1235 static void gen_bitlen(tree_desc * desc);
1236 static void gen_codes(ct_data * tree, int max_code);
1237 static void build_tree(tree_desc * desc);
1238 static void scan_tree(ct_data * tree, int max_code);
1239 static void send_tree(ct_data * tree, int max_code);
1240 static int build_bl_tree(void);
1241 static void send_all_trees(int lcodes, int dcodes, int blcodes);
1242 static void compress_block(ct_data * ltree, ct_data * dtree);
1243 static void set_file_type(void);
1247 /* Send a code of the given tree. c and tree must not have side effects */
1248 # define SEND_CODE(c, tree) send_bits(tree[c].Code, tree[c].Len)
1250 # define SEND_CODE(c, tree) \
1252 if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \
1253 send_bits(tree[c].Code, tree[c].Len); \
1257 #define D_CODE(dist) \
1258 ((dist) < 256 ? dist_code[dist] : dist_code[256 + ((dist)>>7)])
1259 /* Mapping from a distance to a distance code. dist is the distance - 1 and
1260 * must not have side effects. dist_code[256] and dist_code[257] are never
1264 /* the arguments must not have side effects */
1267 /* ===========================================================================
1268 * Allocate the match buffer, initialize the various tables and save the
1269 * location of the internal file attribute (ascii/binary) and method
1272 static void ct_init(ush * attr, int *methodp)
1274 int n; /* iterates over tree elements */
1275 int bits; /* bit counter */
1276 int length; /* length value */
1277 int code; /* code value */
1278 int dist; /* distance index */
1281 file_method = methodp;
1282 compressed_len = 0L;
1284 if (static_dtree[0].Len != 0)
1285 return; /* ct_init already called */
1287 /* Initialize the mapping length (0..255) -> length code (0..28) */
1289 for (code = 0; code < LENGTH_CODES - 1; code++) {
1290 base_length[code] = length;
1291 for (n = 0; n < (1 << extra_lbits[code]); n++) {
1292 length_code[length++] = (uch) code;
1295 Assert(length == 256, "ct_init: length != 256");
1296 /* Note that the length 255 (match length 258) can be represented
1297 * in two different ways: code 284 + 5 bits or code 285, so we
1298 * overwrite length_code[255] to use the best encoding:
1300 length_code[length - 1] = (uch) code;
1302 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
1304 for (code = 0; code < 16; code++) {
1305 base_dist[code] = dist;
1306 for (n = 0; n < (1 << extra_dbits[code]); n++) {
1307 dist_code[dist++] = code;
1310 Assert(dist == 256, "ct_init: dist != 256");
1311 dist >>= 7; /* from now on, all distances are divided by 128 */
1312 for (; code < D_CODES; code++) {
1313 base_dist[code] = dist << 7;
1314 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
1315 dist_code[256 + dist++] = (uch) code;
1318 Assert(dist == 256, "ct_init: 256+dist != 512");
1320 /* Construct the codes of the static literal tree */
1321 for (bits = 0; bits <= MAX_BITS; bits++)
1326 static_ltree[n++].Len = 8;
1330 static_ltree[n++].Len = 9;
1334 static_ltree[n++].Len = 7;
1338 static_ltree[n++].Len = 8;
1341 /* Codes 286 and 287 do not exist, but we must include them in the
1342 * tree construction to get a canonical Huffman tree (longest code
1345 gen_codes((ct_data *) static_ltree, L_CODES + 1);
1347 /* The static distance tree is trivial: */
1348 for (n = 0; n < D_CODES; n++) {
1349 static_dtree[n].Len = 5;
1350 static_dtree[n].Code = bi_reverse(n, 5);
1353 /* Initialize the first block of the first file: */
1358 /* ===========================================================================
1359 * Initialize a new block.
1361 static void init_block(void)
1363 int n; /* iterates over tree elements */
1365 /* Initialize the trees. */
1366 for (n = 0; n < L_CODES; n++)
1367 dyn_ltree[n].Freq = 0;
1368 for (n = 0; n < D_CODES; n++)
1369 dyn_dtree[n].Freq = 0;
1370 for (n = 0; n < BL_CODES; n++)
1371 bl_tree[n].Freq = 0;
1373 dyn_ltree[END_BLOCK].Freq = 1;
1374 opt_len = static_len = 0L;
1375 last_lit = last_dist = last_flags = 0;
1381 /* ===========================================================================
1382 * Restore the heap property by moving down the tree starting at node k,
1383 * exchanging a node with the smallest of its two sons if necessary, stopping
1384 * when the heap property is re-established (each father smaller than its
1388 /* Compares to subtrees, using the tree depth as tie breaker when
1389 * the subtrees have equal frequency. This minimizes the worst case length. */
1390 #define SMALLER(tree, n, m) \
1391 (tree[n].Freq < tree[m].Freq \
1392 || (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
1394 static void pqdownheap(ct_data * tree, int k)
1397 int j = k << 1; /* left son of k */
1399 while (j <= heap_len) {
1400 /* Set j to the smallest of the two sons: */
1401 if (j < heap_len && SMALLER(tree, heap[j + 1], heap[j]))
1404 /* Exit if v is smaller than both sons */
1405 if (SMALLER(tree, v, heap[j]))
1408 /* Exchange v with the smallest son */
1412 /* And continue down the tree, setting j to the left son of k */
1419 /* ===========================================================================
1420 * Compute the optimal bit lengths for a tree and update the total bit length
1421 * for the current block.
1422 * IN assertion: the fields freq and dad are set, heap[heap_max] and
1423 * above are the tree nodes sorted by increasing frequency.
1424 * OUT assertions: the field len is set to the optimal bit length, the
1425 * array bl_count contains the frequencies for each bit length.
1426 * The length opt_len is updated; static_len is also updated if stree is
1429 static void gen_bitlen(tree_desc * desc)
1431 ct_data *tree = desc->dyn_tree;
1432 const extra_bits_t *extra = desc->extra_bits;
1433 int base = desc->extra_base;
1434 int max_code = desc->max_code;
1435 int max_length = desc->max_length;
1436 ct_data *stree = desc->static_tree;
1437 int h; /* heap index */
1438 int n, m; /* iterate over the tree elements */
1439 int bits; /* bit length */
1440 int xbits; /* extra bits */
1441 ush f; /* frequency */
1442 int overflow = 0; /* number of elements with bit length too large */
1444 for (bits = 0; bits <= MAX_BITS; bits++)
1447 /* In a first pass, compute the optimal bit lengths (which may
1448 * overflow in the case of the bit length tree).
1450 tree[heap[heap_max]].Len = 0; /* root of the heap */
1452 for (h = heap_max + 1; h < HEAP_SIZE; h++) {
1454 bits = tree[tree[n].Dad].Len + 1;
1455 if (bits > max_length) {
1459 tree[n].Len = (ush) bits;
1460 /* We overwrite tree[n].Dad which is no longer needed */
1463 continue; /* not a leaf node */
1468 xbits = extra[n - base];
1470 opt_len += (ulg) f *(bits + xbits);
1473 static_len += (ulg) f *(stree[n].Len + xbits);
1478 Trace((stderr, "\nbit length overflow\n"));
1479 /* This happens for example on obj2 and pic of the Calgary corpus */
1481 /* Find the first bit length which could increase: */
1483 bits = max_length - 1;
1484 while (bl_count[bits] == 0)
1486 bl_count[bits]--; /* move one leaf down the tree */
1487 bl_count[bits + 1] += 2; /* move one overflow item as its brother */
1488 bl_count[max_length]--;
1489 /* The brother of the overflow item also moves one step up,
1490 * but this does not affect bl_count[max_length]
1493 } while (overflow > 0);
1495 /* Now recompute all bit lengths, scanning in increasing frequency.
1496 * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
1497 * lengths instead of fixing only the wrong ones. This idea is taken
1498 * from 'ar' written by Haruhiko Okumura.)
1500 for (bits = max_length; bits != 0; bits--) {
1506 if (tree[m].Len != (unsigned) bits) {
1507 Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits));
1508 opt_len += ((long) bits - (long) tree[m].Len) * (long) tree[m].Freq;
1509 tree[m].Len = (ush) bits;
1516 /* ===========================================================================
1517 * Generate the codes for a given tree and bit counts (which need not be
1519 * IN assertion: the array bl_count contains the bit length statistics for
1520 * the given tree and the field len is set for all tree elements.
1521 * OUT assertion: the field code is set for all tree elements of non
1524 static void gen_codes(ct_data * tree, int max_code)
1526 ush next_code[MAX_BITS + 1]; /* next code value for each bit length */
1527 ush code = 0; /* running code value */
1528 int bits; /* bit index */
1529 int n; /* code index */
1531 /* The distribution counts are first used to generate the code values
1532 * without bit reversal.
1534 for (bits = 1; bits <= MAX_BITS; bits++) {
1535 next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
1537 /* Check that the bit counts in bl_count are consistent. The last code
1540 Assert(code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
1541 "inconsistent bit counts");
1542 Tracev((stderr, "\ngen_codes: max_code %d ", max_code));
1544 for (n = 0; n <= max_code; n++) {
1545 int len = tree[n].Len;
1549 /* Now reverse the bits */
1550 tree[n].Code = bi_reverse(next_code[len]++, len);
1552 Tracec(tree != static_ltree,
1553 (stderr, "\nn %3d %c l %2d c %4x (%x) ", n,
1554 (isgraph(n) ? n : ' '), len, tree[n].Code,
1555 next_code[len] - 1));
1559 /* ===========================================================================
1560 * Construct one Huffman tree and assigns the code bit strings and lengths.
1561 * Update the total bit length for the current block.
1562 * IN assertion: the field freq is set for all tree elements.
1563 * OUT assertions: the fields len and code are set to the optimal bit length
1564 * and corresponding code. The length opt_len is updated; static_len is
1565 * also updated if stree is not null. The field max_code is set.
1568 /* Remove the smallest element from the heap and recreate the heap with
1569 * one less element. Updates heap and heap_len. */
1572 /* Index within the heap array of least frequent node in the Huffman tree */
1574 #define PQREMOVE(tree, top) \
1576 top = heap[SMALLEST]; \
1577 heap[SMALLEST] = heap[heap_len--]; \
1578 pqdownheap(tree, SMALLEST); \
1581 static void build_tree(tree_desc * desc)
1583 ct_data *tree = desc->dyn_tree;
1584 ct_data *stree = desc->static_tree;
1585 int elems = desc->elems;
1586 int n, m; /* iterate over heap elements */
1587 int max_code = -1; /* largest code with non zero frequency */
1588 int node = elems; /* next internal node of the tree */
1590 /* Construct the initial heap, with least frequent element in
1591 * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
1592 * heap[0] is not used.
1594 heap_len = 0, heap_max = HEAP_SIZE;
1596 for (n = 0; n < elems; n++) {
1597 if (tree[n].Freq != 0) {
1598 heap[++heap_len] = max_code = n;
1605 /* The pkzip format requires that at least one distance code exists,
1606 * and that at least one bit should be sent even if there is only one
1607 * possible code. So to avoid special checks later on we force at least
1608 * two codes of non zero frequency.
1610 while (heap_len < 2) {
1611 int new = heap[++heap_len] = (max_code < 2 ? ++max_code : 0);
1617 static_len -= stree[new].Len;
1618 /* new is 0 or 1 so it does not have extra bits */
1620 desc->max_code = max_code;
1622 /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
1623 * establish sub-heaps of increasing lengths:
1625 for (n = heap_len / 2; n >= 1; n--)
1626 pqdownheap(tree, n);
1628 /* Construct the Huffman tree by repeatedly combining the least two
1632 PQREMOVE(tree, n); /* n = node of least frequency */
1633 m = heap[SMALLEST]; /* m = node of next least frequency */
1635 heap[--heap_max] = n; /* keep the nodes sorted by frequency */
1636 heap[--heap_max] = m;
1638 /* Create a new node father of n and m */
1639 tree[node].Freq = tree[n].Freq + tree[m].Freq;
1640 depth[node] = (uch) (MAX(depth[n], depth[m]) + 1);
1641 tree[n].Dad = tree[m].Dad = (ush) node;
1643 if (tree == bl_tree) {
1644 bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)",
1645 node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
1648 /* and insert the new node in the heap */
1649 heap[SMALLEST] = node++;
1650 pqdownheap(tree, SMALLEST);
1652 } while (heap_len >= 2);
1654 heap[--heap_max] = heap[SMALLEST];
1656 /* At this point, the fields freq and dad are set. We can now
1657 * generate the bit lengths.
1659 gen_bitlen((tree_desc *) desc);
1661 /* The field len is now set, we can generate the bit codes */
1662 gen_codes((ct_data *) tree, max_code);
1665 /* ===========================================================================
1666 * Scan a literal or distance tree to determine the frequencies of the codes
1667 * in the bit length tree. Updates opt_len to take into account the repeat
1668 * counts. (The contribution of the bit length codes will be added later
1669 * during the construction of bl_tree.)
1671 static void scan_tree(ct_data * tree, int max_code)
1673 int n; /* iterates over all tree elements */
1674 int prevlen = -1; /* last emitted length */
1675 int curlen; /* length of current code */
1676 int nextlen = tree[0].Len; /* length of next code */
1677 int count = 0; /* repeat count of the current code */
1678 int max_count = 7; /* max repeat count */
1679 int min_count = 4; /* min repeat count */
1685 tree[max_code + 1].Len = (ush) 0xffff; /* guard */
1687 for (n = 0; n <= max_code; n++) {
1689 nextlen = tree[n + 1].Len;
1690 if (++count < max_count && curlen == nextlen) {
1692 } else if (count < min_count) {
1693 bl_tree[curlen].Freq += count;
1694 } else if (curlen != 0) {
1695 if (curlen != prevlen)
1696 bl_tree[curlen].Freq++;
1697 bl_tree[REP_3_6].Freq++;
1698 } else if (count <= 10) {
1699 bl_tree[REPZ_3_10].Freq++;
1701 bl_tree[REPZ_11_138].Freq++;
1708 } else if (curlen == nextlen) {
1718 /* ===========================================================================
1719 * Send a literal or distance tree in compressed form, using the codes in
1722 static void send_tree(ct_data * tree, int max_code)
1724 int n; /* iterates over all tree elements */
1725 int prevlen = -1; /* last emitted length */
1726 int curlen; /* length of current code */
1727 int nextlen = tree[0].Len; /* length of next code */
1728 int count = 0; /* repeat count of the current code */
1729 int max_count = 7; /* max repeat count */
1730 int min_count = 4; /* min repeat count */
1732 /* tree[max_code+1].Len = -1; *//* guard already set */
1734 max_count = 138, min_count = 3;
1736 for (n = 0; n <= max_code; n++) {
1738 nextlen = tree[n + 1].Len;
1739 if (++count < max_count && curlen == nextlen) {
1741 } else if (count < min_count) {
1743 SEND_CODE(curlen, bl_tree);
1745 } else if (curlen != 0) {
1746 if (curlen != prevlen) {
1747 SEND_CODE(curlen, bl_tree);
1750 Assert(count >= 3 && count <= 6, " 3_6?");
1751 SEND_CODE(REP_3_6, bl_tree);
1752 send_bits(count - 3, 2);
1753 } else if (count <= 10) {
1754 SEND_CODE(REPZ_3_10, bl_tree);
1755 send_bits(count - 3, 3);
1757 SEND_CODE(REPZ_11_138, bl_tree);
1758 send_bits(count - 11, 7);
1765 } else if (curlen == nextlen) {
1775 /* ===========================================================================
1776 * Construct the Huffman tree for the bit lengths and return the index in
1777 * bl_order of the last bit length code to send.
1779 static int build_bl_tree(void)
1781 int max_blindex; /* index of last bit length code of non zero freq */
1783 /* Determine the bit length frequencies for literal and distance trees */
1784 scan_tree((ct_data *) dyn_ltree, l_desc.max_code);
1785 scan_tree((ct_data *) dyn_dtree, d_desc.max_code);
1787 /* Build the bit length tree: */
1788 build_tree((tree_desc *) (&bl_desc));
1789 /* opt_len now includes the length of the tree representations, except
1790 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
1793 /* Determine the number of bit length codes to send. The pkzip format
1794 * requires that at least 4 bit length codes be sent. (appnote.txt says
1795 * 3 but the actual value used is 4.)
1797 for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
1798 if (bl_tree[bl_order[max_blindex]].Len != 0)
1801 /* Update opt_len to include the bit length tree and counts */
1802 opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
1803 Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, static_len));
1808 /* ===========================================================================
1809 * Send the header for a block using dynamic Huffman trees: the counts, the
1810 * lengths of the bit length codes, the literal tree and the distance tree.
1811 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
1813 static void send_all_trees(int lcodes, int dcodes, int blcodes)
1815 int rank; /* index in bl_order */
1817 Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
1818 Assert(lcodes <= L_CODES && dcodes <= D_CODES
1819 && blcodes <= BL_CODES, "too many codes");
1820 Tracev((stderr, "\nbl counts: "));
1821 send_bits(lcodes - 257, 5); /* not +255 as stated in appnote.txt */
1822 send_bits(dcodes - 1, 5);
1823 send_bits(blcodes - 4, 4); /* not -3 as stated in appnote.txt */
1824 for (rank = 0; rank < blcodes; rank++) {
1825 Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
1826 send_bits(bl_tree[bl_order[rank]].Len, 3);
1828 Tracev((stderr, "\nbl tree: sent %ld", bits_sent));
1830 send_tree((ct_data *) dyn_ltree, lcodes - 1); /* send the literal tree */
1831 Tracev((stderr, "\nlit tree: sent %ld", bits_sent));
1833 send_tree((ct_data *) dyn_dtree, dcodes - 1); /* send the distance tree */
1834 Tracev((stderr, "\ndist tree: sent %ld", bits_sent));
1837 /* ===========================================================================
1838 * Determine the best encoding for the current block: dynamic trees, static
1839 * trees or store, and output the encoded block to the zip file. This function
1840 * returns the total compressed length for the file so far.
1842 static ulg flush_block(char *buf, ulg stored_len, int eof)
1844 ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
1845 int max_blindex; /* index of last bit length code of non zero freq */
1847 flag_buf[last_flags] = flags; /* Save the flags for the last 8 items */
1849 /* Check if the file is ascii or binary */
1850 if (*file_type == (ush) UNKNOWN)
1853 /* Construct the literal and distance trees */
1854 build_tree((tree_desc *) (&l_desc));
1855 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", opt_len, static_len));
1857 build_tree((tree_desc *) (&d_desc));
1858 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", opt_len, static_len));
1859 /* At this point, opt_len and static_len are the total bit lengths of
1860 * the compressed block data, excluding the tree representations.
1863 /* Build the bit length tree for the above two trees, and get the index
1864 * in bl_order of the last bit length code to send.
1866 max_blindex = build_bl_tree();
1868 /* Determine the best encoding. Compute first the block length in bytes */
1869 opt_lenb = (opt_len + 3 + 7) >> 3;
1870 static_lenb = (static_len + 3 + 7) >> 3;
1873 "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
1874 opt_lenb, opt_len, static_lenb, static_len, stored_len,
1875 last_lit, last_dist));
1877 if (static_lenb <= opt_lenb)
1878 opt_lenb = static_lenb;
1880 /* If compression failed and this is the first and last block,
1881 * and if the zip file can be seeked (to rewrite the local header),
1882 * the whole file is transformed into a stored file:
1884 if (stored_len <= opt_lenb && eof && compressed_len == 0L && seekable()) {
1885 /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
1887 bb_error_msg("block vanished");
1889 copy_block(buf, (unsigned) stored_len, 0); /* without header */
1890 compressed_len = stored_len << 3;
1891 *file_method = STORED;
1893 } else if (stored_len + 4 <= opt_lenb && buf != (char *) 0) {
1894 /* 4: two words for the lengths */
1895 /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
1896 * Otherwise we can't have processed more than WSIZE input bytes since
1897 * the last block flush, because compression would have been
1898 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
1899 * transform a block into a stored block.
1901 send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */
1902 compressed_len = (compressed_len + 3 + 7) & ~7L;
1903 compressed_len += (stored_len + 4) << 3;
1905 copy_block(buf, (unsigned) stored_len, 1); /* with header */
1907 } else if (static_lenb == opt_lenb) {
1908 send_bits((STATIC_TREES << 1) + eof, 3);
1909 compress_block((ct_data *) static_ltree, (ct_data *) static_dtree);
1910 compressed_len += 3 + static_len;
1912 send_bits((DYN_TREES << 1) + eof, 3);
1913 send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1,
1915 compress_block((ct_data *) dyn_ltree, (ct_data *) dyn_dtree);
1916 compressed_len += 3 + opt_len;
1918 Assert(compressed_len == bits_sent, "bad compressed size");
1923 compressed_len += 7; /* align on byte boundary */
1925 Tracev((stderr, "\ncomprlen %lu(%lu) ", compressed_len >> 3,
1926 compressed_len - 7 * eof));
1928 return compressed_len >> 3;
1931 /* ===========================================================================
1932 * Save the match info and tally the frequency counts. Return true if
1933 * the current block must be flushed.
1935 static int ct_tally(int dist, int lc)
1937 l_buf[last_lit++] = lc;
1939 /* lc is the unmatched char */
1940 dyn_ltree[lc].Freq++;
1942 /* Here, lc is the match length - MIN_MATCH */
1943 dist--; /* dist = match distance - 1 */
1944 Assert((ush) dist < (ush) MAX_DIST
1945 && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH)
1946 && (ush) D_CODE(dist) < (ush) D_CODES, "ct_tally: bad match"
1949 dyn_ltree[length_code[lc] + LITERALS + 1].Freq++;
1950 dyn_dtree[D_CODE(dist)].Freq++;
1952 d_buf[last_dist++] = dist;
1957 /* Output the flags if they fill a byte: */
1958 if ((last_lit & 7) == 0) {
1959 flag_buf[last_flags++] = flags;
1960 flags = 0, flag_bit = 1;
1962 /* Try to guess if it is profitable to stop the current block here */
1963 if ((last_lit & 0xfff) == 0) {
1964 /* Compute an upper bound for the compressed length */
1965 ulg out_length = last_lit * 8L;
1966 ulg in_length = (ulg) strstart - block_start;
1969 for (dcode = 0; dcode < D_CODES; dcode++) {
1970 out_length += dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]);
1974 "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
1975 last_lit, last_dist, in_length, out_length,
1976 100L - out_length * 100L / in_length));
1977 if (last_dist < last_lit / 2 && out_length < in_length / 2)
1980 return (last_lit == LIT_BUFSIZE - 1 || last_dist == DIST_BUFSIZE);
1981 /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
1982 * on 16 bit machines and because stored blocks are restricted to
1987 /* ===========================================================================
1988 * Send the block data compressed using the given Huffman trees
1990 static void compress_block(ct_data * ltree, ct_data * dtree)
1992 unsigned dist; /* distance of matched string */
1993 int lc; /* match length or unmatched char (if dist == 0) */
1994 unsigned lx = 0; /* running index in l_buf */
1995 unsigned dx = 0; /* running index in d_buf */
1996 unsigned fx = 0; /* running index in flag_buf */
1997 uch flag = 0; /* current flags */
1998 unsigned code; /* the code to send */
1999 int extra; /* number of extra bits to send */
2001 if (last_lit != 0) {
2004 flag = flag_buf[fx++];
2006 if ((flag & 1) == 0) {
2007 SEND_CODE(lc, ltree); /* send a literal byte */
2008 Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
2010 /* Here, lc is the match length - MIN_MATCH */
2011 code = length_code[lc];
2012 SEND_CODE(code + LITERALS + 1, ltree); /* send the length code */
2013 extra = extra_lbits[code];
2015 lc -= base_length[code];
2016 send_bits(lc, extra); /* send the extra length bits */
2019 /* Here, dist is the match distance - 1 */
2020 code = D_CODE(dist);
2021 Assert(code < D_CODES, "bad d_code");
2023 SEND_CODE(code, dtree); /* send the distance code */
2024 extra = extra_dbits[code];
2026 dist -= base_dist[code];
2027 send_bits(dist, extra); /* send the extra distance bits */
2029 } /* literal or match pair ? */
2031 } while (lx < last_lit);
2034 SEND_CODE(END_BLOCK, ltree);
2037 /* ===========================================================================
2038 * Set the file type to ASCII or BINARY, using a crude approximation:
2039 * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
2040 * IN assertion: the fields freq of dyn_ltree are set and the total of all
2041 * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
2043 static void set_file_type(void)
2046 unsigned ascii_freq = 0;
2047 unsigned bin_freq = 0;
2050 bin_freq += dyn_ltree[n++].Freq;
2052 ascii_freq += dyn_ltree[n++].Freq;
2053 while (n < LITERALS)
2054 bin_freq += dyn_ltree[n++].Freq;
2055 *file_type = (bin_freq > (ascii_freq >> 2)) ? BINARY : ASCII;
2056 if (*file_type == BINARY && translate_eol) {
2057 bb_error_msg("-l used on binary file");
2061 /* ===========================================================================
2062 * Deflate in to out.
2063 * IN assertions: the input and output buffers are cleared.
2064 * The variables time_stamp and save_orig_name are initialized.
2066 static int zip(int in, int out)
2068 uch my_flags = 0; /* general purpose bit flags */
2069 ush attr = 0; /* ascii/binary flag */
2070 ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */
2076 /* Write the header to the gzip file. See algorithm.doc for the format */
2079 put_header_byte(0x1f); /* magic header for gzip files, 1F 8B */
2080 put_header_byte(0x8b);
2082 put_header_byte(DEFLATED); /* compression method */
2084 put_header_byte(my_flags); /* general flags */
2085 put_32bit(time_stamp);
2087 /* Write deflated file to zip file */
2091 ct_init(&attr, &method);
2092 lm_init(&deflate_flags);
2094 put_8bit(deflate_flags); /* extra flags */
2095 put_8bit(3); /* OS identifier = 3 (Unix) */
2099 /* Write the crc and uncompressed size */
2108 /* ======================================================================== */
2109 static void abort_gzip(int ATTRIBUTE_UNUSED ignored)
2114 int gzip_main(int argc, char **argv)
2126 struct stat statBuf;
2129 opt = getopt32(argc, argv, "cf123456789qv" USE_GUNZIP("d"));
2130 //if (opt & 0x1) // -c
2131 //if (opt & 0x2) // -f
2132 /* Ignore 1-9 (compression level) options */
2133 //if (opt & 0x4) // -1
2134 //if (opt & 0x8) // -2
2135 //if (opt & 0x10) // -3
2136 //if (opt & 0x20) // -4
2137 //if (opt & 0x40) // -5
2138 //if (opt & 0x80) // -6
2139 //if (opt & 0x100) // -7
2140 //if (opt & 0x200) // -8
2141 //if (opt & 0x400) // -9
2142 //if (opt & 0x800) // -q
2143 //if (opt & 0x1000) // -v
2144 #if ENABLE_GUNZIP /* gunzip_main may not be visible... */
2145 if (opt & 0x2000) { // -d
2146 /* FIXME: getopt32 should not depend on optind */
2148 return gunzip_main(argc, argv);
2152 foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
2154 signal(SIGINT, abort_gzip);
2157 if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
2158 signal(SIGTERM, abort_gzip);
2162 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
2163 signal(SIGHUP, abort_gzip);
2167 strncpy(z_suffix, ".gz", sizeof(z_suffix) - 1);
2169 /* Allocate all global buffers (for DYN_ALLOC option) */
2170 ALLOC(uch, inbuf, INBUFSIZ + INBUF_EXTRA);
2171 ALLOC(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
2172 ALLOC(ush, d_buf, DIST_BUFSIZE);
2173 ALLOC(uch, window, 2L * WSIZE);
2174 ALLOC(ush, prev, 1L << BITS);
2176 /* Initialise the CRC32 table */
2177 crc_32_tab = crc32_filltable(0);
2181 if (optind == argc) {
2183 zip(STDIN_FILENO, STDOUT_FILENO);
2187 for (i = optind; i < argc; i++) {
2191 if (LONE_DASH(argv[i])) {
2193 inFileNum = STDIN_FILENO;
2194 outFileNum = STDOUT_FILENO;
2196 inFileNum = xopen(argv[i], O_RDONLY);
2197 if (fstat(inFileNum, &statBuf) < 0)
2198 bb_perror_msg_and_die("%s", argv[i]);
2199 time_stamp = statBuf.st_ctime;
2201 if (!(opt & OPT_tostdout)) {
2202 path = xasprintf("%s.gz", argv[i]);
2204 /* Open output file */
2205 #if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 && defined(O_NOFOLLOW)
2206 outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW);
2208 outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL);
2210 if (outFileNum < 0) {
2211 bb_perror_msg("%s", path);
2216 /* Set permissions on the file */
2217 fchmod(outFileNum, statBuf.st_mode);
2219 outFileNum = STDOUT_FILENO;
2222 if (path == NULL && isatty(outFileNum) && !(opt & OPT_force)) {
2223 bb_error_msg("compressed data not written "
2224 "to a terminal. Use -f to force compression.");
2229 result = zip(inFileNum, outFileNum);
2235 /* Delete the original file */
2237 delFileName = argv[i];
2241 if (unlink(delFileName) < 0)
2242 bb_perror_msg("%s", delFileName);