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 /* big objects in bss:
21 * 00000074 b base_length
22 * 00000078 b base_dist
23 * 00000078 b static_dtree
25 * 000000f4 b dyn_dtree
26 * 00000100 b length_code
27 * 00000200 b dist_code
31 * 00000480 b static_ltree
32 * 000008f4 b dyn_ltree
35 /* TODO: full support for -v for DESKTOP
36 * "/usr/bin/gzip -v a bogus aa" should say:
37 a: 85.1% -- replaced with a.gz
38 gzip: bogus: No such file or directory
39 aa: 85.1% -- replaced with aa.gz
45 /* ===========================================================================
48 /* Diagnostic functions */
50 # define Assert(cond,msg) {if(!(cond)) bb_error_msg(msg);}
51 # define Trace(x) fprintf x
52 # define Tracev(x) {if (verbose) fprintf x ;}
53 # define Tracevv(x) {if (verbose > 1) fprintf x ;}
54 # define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
55 # define Tracecv(c,x) {if (verbose > 1 && (c)) fprintf x ;}
57 # define Assert(cond,msg)
66 /* ===========================================================================
70 //// /* Compression methods (see algorithm.doc) */
71 //// /* Only STORED and DEFLATED are supported by this BusyBox module */
73 //// /* methods 4 to 7 reserved */
74 //// #define DEFLATED 8
78 # define INBUFSIZ 0x2000 /* input buffer size */
80 # define INBUFSIZ 0x8000 /* input buffer size */
86 # define OUTBUFSIZ 8192 /* output buffer size */
88 # define OUTBUFSIZ 16384 /* output buffer size */
94 # define DIST_BUFSIZE 0x2000 /* buffer for distances, see trees.c */
96 # define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */
101 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
102 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
103 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
104 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
105 #define COMMENT 0x10 /* bit 4 set: file comment present */
106 #define RESERVED 0xC0 /* bit 6,7: reserved */
108 /* internal file attribute */
109 #define UNKNOWN 0xffff
114 # define WSIZE 0x8000 /* window size--must be a power of two, and */
115 #endif /* at least 32K for zip's deflate method */
118 #define MAX_MATCH 258
119 /* The minimum and maximum match lengths */
121 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
122 /* Minimum amount of lookahead, except at the end of the input file.
123 * See deflate.c for comments about the MIN_MATCH+1.
126 #define MAX_DIST (WSIZE-MIN_LOOKAHEAD)
127 /* In order to simplify the code, particularly on 16 bit machines, match
128 * distances are limited to MAX_DIST instead of WSIZE.
132 # define MAX_PATH_LEN 1024 /* max pathname length */
135 #define seekable() 0 /* force sequential output */
136 #define translate_eol 0 /* no option -a yet */
141 #define INIT_BITS 9 /* Initial number of bits per code */
143 #define BIT_MASK 0x1f /* Mask for 'number of compression bits' */
144 /* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free.
145 * It's a pity that old uncompress does not check bit 0x20. That makes
146 * extension of the format actually undesirable because old compress
147 * would just crash on the new format instead of giving a meaningful
148 * error message. It does check the number of bits, but it's more
149 * helpful to say "unsupported format, get a new version" than
150 * "can only handle 16 bits".
154 # define MAX_SUFFIX MAX_EXT_CHARS
156 # define MAX_SUFFIX 30
160 /* ===========================================================================
161 * Compile with MEDIUM_MEM to reduce the memory requirements or
162 * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
163 * entire input file can be held in memory (not possible on 16 bit systems).
164 * Warning: defining these symbols affects HASH_BITS (see below) and thus
165 * affects the compression ratio. The compressed output
166 * is still correct, and might even be smaller in some cases.
170 # define HASH_BITS 13 /* Number of bits used to hash strings */
173 # define HASH_BITS 14
176 # define HASH_BITS 15
177 /* For portability to 16 bit machines, do not use values above 15. */
180 #define HASH_SIZE (unsigned)(1<<HASH_BITS)
181 #define HASH_MASK (HASH_SIZE-1)
182 #define WMASK (WSIZE-1)
183 /* HASH_SIZE and WSIZE must be powers of two */
185 # define TOO_FAR 4096
187 /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
190 /* ===========================================================================
191 * These types are not really 'char', 'short' and 'long'
194 typedef uint16_t ush;
195 typedef uint32_t ulg;
199 typedef unsigned IPos;
200 /* A Pos is an index in the character window. We use short instead of int to
201 * save space in the various tables. IPos is used only for parameter passing.
205 WINDOW_SIZE = 2 * WSIZE,
206 /* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
207 * input file length plus MIN_LOOKAHEAD.
210 max_chain_length = 4096,
211 /* To speed up deflation, hash chains are never searched beyond this length.
212 * A higher limit improves compression ratio but degrades the speed.
215 max_lazy_match = 258,
216 /* Attempt to find a better match only when the current match is strictly
217 * smaller than this value. This mechanism is used only for compression
221 max_insert_length = max_lazy_match,
222 /* Insert new strings in the hash table only if the match length
223 * is not greater than this length. This saves time but degrades compression.
224 * max_insert_length is used only for compression levels <= 3.
228 /* Use a faster search when the previous match is longer than this */
230 /* Values for max_lazy_match, good_match and max_chain_length, depending on
231 * the desired pack level (0..9). The values given below have been tuned to
232 * exclude worst case performance for pathological files. Better values may be
233 * found for specific files.
236 nice_match = 258, /* Stop searching when current match exceeds this */
237 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
238 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
248 /* window position at the beginning of the current output block. Gets
249 * negative when the window is moved backwards.
251 unsigned ins_h; /* hash index of string to be inserted */
253 #define H_SHIFT ((HASH_BITS+MIN_MATCH-1) / MIN_MATCH)
254 /* Number of bits by which ins_h and del_h must be shifted at each
255 * input step. It must be such that after MIN_MATCH steps, the oldest
256 * byte no longer takes part in the hash key, that is:
257 * H_SHIFT * MIN_MATCH >= HASH_BITS
260 unsigned prev_length;
262 /* Length of the best match at previous step. Matches not greater than this
263 * are discarded. This is used in the lazy match evaluation.
266 unsigned strstart; /* start of string to insert */
267 unsigned match_start; /* start of matching string */
268 unsigned lookahead; /* number of valid bytes ahead in window */
270 /* ===========================================================================
272 #define DECLARE(type, array, size) \
274 #define ALLOC(type, array, size) \
275 array = xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type));
276 #define FREE(array) \
277 do { free(array); array = NULL; } while (0)
281 /* buffer for literals or lengths */
282 /* DECLARE(uch, l_buf, LIT_BUFSIZE); */
283 DECLARE(uch, l_buf, INBUFSIZ);
285 DECLARE(ush, d_buf, DIST_BUFSIZE);
286 DECLARE(uch, outbuf, OUTBUFSIZ);
288 /* Sliding window. Input bytes are read into the second half of the window,
289 * and move to the first half later to keep a dictionary of at least WSIZE
290 * bytes. With this organization, matches are limited to a distance of
291 * WSIZE-MAX_MATCH bytes, but this ensures that IO is always
292 * performed with a length multiple of the block size. Also, it limits
293 * the window size to 64K, which is quite useful on MSDOS.
294 * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
295 * be less efficient).
297 DECLARE(uch, window, 2L * WSIZE);
299 /* Link to older string with same hash index. To limit the size of this
300 * array to 64K, this link is maintained only for the last 32K strings.
301 * An index in this array is thus a window index modulo 32K.
303 /* DECLARE(Pos, prev, WSIZE); */
304 DECLARE(ush, prev, 1L << BITS);
306 /* Heads of the hash chains or 0. */
307 /* DECLARE(Pos, head, 1<<HASH_BITS); */
308 #define head (G1.prev + WSIZE) /* hash head (see deflate.c) */
311 /* number of input bytes */
312 ulg isize; /* only 32 bits stored in .gz file */
314 //// int method = DEFLATED; /* compression method */
315 //## int exit_code; /* program exit code */
317 /* original time stamp (modification time) */
318 ulg time_stamp; /* only 32 bits stored in .gz file */
320 //TODO: get rid of this
321 int ifd; /* input file descriptor */
322 int ofd; /* output file descriptor */
324 unsigned insize; /* valid bytes in l_buf */
326 unsigned outcnt; /* bytes in output buffer */
328 smallint eofile; /* flag set at end of input file */
330 /* ===========================================================================
331 * Local data used by the "bit string" routines.
334 unsigned short bi_buf;
336 /* Output buffer. bits are inserted starting at the bottom (least significant
341 #define BUF_SIZE (8 * sizeof(G1.bi_buf))
342 /* Number of bits used within bi_buf. (bi_buf might be implemented on
343 * more than 16 bits on some systems.)
348 /* Current input function. Set to mem_read for in-memory compression */
351 ulg bits_sent; /* bit length of the compressed data */
354 uint32_t *crc_32_tab;
355 uint32_t crc; /* shift register contents */
358 extern struct global1 *ptr_to_globals;
359 #define G1 (*(ptr_to_globals - 1))
362 /* ===========================================================================
363 * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
364 * (used for the compressed data only)
366 static void flush_outbuf(void)
371 xwrite(G1.ofd, (char *) G1.outbuf, G1.outcnt);
376 /* ===========================================================================
378 /* put_8bit is used for the compressed output */
379 #define put_8bit(c) \
381 G1.outbuf[G1.outcnt++] = (c); \
382 if (G1.outcnt == OUTBUFSIZ) flush_outbuf(); \
385 /* Output a 16 bit value, lsb first */
386 static void put_16bit(ush w)
388 if (G1.outcnt < OUTBUFSIZ - 2) {
389 G1.outbuf[G1.outcnt++] = w;
390 G1.outbuf[G1.outcnt++] = w >> 8;
397 static void put_32bit(ulg n)
403 /* ===========================================================================
404 * Clear input and output buffers
406 static void clear_bufs(void)
416 /* ===========================================================================
417 * Run a set of bytes through the crc shift register. If s is a NULL
418 * pointer, then initialize the crc shift register contents instead.
419 * Return the current crc in either case.
421 static uint32_t updcrc(uch * s, unsigned n)
425 c = G1.crc_32_tab[(uch)(c ^ *s++)] ^ (c >> 8);
433 /* ===========================================================================
434 * Read a new buffer from the current input file, perform end-of-line
435 * translation, and update the crc and input file size.
436 * IN assertion: size >= 2 (for end-of-line translation)
438 static unsigned file_read(void *buf, unsigned size)
442 Assert(G1.insize == 0, "l_buf not empty");
444 len = safe_read(G1.ifd, buf, size);
445 if (len == (unsigned)(-1) || len == 0)
454 /* ===========================================================================
455 * Send a value on a given number of bits.
456 * IN assertion: length <= 16 and value fits in length bits.
458 static void send_bits(int value, int length)
461 Tracev((stderr, " l %2d v %4x ", length, value));
462 Assert(length > 0 && length <= 15, "invalid length");
463 G1.bits_sent += length;
465 /* If not enough room in bi_buf, use (valid) bits from bi_buf and
466 * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
467 * unused bits in value.
469 if (G1.bi_valid > (int) BUF_SIZE - length) {
470 G1.bi_buf |= (value << G1.bi_valid);
471 put_16bit(G1.bi_buf);
472 G1.bi_buf = (ush) value >> (BUF_SIZE - G1.bi_valid);
473 G1.bi_valid += length - BUF_SIZE;
475 G1.bi_buf |= value << G1.bi_valid;
476 G1.bi_valid += length;
481 /* ===========================================================================
482 * Reverse the first len bits of a code, using straightforward code (a faster
483 * method would use a table)
484 * IN assertion: 1 <= len <= 15
486 static unsigned bi_reverse(unsigned code, int len)
492 if (--len <= 0) return res;
499 /* ===========================================================================
500 * Write out any remaining bits in an incomplete byte.
502 static void bi_windup(void)
504 if (G1.bi_valid > 8) {
505 put_16bit(G1.bi_buf);
506 } else if (G1.bi_valid > 0) {
512 G1.bits_sent = (G1.bits_sent + 7) & ~7;
517 /* ===========================================================================
518 * Copy a stored block to the zip file, storing first the length and its
519 * one's complement if requested.
521 static void copy_block(char *buf, unsigned len, int header)
523 bi_windup(); /* align on byte boundary */
529 G1.bits_sent += 2 * 16;
533 G1.bits_sent += (ulg) len << 3;
541 /* ===========================================================================
542 * Fill the window when the lookahead becomes insufficient.
543 * Updates strstart and lookahead, and sets eofile if end of input file.
544 * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
545 * OUT assertions: at least one byte has been read, or eofile is set;
546 * file reads are performed for at least two bytes (required for the
547 * translate_eol option).
549 static void fill_window(void)
552 unsigned more = WINDOW_SIZE - G1.lookahead - G1.strstart;
553 /* Amount of free space at the end of the window. */
555 /* If the window is almost full and there is insufficient lookahead,
556 * move the upper half to the lower one to make room in the upper half.
558 if (more == (unsigned) -1) {
559 /* Very unlikely, but possible on 16 bit machine if strstart == 0
560 * and lookahead == 1 (input done one byte at time)
563 } else if (G1.strstart >= WSIZE + MAX_DIST) {
564 /* By the IN assertion, the window is not empty so we can't confuse
565 * more == 0 with more == 64K on a 16 bit machine.
567 Assert(WINDOW_SIZE == 2 * WSIZE, "no sliding with BIG_MEM");
569 memcpy(G1.window, G1.window + WSIZE, WSIZE);
570 G1.match_start -= WSIZE;
571 G1.strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */
573 G1.block_start -= WSIZE;
575 for (n = 0; n < HASH_SIZE; n++) {
577 head[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
579 for (n = 0; n < WSIZE; n++) {
581 G1.prev[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
582 /* If n is not on any hash chain, prev[n] is garbage but
583 * its value will never be used.
588 /* At this point, more >= 2 */
590 n = file_read(G1.window + G1.strstart + G1.lookahead, more);
591 if (n == 0 || n == (unsigned) -1) {
600 /* ===========================================================================
601 * Set match_start to the longest match starting at the given string and
602 * return its length. Matches shorter or equal to prev_length are discarded,
603 * in which case the result is equal to prev_length and match_start is
605 * IN assertions: cur_match is the head of the hash chain for the current
606 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
609 /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or
610 * match.s. The code is functionally equivalent, so you can use the C version
613 static int longest_match(IPos cur_match)
615 unsigned chain_length = max_chain_length; /* max hash chain length */
616 uch *scan = G1.window + G1.strstart; /* current string */
617 uch *match; /* matched string */
618 int len; /* length of current match */
619 int best_len = G1.prev_length; /* best match length so far */
620 IPos limit = G1.strstart > (IPos) MAX_DIST ? G1.strstart - (IPos) MAX_DIST : 0;
621 /* Stop when cur_match becomes <= limit. To simplify the code,
622 * we prevent matches with the string of window index 0.
625 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
626 * It is easy to get rid of this optimization if necessary.
628 #if HASH_BITS < 8 || MAX_MATCH != 258
629 # error Code too clever
631 uch *strend = G1.window + G1.strstart + MAX_MATCH;
632 uch scan_end1 = scan[best_len - 1];
633 uch scan_end = scan[best_len];
635 /* Do not waste too much time if we already have a good match: */
636 if (G1.prev_length >= good_match) {
639 Assert(G1.strstart <= WINDOW_SIZE - MIN_LOOKAHEAD, "insufficient lookahead");
642 Assert(cur_match < G1.strstart, "no future");
643 match = G1.window + cur_match;
645 /* Skip to next match if the match length cannot increase
646 * or if the match length is less than 2:
648 if (match[best_len] != scan_end ||
649 match[best_len - 1] != scan_end1 ||
650 *match != *scan || *++match != scan[1])
653 /* The check at best_len-1 can be removed because it will be made
654 * again later. (This heuristic is not always a win.)
655 * It is not necessary to compare scan[2] and match[2] since they
656 * are always equal when the other bytes match, given that
657 * the hash keys are equal and that HASH_BITS >= 8.
661 /* We check for insufficient lookahead only every 8th comparison;
662 * the 256th check will be made at strstart+258.
665 } while (*++scan == *++match && *++scan == *++match &&
666 *++scan == *++match && *++scan == *++match &&
667 *++scan == *++match && *++scan == *++match &&
668 *++scan == *++match && *++scan == *++match && scan < strend);
670 len = MAX_MATCH - (int) (strend - scan);
671 scan = strend - MAX_MATCH;
673 if (len > best_len) {
674 G1.match_start = cur_match;
676 if (len >= nice_match)
678 scan_end1 = scan[best_len - 1];
679 scan_end = scan[best_len];
681 } while ((cur_match = G1.prev[cur_match & WMASK]) > limit
682 && --chain_length != 0);
689 /* ===========================================================================
690 * Check that the match at match_start is indeed a match.
692 static void check_match(IPos start, IPos match, int length)
694 /* check that the match is indeed a match */
695 if (memcmp(G1.window + match, G1.window + start, length) != 0) {
696 bb_error_msg(" start %d, match %d, length %d", start, match, length);
697 bb_error_msg("invalid match");
700 bb_error_msg("\\[%d,%d]", start - match, length);
702 putc(G1.window[start++], stderr);
703 } while (--length != 0);
707 # define check_match(start, match, length) ((void)0)
711 /* trees.c -- output deflated data using Huffman coding
712 * Copyright (C) 1992-1993 Jean-loup Gailly
713 * This is free software; you can redistribute it and/or modify it under the
714 * terms of the GNU General Public License, see the file COPYING.
718 * Encode various sets of source values using variable-length
722 * The PKZIP "deflation" process uses several Huffman trees. The more
723 * common source values are represented by shorter bit sequences.
725 * Each code tree is stored in the ZIP file in a compressed form
726 * which is itself a Huffman encoding of the lengths of
727 * all the code strings (in ascending order by source values).
728 * The actual code strings are reconstructed from the lengths in
729 * the UNZIP process, as described in the "application note"
730 * (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
734 * Data Compression: Techniques and Applications, pp. 53-55.
735 * Lifetime Learning Publications, 1985. ISBN 0-534-03418-7.
738 * Data Compression: Methods and Theory, pp. 49-50.
739 * Computer Science Press, 1988. ISBN 0-7167-8156-5.
743 * Addison-Wesley, 1983. ISBN 0-201-06672-6.
746 * void ct_init() //// ush *attr, int *methodp)
747 * Allocate the match buffer, initialize the various tables and save
748 * the location of the internal file attribute (ascii/binary) and
749 * method (DEFLATE/STORE)
751 * void ct_tally(int dist, int lc);
752 * Save the match info and tally the frequency counts.
754 * ulg flush_block(char *buf, ulg stored_len, int eof)
755 * Determine the best encoding for the current block: dynamic trees,
756 * static trees or store, and output the encoded block to the zip
757 * file. Returns the total compressed length for the file so far.
761 /* All codes must not exceed MAX_BITS bits */
763 #define MAX_BL_BITS 7
764 /* Bit length codes must not exceed MAX_BL_BITS bits */
766 #define LENGTH_CODES 29
767 /* number of length codes, not counting the special END_BLOCK code */
770 /* number of literal bytes 0..255 */
772 #define END_BLOCK 256
773 /* end of block literal code */
775 #define L_CODES (LITERALS+1+LENGTH_CODES)
776 /* number of Literal or Length codes, including the END_BLOCK code */
779 /* number of distance codes */
782 /* number of codes used to transfer the bit lengths */
784 typedef uch extra_bits_t;
786 /* extra bits for each length code */
787 static const extra_bits_t extra_lbits[LENGTH_CODES]= {
788 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
792 /* extra bits for each distance code */
793 static const extra_bits_t extra_dbits[D_CODES] = {
794 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
795 10, 10, 11, 11, 12, 12, 13, 13
798 /* extra bits for each bit length code */
799 static const extra_bits_t extra_blbits[BL_CODES] = {
800 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
802 /* number of codes at each bit length for an optimal tree */
803 static const uch bl_order[BL_CODES] = {
804 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
806 #define STORED_BLOCK 0
807 #define STATIC_TREES 1
809 /* The three kinds of block type */
813 # define LIT_BUFSIZE 0x2000
816 # define LIT_BUFSIZE 0x4000
818 # define LIT_BUFSIZE 0x8000
823 # define DIST_BUFSIZE LIT_BUFSIZE
825 /* Sizes of match buffers for literals/lengths and distances. There are
826 * 4 reasons for limiting LIT_BUFSIZE to 64K:
827 * - frequencies can be kept in 16 bit counters
828 * - if compression is not successful for the first block, all input data is
829 * still in the window so we can still emit a stored block even when input
830 * comes from standard input. (This can also be done for all blocks if
831 * LIT_BUFSIZE is not greater than 32K.)
832 * - if compression is not successful for a file smaller than 64K, we can
833 * even emit a stored file instead of a stored block (saving 5 bytes).
834 * - creating new Huffman trees less frequently may not provide fast
835 * adaptation to changes in the input data statistics. (Take for
836 * example a binary file with poorly compressible code followed by
837 * a highly compressible string table.) Smaller buffer sizes give
838 * fast adaptation but have of course the overhead of transmitting trees
840 * - I can't count above 4
841 * The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
842 * memory at the expense of compression). Some optimizations would be possible
843 * if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
846 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
848 /* repeat a zero length 3-10 times (3 bits of repeat count) */
849 #define REPZ_11_138 18
850 /* repeat a zero length 11-138 times (7 bits of repeat count) */
852 /* ===========================================================================
854 /* Data structure describing a single value and its code string. */
855 typedef struct ct_data {
857 ush freq; /* frequency count */
858 ush code; /* bit string */
861 ush dad; /* father node in Huffman tree */
862 ush len; /* length of bit string */
871 #define HEAP_SIZE (2*L_CODES + 1)
872 /* maximum heap size */
874 typedef struct tree_desc {
875 ct_data *dyn_tree; /* the dynamic tree */
876 ct_data *static_tree; /* corresponding static tree or NULL */
877 const extra_bits_t *extra_bits; /* extra bits for each code or NULL */
878 int extra_base; /* base index for extra_bits */
879 int elems; /* max number of elements in the tree */
880 int max_length; /* max bit length for the codes */
881 int max_code; /* largest code with non zero frequency */
886 ush heap[HEAP_SIZE]; /* heap used to build the Huffman trees */
887 int heap_len; /* number of elements in the heap */
888 int heap_max; /* element of largest frequency */
890 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
891 * The same heap array is used to build all trees.
894 ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */
895 ct_data dyn_dtree[2 * D_CODES + 1]; /* distance tree */
897 ct_data static_ltree[L_CODES + 2];
899 /* The static literal tree. Since the bit lengths are imposed, there is no
900 * need for the L_CODES extra codes used during heap construction. However
901 * The codes 286 and 287 are needed to build a canonical tree (see ct_init
905 ct_data static_dtree[D_CODES];
907 /* The static distance tree. (Actually a trivial tree since all codes use
911 ct_data bl_tree[2 * BL_CODES + 1];
913 /* Huffman tree for the bit lengths */
919 ush bl_count[MAX_BITS + 1];
921 /* The lengths of the bit length codes are sent in order of decreasing
922 * probability, to avoid transmitting the lengths for unused bit length codes.
925 uch depth[2 * L_CODES + 1];
927 /* Depth of each subtree used as tie breaker for trees of equal frequency */
929 uch length_code[MAX_MATCH - MIN_MATCH + 1];
931 /* length code for each normalized match length (0 == MIN_MATCH) */
935 /* distance codes. The first 256 values correspond to the distances
936 * 3 .. 258, the last 256 values correspond to the top 8 bits of
937 * the 15 bit distances.
940 int base_length[LENGTH_CODES];
942 /* First normalized length for each code (0 = MIN_MATCH) */
944 int base_dist[D_CODES];
946 /* First normalized distance for each code (0 = distance of 1) */
948 uch flag_buf[LIT_BUFSIZE / 8];
950 /* flag_buf is a bit array distinguishing literals from lengths in
951 * l_buf, thus indicating the presence or absence of a distance.
954 unsigned last_lit; /* running index in l_buf */
955 unsigned last_dist; /* running index in d_buf */
956 unsigned last_flags; /* running index in flag_buf */
957 uch flags; /* current flags not yet saved in flag_buf */
958 uch flag_bit; /* current bit used in flags */
960 /* bits are filled in flags starting at bit 0 (least significant).
961 * Note: these flags are overkill in the current code since we don't
962 * take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
965 ulg opt_len; /* bit length of current block with optimal trees */
966 ulg static_len; /* bit length of current block with static trees */
968 ulg compressed_len; /* total bit length of compressed file */
970 //// ush *file_type; /* pointer to UNKNOWN, BINARY or ASCII */
971 //// int *file_method; /* pointer to DEFLATE or STORE */
975 #define G2ptr ((struct global2*)(ptr_to_globals))
979 /* ===========================================================================
981 static void gen_codes(ct_data * tree, int max_code);
982 static void build_tree(tree_desc * desc);
983 static void scan_tree(ct_data * tree, int max_code);
984 static void send_tree(ct_data * tree, int max_code);
985 static int build_bl_tree(void);
986 static void send_all_trees(int lcodes, int dcodes, int blcodes);
987 static void compress_block(ct_data * ltree, ct_data * dtree);
991 /* Send a code of the given tree. c and tree must not have side effects */
992 # define SEND_CODE(c, tree) send_bits(tree[c].Code, tree[c].Len)
994 # define SEND_CODE(c, tree) \
996 if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \
997 send_bits(tree[c].Code, tree[c].Len); \
1001 #define D_CODE(dist) \
1002 ((dist) < 256 ? G2.dist_code[dist] : G2.dist_code[256 + ((dist)>>7)])
1003 /* Mapping from a distance to a distance code. dist is the distance - 1 and
1004 * must not have side effects. dist_code[256] and dist_code[257] are never
1006 * The arguments must not have side effects.
1010 /* ===========================================================================
1011 * Initialize a new block.
1013 static void init_block(void)
1015 int n; /* iterates over tree elements */
1017 /* Initialize the trees. */
1018 for (n = 0; n < L_CODES; n++)
1019 G2.dyn_ltree[n].Freq = 0;
1020 for (n = 0; n < D_CODES; n++)
1021 G2.dyn_dtree[n].Freq = 0;
1022 for (n = 0; n < BL_CODES; n++)
1023 G2.bl_tree[n].Freq = 0;
1025 G2.dyn_ltree[END_BLOCK].Freq = 1;
1026 G2.opt_len = G2.static_len = 0;
1027 G2.last_lit = G2.last_dist = G2.last_flags = 0;
1033 /* ===========================================================================
1034 * Restore the heap property by moving down the tree starting at node k,
1035 * exchanging a node with the smallest of its two sons if necessary, stopping
1036 * when the heap property is re-established (each father smaller than its
1040 /* Compares to subtrees, using the tree depth as tie breaker when
1041 * the subtrees have equal frequency. This minimizes the worst case length. */
1042 #define SMALLER(tree, n, m) \
1043 (tree[n].Freq < tree[m].Freq \
1044 || (tree[n].Freq == tree[m].Freq && G2.depth[n] <= G2.depth[m]))
1046 static void pqdownheap(ct_data * tree, int k)
1049 int j = k << 1; /* left son of k */
1051 while (j <= G2.heap_len) {
1052 /* Set j to the smallest of the two sons: */
1053 if (j < G2.heap_len && SMALLER(tree, G2.heap[j + 1], G2.heap[j]))
1056 /* Exit if v is smaller than both sons */
1057 if (SMALLER(tree, v, G2.heap[j]))
1060 /* Exchange v with the smallest son */
1061 G2.heap[k] = G2.heap[j];
1064 /* And continue down the tree, setting j to the left son of k */
1071 /* ===========================================================================
1072 * Compute the optimal bit lengths for a tree and update the total bit length
1073 * for the current block.
1074 * IN assertion: the fields freq and dad are set, heap[heap_max] and
1075 * above are the tree nodes sorted by increasing frequency.
1076 * OUT assertions: the field len is set to the optimal bit length, the
1077 * array bl_count contains the frequencies for each bit length.
1078 * The length opt_len is updated; static_len is also updated if stree is
1081 static void gen_bitlen(tree_desc * desc)
1083 ct_data *tree = desc->dyn_tree;
1084 const extra_bits_t *extra = desc->extra_bits;
1085 int base = desc->extra_base;
1086 int max_code = desc->max_code;
1087 int max_length = desc->max_length;
1088 ct_data *stree = desc->static_tree;
1089 int h; /* heap index */
1090 int n, m; /* iterate over the tree elements */
1091 int bits; /* bit length */
1092 int xbits; /* extra bits */
1093 ush f; /* frequency */
1094 int overflow = 0; /* number of elements with bit length too large */
1096 for (bits = 0; bits <= MAX_BITS; bits++)
1097 G2.bl_count[bits] = 0;
1099 /* In a first pass, compute the optimal bit lengths (which may
1100 * overflow in the case of the bit length tree).
1102 tree[G2.heap[G2.heap_max]].Len = 0; /* root of the heap */
1104 for (h = G2.heap_max + 1; h < HEAP_SIZE; h++) {
1106 bits = tree[tree[n].Dad].Len + 1;
1107 if (bits > max_length) {
1111 tree[n].Len = (ush) bits;
1112 /* We overwrite tree[n].Dad which is no longer needed */
1115 continue; /* not a leaf node */
1117 G2.bl_count[bits]++;
1120 xbits = extra[n - base];
1122 G2.opt_len += (ulg) f *(bits + xbits);
1125 G2.static_len += (ulg) f * (stree[n].Len + xbits);
1130 Trace((stderr, "\nbit length overflow\n"));
1131 /* This happens for example on obj2 and pic of the Calgary corpus */
1133 /* Find the first bit length which could increase: */
1135 bits = max_length - 1;
1136 while (G2.bl_count[bits] == 0)
1138 G2.bl_count[bits]--; /* move one leaf down the tree */
1139 G2.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
1140 G2.bl_count[max_length]--;
1141 /* The brother of the overflow item also moves one step up,
1142 * but this does not affect bl_count[max_length]
1145 } while (overflow > 0);
1147 /* Now recompute all bit lengths, scanning in increasing frequency.
1148 * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
1149 * lengths instead of fixing only the wrong ones. This idea is taken
1150 * from 'ar' written by Haruhiko Okumura.)
1152 for (bits = max_length; bits != 0; bits--) {
1153 n = G2.bl_count[bits];
1158 if (tree[m].Len != (unsigned) bits) {
1159 Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits));
1160 G2.opt_len += ((int32_t) bits - tree[m].Len) * tree[m].Freq;
1169 /* ===========================================================================
1170 * Generate the codes for a given tree and bit counts (which need not be
1172 * IN assertion: the array bl_count contains the bit length statistics for
1173 * the given tree and the field len is set for all tree elements.
1174 * OUT assertion: the field code is set for all tree elements of non
1177 static void gen_codes(ct_data * tree, int max_code)
1179 ush next_code[MAX_BITS + 1]; /* next code value for each bit length */
1180 ush code = 0; /* running code value */
1181 int bits; /* bit index */
1182 int n; /* code index */
1184 /* The distribution counts are first used to generate the code values
1185 * without bit reversal.
1187 for (bits = 1; bits <= MAX_BITS; bits++) {
1188 next_code[bits] = code = (code + G2.bl_count[bits - 1]) << 1;
1190 /* Check that the bit counts in bl_count are consistent. The last code
1193 Assert(code + G2.bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
1194 "inconsistent bit counts");
1195 Tracev((stderr, "\ngen_codes: max_code %d ", max_code));
1197 for (n = 0; n <= max_code; n++) {
1198 int len = tree[n].Len;
1202 /* Now reverse the bits */
1203 tree[n].Code = bi_reverse(next_code[len]++, len);
1205 Tracec(tree != G2.static_ltree,
1206 (stderr, "\nn %3d %c l %2d c %4x (%x) ", n,
1207 (isgraph(n) ? n : ' '), len, tree[n].Code,
1208 next_code[len] - 1));
1213 /* ===========================================================================
1214 * Construct one Huffman tree and assigns the code bit strings and lengths.
1215 * Update the total bit length for the current block.
1216 * IN assertion: the field freq is set for all tree elements.
1217 * OUT assertions: the fields len and code are set to the optimal bit length
1218 * and corresponding code. The length opt_len is updated; static_len is
1219 * also updated if stree is not null. The field max_code is set.
1222 /* Remove the smallest element from the heap and recreate the heap with
1223 * one less element. Updates heap and heap_len. */
1226 /* Index within the heap array of least frequent node in the Huffman tree */
1228 #define PQREMOVE(tree, top) \
1230 top = G2.heap[SMALLEST]; \
1231 G2.heap[SMALLEST] = G2.heap[G2.heap_len--]; \
1232 pqdownheap(tree, SMALLEST); \
1235 static void build_tree(tree_desc * desc)
1237 ct_data *tree = desc->dyn_tree;
1238 ct_data *stree = desc->static_tree;
1239 int elems = desc->elems;
1240 int n, m; /* iterate over heap elements */
1241 int max_code = -1; /* largest code with non zero frequency */
1242 int node = elems; /* next internal node of the tree */
1244 /* Construct the initial heap, with least frequent element in
1245 * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
1246 * heap[0] is not used.
1249 G2.heap_max = HEAP_SIZE;
1251 for (n = 0; n < elems; n++) {
1252 if (tree[n].Freq != 0) {
1253 G2.heap[++G2.heap_len] = max_code = n;
1260 /* The pkzip format requires that at least one distance code exists,
1261 * and that at least one bit should be sent even if there is only one
1262 * possible code. So to avoid special checks later on we force at least
1263 * two codes of non zero frequency.
1265 while (G2.heap_len < 2) {
1266 int new = G2.heap[++G2.heap_len] = (max_code < 2 ? ++max_code : 0);
1272 G2.static_len -= stree[new].Len;
1273 /* new is 0 or 1 so it does not have extra bits */
1275 desc->max_code = max_code;
1277 /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
1278 * establish sub-heaps of increasing lengths:
1280 for (n = G2.heap_len / 2; n >= 1; n--)
1281 pqdownheap(tree, n);
1283 /* Construct the Huffman tree by repeatedly combining the least two
1287 PQREMOVE(tree, n); /* n = node of least frequency */
1288 m = G2.heap[SMALLEST]; /* m = node of next least frequency */
1290 G2.heap[--G2.heap_max] = n; /* keep the nodes sorted by frequency */
1291 G2.heap[--G2.heap_max] = m;
1293 /* Create a new node father of n and m */
1294 tree[node].Freq = tree[n].Freq + tree[m].Freq;
1295 G2.depth[node] = MAX(G2.depth[n], G2.depth[m]) + 1;
1296 tree[n].Dad = tree[m].Dad = (ush) node;
1298 if (tree == G2.bl_tree) {
1299 bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)",
1300 node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
1303 /* and insert the new node in the heap */
1304 G2.heap[SMALLEST] = node++;
1305 pqdownheap(tree, SMALLEST);
1307 } while (G2.heap_len >= 2);
1309 G2.heap[--G2.heap_max] = G2.heap[SMALLEST];
1311 /* At this point, the fields freq and dad are set. We can now
1312 * generate the bit lengths.
1314 gen_bitlen((tree_desc *) desc);
1316 /* The field len is now set, we can generate the bit codes */
1317 gen_codes((ct_data *) tree, max_code);
1321 /* ===========================================================================
1322 * Scan a literal or distance tree to determine the frequencies of the codes
1323 * in the bit length tree. Updates opt_len to take into account the repeat
1324 * counts. (The contribution of the bit length codes will be added later
1325 * during the construction of bl_tree.)
1327 static void scan_tree(ct_data * tree, int max_code)
1329 int n; /* iterates over all tree elements */
1330 int prevlen = -1; /* last emitted length */
1331 int curlen; /* length of current code */
1332 int nextlen = tree[0].Len; /* length of next code */
1333 int count = 0; /* repeat count of the current code */
1334 int max_count = 7; /* max repeat count */
1335 int min_count = 4; /* min repeat count */
1341 tree[max_code + 1].Len = 0xffff; /* guard */
1343 for (n = 0; n <= max_code; n++) {
1345 nextlen = tree[n + 1].Len;
1346 if (++count < max_count && curlen == nextlen)
1349 if (count < min_count) {
1350 G2.bl_tree[curlen].Freq += count;
1351 } else if (curlen != 0) {
1352 if (curlen != prevlen)
1353 G2.bl_tree[curlen].Freq++;
1354 G2.bl_tree[REP_3_6].Freq++;
1355 } else if (count <= 10) {
1356 G2.bl_tree[REPZ_3_10].Freq++;
1358 G2.bl_tree[REPZ_11_138].Freq++;
1368 } else if (curlen == nextlen) {
1376 /* ===========================================================================
1377 * Send a literal or distance tree in compressed form, using the codes in
1380 static void send_tree(ct_data * tree, int max_code)
1382 int n; /* iterates over all tree elements */
1383 int prevlen = -1; /* last emitted length */
1384 int curlen; /* length of current code */
1385 int nextlen = tree[0].Len; /* length of next code */
1386 int count = 0; /* repeat count of the current code */
1387 int max_count = 7; /* max repeat count */
1388 int min_count = 4; /* min repeat count */
1390 /* tree[max_code+1].Len = -1; *//* guard already set */
1392 max_count = 138, min_count = 3;
1394 for (n = 0; n <= max_code; n++) {
1396 nextlen = tree[n + 1].Len;
1397 if (++count < max_count && curlen == nextlen) {
1399 } else if (count < min_count) {
1401 SEND_CODE(curlen, G2.bl_tree);
1403 } else if (curlen != 0) {
1404 if (curlen != prevlen) {
1405 SEND_CODE(curlen, G2.bl_tree);
1408 Assert(count >= 3 && count <= 6, " 3_6?");
1409 SEND_CODE(REP_3_6, G2.bl_tree);
1410 send_bits(count - 3, 2);
1411 } else if (count <= 10) {
1412 SEND_CODE(REPZ_3_10, G2.bl_tree);
1413 send_bits(count - 3, 3);
1415 SEND_CODE(REPZ_11_138, G2.bl_tree);
1416 send_bits(count - 11, 7);
1423 } else if (curlen == nextlen) {
1434 /* ===========================================================================
1435 * Construct the Huffman tree for the bit lengths and return the index in
1436 * bl_order of the last bit length code to send.
1438 static int build_bl_tree(void)
1440 int max_blindex; /* index of last bit length code of non zero freq */
1442 /* Determine the bit length frequencies for literal and distance trees */
1443 scan_tree(G2.dyn_ltree, G2.l_desc.max_code);
1444 scan_tree(G2.dyn_dtree, G2.d_desc.max_code);
1446 /* Build the bit length tree: */
1447 build_tree(&G2.bl_desc);
1448 /* opt_len now includes the length of the tree representations, except
1449 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
1452 /* Determine the number of bit length codes to send. The pkzip format
1453 * requires that at least 4 bit length codes be sent. (appnote.txt says
1454 * 3 but the actual value used is 4.)
1456 for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
1457 if (G2.bl_tree[bl_order[max_blindex]].Len != 0)
1460 /* Update opt_len to include the bit length tree and counts */
1461 G2.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
1462 Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", G2.opt_len, G2.static_len));
1468 /* ===========================================================================
1469 * Send the header for a block using dynamic Huffman trees: the counts, the
1470 * lengths of the bit length codes, the literal tree and the distance tree.
1471 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
1473 static void send_all_trees(int lcodes, int dcodes, int blcodes)
1475 int rank; /* index in bl_order */
1477 Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
1478 Assert(lcodes <= L_CODES && dcodes <= D_CODES
1479 && blcodes <= BL_CODES, "too many codes");
1480 Tracev((stderr, "\nbl counts: "));
1481 send_bits(lcodes - 257, 5); /* not +255 as stated in appnote.txt */
1482 send_bits(dcodes - 1, 5);
1483 send_bits(blcodes - 4, 4); /* not -3 as stated in appnote.txt */
1484 for (rank = 0; rank < blcodes; rank++) {
1485 Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
1486 send_bits(G2.bl_tree[bl_order[rank]].Len, 3);
1488 Tracev((stderr, "\nbl tree: sent %ld", G1.bits_sent));
1490 send_tree((ct_data *) G2.dyn_ltree, lcodes - 1); /* send the literal tree */
1491 Tracev((stderr, "\nlit tree: sent %ld", G1.bits_sent));
1493 send_tree((ct_data *) G2.dyn_dtree, dcodes - 1); /* send the distance tree */
1494 Tracev((stderr, "\ndist tree: sent %ld", G1.bits_sent));
1498 /////* ===========================================================================
1499 //// * Set the file type to ASCII or BINARY, using a crude approximation:
1500 //// * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
1501 //// * IN assertion: the fields freq of dyn_ltree are set and the total of all
1502 //// * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
1504 ////static void set_file_type(void)
1507 //// unsigned ascii_freq = 0;
1508 //// unsigned bin_freq = 0;
1511 //// bin_freq += G2.dyn_ltree[n++].Freq;
1512 //// while (n < 128)
1513 //// ascii_freq += G2.dyn_ltree[n++].Freq;
1514 //// while (n < LITERALS)
1515 //// bin_freq += G2.dyn_ltree[n++].Freq;
1516 //// *G2.file_type = (bin_freq > (ascii_freq >> 2)) ? BINARY : ASCII;
1517 //// if (*G2.file_type == BINARY && translate_eol) {
1518 //// bb_error_msg("-l used on binary file");
1523 /* ===========================================================================
1524 * Save the match info and tally the frequency counts. Return true if
1525 * the current block must be flushed.
1527 static int ct_tally(int dist, int lc)
1529 G1.l_buf[G2.last_lit++] = lc;
1531 /* lc is the unmatched char */
1532 G2.dyn_ltree[lc].Freq++;
1534 /* Here, lc is the match length - MIN_MATCH */
1535 dist--; /* dist = match distance - 1 */
1536 Assert((ush) dist < (ush) MAX_DIST
1537 && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH)
1538 && (ush) D_CODE(dist) < (ush) D_CODES, "ct_tally: bad match"
1541 G2.dyn_ltree[G2.length_code[lc] + LITERALS + 1].Freq++;
1542 G2.dyn_dtree[D_CODE(dist)].Freq++;
1544 G1.d_buf[G2.last_dist++] = dist;
1545 G2.flags |= G2.flag_bit;
1549 /* Output the flags if they fill a byte: */
1550 if ((G2.last_lit & 7) == 0) {
1551 G2.flag_buf[G2.last_flags++] = G2.flags;
1555 /* Try to guess if it is profitable to stop the current block here */
1556 if ((G2.last_lit & 0xfff) == 0) {
1557 /* Compute an upper bound for the compressed length */
1558 ulg out_length = G2.last_lit * 8L;
1559 ulg in_length = (ulg) G1.strstart - G1.block_start;
1562 for (dcode = 0; dcode < D_CODES; dcode++) {
1563 out_length += G2.dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]);
1567 "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
1568 G2.last_lit, G2.last_dist, in_length, out_length,
1569 100L - out_length * 100L / in_length));
1570 if (G2.last_dist < G2.last_lit / 2 && out_length < in_length / 2)
1573 return (G2.last_lit == LIT_BUFSIZE - 1 || G2.last_dist == DIST_BUFSIZE);
1574 /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
1575 * on 16 bit machines and because stored blocks are restricted to
1580 /* ===========================================================================
1581 * Send the block data compressed using the given Huffman trees
1583 static void compress_block(ct_data * ltree, ct_data * dtree)
1585 unsigned dist; /* distance of matched string */
1586 int lc; /* match length or unmatched char (if dist == 0) */
1587 unsigned lx = 0; /* running index in l_buf */
1588 unsigned dx = 0; /* running index in d_buf */
1589 unsigned fx = 0; /* running index in flag_buf */
1590 uch flag = 0; /* current flags */
1591 unsigned code; /* the code to send */
1592 int extra; /* number of extra bits to send */
1594 if (G2.last_lit != 0) do {
1596 flag = G2.flag_buf[fx++];
1597 lc = G1.l_buf[lx++];
1598 if ((flag & 1) == 0) {
1599 SEND_CODE(lc, ltree); /* send a literal byte */
1600 Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
1602 /* Here, lc is the match length - MIN_MATCH */
1603 code = G2.length_code[lc];
1604 SEND_CODE(code + LITERALS + 1, ltree); /* send the length code */
1605 extra = extra_lbits[code];
1607 lc -= G2.base_length[code];
1608 send_bits(lc, extra); /* send the extra length bits */
1610 dist = G1.d_buf[dx++];
1611 /* Here, dist is the match distance - 1 */
1612 code = D_CODE(dist);
1613 Assert(code < D_CODES, "bad d_code");
1615 SEND_CODE(code, dtree); /* send the distance code */
1616 extra = extra_dbits[code];
1618 dist -= G2.base_dist[code];
1619 send_bits(dist, extra); /* send the extra distance bits */
1621 } /* literal or match pair ? */
1623 } while (lx < G2.last_lit);
1625 SEND_CODE(END_BLOCK, ltree);
1629 /* ===========================================================================
1630 * Determine the best encoding for the current block: dynamic trees, static
1631 * trees or store, and output the encoded block to the zip file. This function
1632 * returns the total compressed length for the file so far.
1634 static ulg flush_block(char *buf, ulg stored_len, int eof)
1636 ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
1637 int max_blindex; /* index of last bit length code of non zero freq */
1639 G2.flag_buf[G2.last_flags] = G2.flags; /* Save the flags for the last 8 items */
1641 //// /* Check if the file is ascii or binary */
1642 //// if (*G2.file_type == (ush) UNKNOWN)
1643 //// set_file_type();
1645 /* Construct the literal and distance trees */
1646 build_tree(&G2.l_desc);
1647 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", G2.opt_len, G2.static_len));
1649 build_tree(&G2.d_desc);
1650 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", G2.opt_len, G2.static_len));
1651 /* At this point, opt_len and static_len are the total bit lengths of
1652 * the compressed block data, excluding the tree representations.
1655 /* Build the bit length tree for the above two trees, and get the index
1656 * in bl_order of the last bit length code to send.
1658 max_blindex = build_bl_tree();
1660 /* Determine the best encoding. Compute first the block length in bytes */
1661 opt_lenb = (G2.opt_len + 3 + 7) >> 3;
1662 static_lenb = (G2.static_len + 3 + 7) >> 3;
1665 "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
1666 opt_lenb, G2.opt_len, static_lenb, G2.static_len, stored_len,
1667 G2.last_lit, G2.last_dist));
1669 if (static_lenb <= opt_lenb)
1670 opt_lenb = static_lenb;
1672 /* If compression failed and this is the first and last block,
1673 * and if the zip file can be seeked (to rewrite the local header),
1674 * the whole file is transformed into a stored file:
1676 if (stored_len <= opt_lenb && eof && G2.compressed_len == 0L && seekable()) {
1677 /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
1679 bb_error_msg("block vanished");
1681 copy_block(buf, (unsigned) stored_len, 0); /* without header */
1682 G2.compressed_len = stored_len << 3;
1683 //// *file_method = STORED;
1685 } else if (stored_len + 4 <= opt_lenb && buf != NULL) {
1686 /* 4: two words for the lengths */
1687 /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
1688 * Otherwise we can't have processed more than WSIZE input bytes since
1689 * the last block flush, because compression would have been
1690 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
1691 * transform a block into a stored block.
1693 send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */
1694 G2.compressed_len = (G2.compressed_len + 3 + 7) & ~7L;
1695 G2.compressed_len += (stored_len + 4) << 3;
1697 copy_block(buf, (unsigned) stored_len, 1); /* with header */
1699 } else if (static_lenb == opt_lenb) {
1700 send_bits((STATIC_TREES << 1) + eof, 3);
1701 compress_block((ct_data *) G2.static_ltree, (ct_data *) G2.static_dtree);
1702 G2.compressed_len += 3 + G2.static_len;
1704 send_bits((DYN_TREES << 1) + eof, 3);
1705 send_all_trees(G2.l_desc.max_code + 1, G2.d_desc.max_code + 1,
1707 compress_block((ct_data *) G2.dyn_ltree, (ct_data *) G2.dyn_dtree);
1708 G2.compressed_len += 3 + G2.opt_len;
1710 Assert(G2.compressed_len == G1.bits_sent, "bad compressed size");
1715 G2.compressed_len += 7; /* align on byte boundary */
1717 Tracev((stderr, "\ncomprlen %lu(%lu) ", G2.compressed_len >> 3,
1718 G2.compressed_len - 7 * eof));
1720 return G2.compressed_len >> 3;
1724 /* ===========================================================================
1725 * Update a hash value with the given input byte
1726 * IN assertion: all calls to to UPDATE_HASH are made with consecutive
1727 * input characters, so that a running hash key can be computed from the
1728 * previous key instead of complete recalculation each time.
1730 #define UPDATE_HASH(h, c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
1733 /* ===========================================================================
1734 * Same as above, but achieves better compression. We use a lazy
1735 * evaluation for matches: a match is finally adopted only if there is
1736 * no better match at the next window position.
1738 * Processes a new input file and return its compressed length. Sets
1739 * the compressed length, crc, deflate flags and internal file
1743 /* Flush the current block, with given end-of-file flag.
1744 * IN assertion: strstart is set to the end of the current match. */
1745 #define FLUSH_BLOCK(eof) \
1747 G1.block_start >= 0L \
1748 ? (char*)&G1.window[(unsigned)G1.block_start] \
1750 (ulg)G1.strstart - G1.block_start, \
1754 /* Insert string s in the dictionary and set match_head to the previous head
1755 * of the hash chain (the most recent string with same hash key). Return
1756 * the previous length of the hash chain.
1757 * IN assertion: all calls to to INSERT_STRING are made with consecutive
1758 * input characters and the first MIN_MATCH bytes of s are valid
1759 * (except for the last MIN_MATCH-1 bytes of the input file). */
1760 #define INSERT_STRING(s, match_head) \
1762 UPDATE_HASH(G1.ins_h, G1.window[(s) + MIN_MATCH-1]); \
1763 G1.prev[(s) & WMASK] = match_head = head[G1.ins_h]; \
1764 head[G1.ins_h] = (s); \
1767 static ulg deflate(void)
1769 IPos hash_head; /* head of hash chain */
1770 IPos prev_match; /* previous match */
1771 int flush; /* set if current block must be flushed */
1772 int match_available = 0; /* set if previous match exists */
1773 unsigned match_length = MIN_MATCH - 1; /* length of best match */
1775 /* Process the input block. */
1776 while (G1.lookahead != 0) {
1777 /* Insert the string window[strstart .. strstart+2] in the
1778 * dictionary, and set hash_head to the head of the hash chain:
1780 INSERT_STRING(G1.strstart, hash_head);
1782 /* Find the longest match, discarding those <= prev_length.
1784 G1.prev_length = match_length;
1785 prev_match = G1.match_start;
1786 match_length = MIN_MATCH - 1;
1788 if (hash_head != 0 && G1.prev_length < max_lazy_match
1789 && G1.strstart - hash_head <= MAX_DIST
1791 /* To simplify the code, we prevent matches with the string
1792 * of window index 0 (in particular we have to avoid a match
1793 * of the string with itself at the start of the input file).
1795 match_length = longest_match(hash_head);
1796 /* longest_match() sets match_start */
1797 if (match_length > G1.lookahead)
1798 match_length = G1.lookahead;
1800 /* Ignore a length 3 match if it is too distant: */
1801 if (match_length == MIN_MATCH && G1.strstart - G1.match_start > TOO_FAR) {
1802 /* If prev_match is also MIN_MATCH, G1.match_start is garbage
1803 * but we will ignore the current match anyway.
1808 /* If there was a match at the previous step and the current
1809 * match is not better, output the previous match:
1811 if (G1.prev_length >= MIN_MATCH && match_length <= G1.prev_length) {
1812 check_match(G1.strstart - 1, prev_match, G1.prev_length);
1813 flush = ct_tally(G1.strstart - 1 - prev_match, G1.prev_length - MIN_MATCH);
1815 /* Insert in hash table all strings up to the end of the match.
1816 * strstart-1 and strstart are already inserted.
1818 G1.lookahead -= G1.prev_length - 1;
1819 G1.prev_length -= 2;
1822 INSERT_STRING(G1.strstart, hash_head);
1823 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
1824 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
1825 * these bytes are garbage, but it does not matter since the
1826 * next lookahead bytes will always be emitted as literals.
1828 } while (--G1.prev_length != 0);
1829 match_available = 0;
1830 match_length = MIN_MATCH - 1;
1834 G1.block_start = G1.strstart;
1836 } else if (match_available) {
1837 /* If there was no match at the previous position, output a
1838 * single literal. If there was a match but the current match
1839 * is longer, truncate the previous match to a single literal.
1841 Tracevv((stderr, "%c", G1.window[G1.strstart - 1]));
1842 if (ct_tally(0, G1.window[G1.strstart - 1])) {
1844 G1.block_start = G1.strstart;
1849 /* There is no previous match to compare with, wait for
1850 * the next step to decide.
1852 match_available = 1;
1856 Assert(G1.strstart <= G1.isize && lookahead <= G1.isize, "a bit too far");
1858 /* Make sure that we always have enough lookahead, except
1859 * at the end of the input file. We need MAX_MATCH bytes
1860 * for the next match, plus MIN_MATCH bytes to insert the
1861 * string following the next match.
1863 while (G1.lookahead < MIN_LOOKAHEAD && !G1.eofile)
1866 if (match_available)
1867 ct_tally(0, G1.window[G1.strstart - 1]);
1869 return FLUSH_BLOCK(1); /* eof */
1873 /* ===========================================================================
1874 * Initialize the bit string routines.
1876 static void bi_init(void)
1886 /* ===========================================================================
1887 * Initialize the "longest match" routines for a new file
1889 static void lm_init(ush * flagsp)
1893 /* Initialize the hash table. */
1894 memset(head, 0, HASH_SIZE * sizeof(*head));
1895 /* prev will be initialized on the fly */
1897 /* speed options for the general purpose bit flag */
1898 *flagsp |= 2; /* FAST 4, SLOW 2 */
1899 /* ??? reduce max_chain_length for binary files */
1902 G1.block_start = 0L;
1904 G1.lookahead = file_read(G1.window,
1905 sizeof(int) <= 2 ? (unsigned) WSIZE : 2 * WSIZE);
1907 if (G1.lookahead == 0 || G1.lookahead == (unsigned) -1) {
1913 /* Make sure that we always have enough lookahead. This is important
1914 * if input comes from a device such as a tty.
1916 while (G1.lookahead < MIN_LOOKAHEAD && !G1.eofile)
1920 for (j = 0; j < MIN_MATCH - 1; j++)
1921 UPDATE_HASH(G1.ins_h, G1.window[j]);
1922 /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
1923 * not important since only literal bytes will be emitted.
1928 /* ===========================================================================
1929 * Allocate the match buffer, initialize the various tables and save the
1930 * location of the internal file attribute (ascii/binary) and method
1932 * One callsite in zip()
1934 static void ct_init(void) ////ush * attr, int *methodp)
1936 int n; /* iterates over tree elements */
1937 int length; /* length value */
1938 int code; /* code value */
1939 int dist; /* distance index */
1941 //// file_type = attr;
1942 //// file_method = methodp;
1943 G2.compressed_len = 0L;
1946 if (G2.static_dtree[0].Len != 0)
1947 return; /* ct_init already called */
1950 /* Initialize the mapping length (0..255) -> length code (0..28) */
1952 for (code = 0; code < LENGTH_CODES - 1; code++) {
1953 G2.base_length[code] = length;
1954 for (n = 0; n < (1 << extra_lbits[code]); n++) {
1955 G2.length_code[length++] = code;
1958 Assert(length == 256, "ct_init: length != 256");
1959 /* Note that the length 255 (match length 258) can be represented
1960 * in two different ways: code 284 + 5 bits or code 285, so we
1961 * overwrite length_code[255] to use the best encoding:
1963 G2.length_code[length - 1] = code;
1965 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
1967 for (code = 0; code < 16; code++) {
1968 G2.base_dist[code] = dist;
1969 for (n = 0; n < (1 << extra_dbits[code]); n++) {
1970 G2.dist_code[dist++] = code;
1973 Assert(dist == 256, "ct_init: dist != 256");
1974 dist >>= 7; /* from now on, all distances are divided by 128 */
1975 for (; code < D_CODES; code++) {
1976 G2.base_dist[code] = dist << 7;
1977 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
1978 G2.dist_code[256 + dist++] = code;
1981 Assert(dist == 256, "ct_init: 256+dist != 512");
1983 /* Construct the codes of the static literal tree */
1984 /* already zeroed - it's in bss
1985 for (n = 0; n <= MAX_BITS; n++)
1986 G2.bl_count[n] = 0; */
1990 G2.static_ltree[n++].Len = 8;
1994 G2.static_ltree[n++].Len = 9;
1998 G2.static_ltree[n++].Len = 7;
2002 G2.static_ltree[n++].Len = 8;
2005 /* Codes 286 and 287 do not exist, but we must include them in the
2006 * tree construction to get a canonical Huffman tree (longest code
2009 gen_codes((ct_data *) G2.static_ltree, L_CODES + 1);
2011 /* The static distance tree is trivial: */
2012 for (n = 0; n < D_CODES; n++) {
2013 G2.static_dtree[n].Len = 5;
2014 G2.static_dtree[n].Code = bi_reverse(n, 5);
2017 /* Initialize the first block of the first file: */
2022 /* ===========================================================================
2023 * Deflate in to out.
2024 * IN assertions: the input and output buffers are cleared.
2025 * The variables time_stamp and save_orig_name are initialized.
2028 /* put_header_byte is used for the compressed output
2029 * - for the initial 4 bytes that can't overflow the buffer. */
2030 #define put_header_byte(c) G1.outbuf[G1.outcnt++] = (c)
2032 static void zip(int in, int out)
2034 //// uch my_flags = 0; /* general purpose bit flags */
2035 //// ush attr = 0; /* ascii/binary flag */
2036 ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */
2037 //// int method = DEFLATED; /* compression method */
2043 /* Write the header to the gzip file. See algorithm.doc for the format */
2045 //put_header_byte(0x1f); /* magic header for gzip files, 1F 8B */
2046 //put_header_byte(0x8b);
2047 //////put_header_byte(DEFLATED); /* compression method */
2048 //put_header_byte(8); /* compression method */
2049 //put_header_byte(0); /* general flags */
2050 /* magic header for gzip files: 1F 8B */
2051 /* compression method: 8 */
2052 /* general flags: 0 */
2053 put_32bit(0x00088b1f);
2054 put_32bit(G1.time_stamp);
2056 /* Write deflated file to zip file */
2060 ct_init(); //// &attr, &method);
2061 lm_init(&deflate_flags);
2063 put_8bit(deflate_flags); /* extra flags */
2064 put_8bit(3); /* OS identifier = 3 (Unix) */
2068 /* Write the crc and uncompressed size */
2070 put_32bit(G1.isize);
2076 /* ======================================================================== */
2077 static void abort_gzip(int ATTRIBUTE_UNUSED ignored)
2082 int gzip_main(int argc, char **argv);
2083 int gzip_main(int argc, char **argv)
2094 struct stat statBuf;
2096 opt = getopt32(argc, argv, "cf123456789qv" USE_GUNZIP("d"));
2097 //if (opt & 0x1) // -c
2098 //if (opt & 0x2) // -f
2099 /* Ignore 1-9 (compression level) options */
2100 //if (opt & 0x4) // -1
2101 //if (opt & 0x8) // -2
2102 //if (opt & 0x10) // -3
2103 //if (opt & 0x20) // -4
2104 //if (opt & 0x40) // -5
2105 //if (opt & 0x80) // -6
2106 //if (opt & 0x100) // -7
2107 //if (opt & 0x200) // -8
2108 //if (opt & 0x400) // -9
2109 //if (opt & 0x800) // -q
2110 //if (opt & 0x1000) // -v
2111 #if ENABLE_GUNZIP /* gunzip_main may not be visible... */
2112 if (opt & 0x2000) { // -d
2113 /* FIXME: getopt32 should not depend on optind */
2115 return gunzip_main(argc, argv);
2120 if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
2121 signal(SIGINT, abort_gzip);
2124 if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
2125 signal(SIGTERM, abort_gzip);
2129 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
2130 signal(SIGHUP, abort_gzip);
2134 ptr_to_globals = xzalloc(sizeof(struct global1) + sizeof(struct global2));
2136 G2.l_desc.dyn_tree = G2.dyn_ltree;
2137 G2.l_desc.static_tree = G2.static_ltree;
2138 G2.l_desc.extra_bits = extra_lbits;
2139 G2.l_desc.extra_base = LITERALS + 1;
2140 G2.l_desc.elems = L_CODES;
2141 G2.l_desc.max_length = MAX_BITS;
2142 //G2.l_desc.max_code = 0;
2144 G2.d_desc.dyn_tree = G2.dyn_dtree;
2145 G2.d_desc.static_tree = G2.static_dtree;
2146 G2.d_desc.extra_bits = extra_dbits;
2147 //G2.d_desc.extra_base = 0;
2148 G2.d_desc.elems = D_CODES;
2149 G2.d_desc.max_length = MAX_BITS;
2150 //G2.d_desc.max_code = 0;
2152 G2.bl_desc.dyn_tree = G2.bl_tree;
2153 //G2.bl_desc.static_tree = NULL;
2154 G2.bl_desc.extra_bits = extra_blbits,
2155 //G2.bl_desc.extra_base = 0;
2156 G2.bl_desc.elems = BL_CODES;
2157 G2.bl_desc.max_length = MAX_BL_BITS;
2158 //G2.bl_desc.max_code = 0;
2160 /* Allocate all global buffers (for DYN_ALLOC option) */
2161 ALLOC(uch, G1.l_buf, INBUFSIZ);
2162 ALLOC(uch, G1.outbuf, OUTBUFSIZ);
2163 ALLOC(ush, G1.d_buf, DIST_BUFSIZE);
2164 ALLOC(uch, G1.window, 2L * WSIZE);
2165 ALLOC(ush, G1.prev, 1L << BITS);
2167 /* Initialise the CRC32 table */
2168 G1.crc_32_tab = crc32_filltable(0);
2172 if (optind == argc) {
2174 zip(STDIN_FILENO, STDOUT_FILENO);
2175 return 0; //## G1.exit_code;
2178 for (i = optind; i < argc; i++) {
2182 if (LONE_DASH(argv[i])) {
2184 inFileNum = STDIN_FILENO;
2185 outFileNum = STDOUT_FILENO;
2187 inFileNum = xopen(argv[i], O_RDONLY);
2188 if (fstat(inFileNum, &statBuf) < 0)
2189 bb_perror_msg_and_die("%s", argv[i]);
2190 G1.time_stamp = statBuf.st_ctime;
2192 if (!(opt & OPT_tostdout)) {
2193 path = xasprintf("%s.gz", argv[i]);
2195 /* Open output file */
2196 #if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 && defined(O_NOFOLLOW)
2197 outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW);
2199 outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL);
2201 if (outFileNum < 0) {
2202 bb_perror_msg("%s", path);
2207 /* Set permissions on the file */
2208 fchmod(outFileNum, statBuf.st_mode);
2210 outFileNum = STDOUT_FILENO;
2213 if (path == NULL && isatty(outFileNum) && !(opt & OPT_force)) {
2214 bb_error_msg("compressed data not written "
2215 "to a terminal. Use -f to force compression.");
2220 zip(inFileNum, outFileNum);
2228 /* Delete the original file */
2229 // Pity we don't propagate zip failures to this place...
2231 delFileName = argv[i];
2233 // delFileName = path;
2234 if (unlink(delFileName) < 0)
2235 bb_perror_msg("%s", delFileName);
2241 return 0; //##G1.exit_code;