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
43 #include "unarchive.h"
46 /* ===========================================================================
49 /* Diagnostic functions */
51 # define Assert(cond,msg) { if (!(cond)) bb_error_msg(msg); }
52 # define Trace(x) fprintf x
53 # define Tracev(x) {if (verbose) fprintf x; }
54 # define Tracevv(x) {if (verbose > 1) fprintf x; }
55 # define Tracec(c,x) {if (verbose && (c)) fprintf x; }
56 # define Tracecv(c,x) {if (verbose > 1 && (c)) fprintf x; }
58 # define Assert(cond,msg)
67 /* ===========================================================================
73 # define INBUFSIZ 0x2000 /* input buffer size */
75 # define INBUFSIZ 0x8000 /* input buffer size */
81 # define OUTBUFSIZ 8192 /* output buffer size */
83 # define OUTBUFSIZ 16384 /* output buffer size */
89 # define DIST_BUFSIZE 0x2000 /* buffer for distances, see trees.c */
91 # define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */
96 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
97 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
98 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
99 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
100 #define COMMENT 0x10 /* bit 4 set: file comment present */
101 #define RESERVED 0xC0 /* bit 6,7: reserved */
103 /* internal file attribute */
104 #define UNKNOWN 0xffff
109 # define WSIZE 0x8000 /* window size--must be a power of two, and */
110 #endif /* at least 32K for zip's deflate method */
113 #define MAX_MATCH 258
114 /* The minimum and maximum match lengths */
116 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
117 /* Minimum amount of lookahead, except at the end of the input file.
118 * See deflate.c for comments about the MIN_MATCH+1.
121 #define MAX_DIST (WSIZE-MIN_LOOKAHEAD)
122 /* In order to simplify the code, particularly on 16 bit machines, match
123 * distances are limited to MAX_DIST instead of WSIZE.
127 # define MAX_PATH_LEN 1024 /* max pathname length */
130 #define seekable() 0 /* force sequential output */
131 #define translate_eol 0 /* no option -a yet */
136 #define INIT_BITS 9 /* Initial number of bits per code */
138 #define BIT_MASK 0x1f /* Mask for 'number of compression bits' */
139 /* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free.
140 * It's a pity that old uncompress does not check bit 0x20. That makes
141 * extension of the format actually undesirable because old compress
142 * would just crash on the new format instead of giving a meaningful
143 * error message. It does check the number of bits, but it's more
144 * helpful to say "unsupported format, get a new version" than
145 * "can only handle 16 bits".
149 # define MAX_SUFFIX MAX_EXT_CHARS
151 # define MAX_SUFFIX 30
155 /* ===========================================================================
156 * Compile with MEDIUM_MEM to reduce the memory requirements or
157 * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
158 * entire input file can be held in memory (not possible on 16 bit systems).
159 * Warning: defining these symbols affects HASH_BITS (see below) and thus
160 * affects the compression ratio. The compressed output
161 * is still correct, and might even be smaller in some cases.
165 # define HASH_BITS 13 /* Number of bits used to hash strings */
168 # define HASH_BITS 14
171 # define HASH_BITS 15
172 /* For portability to 16 bit machines, do not use values above 15. */
175 #define HASH_SIZE (unsigned)(1<<HASH_BITS)
176 #define HASH_MASK (HASH_SIZE-1)
177 #define WMASK (WSIZE-1)
178 /* HASH_SIZE and WSIZE must be powers of two */
180 # define TOO_FAR 4096
182 /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
185 /* ===========================================================================
186 * These types are not really 'char', 'short' and 'long'
189 typedef uint16_t ush;
190 typedef uint32_t ulg;
194 typedef unsigned IPos;
195 /* A Pos is an index in the character window. We use short instead of int to
196 * save space in the various tables. IPos is used only for parameter passing.
200 WINDOW_SIZE = 2 * WSIZE,
201 /* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
202 * input file length plus MIN_LOOKAHEAD.
205 max_chain_length = 4096,
206 /* To speed up deflation, hash chains are never searched beyond this length.
207 * A higher limit improves compression ratio but degrades the speed.
210 max_lazy_match = 258,
211 /* Attempt to find a better match only when the current match is strictly
212 * smaller than this value. This mechanism is used only for compression
216 max_insert_length = max_lazy_match,
217 /* Insert new strings in the hash table only if the match length
218 * is not greater than this length. This saves time but degrades compression.
219 * max_insert_length is used only for compression levels <= 3.
223 /* Use a faster search when the previous match is longer than this */
225 /* Values for max_lazy_match, good_match and max_chain_length, depending on
226 * the desired pack level (0..9). The values given below have been tuned to
227 * exclude worst case performance for pathological files. Better values may be
228 * found for specific files.
231 nice_match = 258, /* Stop searching when current match exceeds this */
232 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
233 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
243 /* window position at the beginning of the current output block. Gets
244 * negative when the window is moved backwards.
246 unsigned ins_h; /* hash index of string to be inserted */
248 #define H_SHIFT ((HASH_BITS+MIN_MATCH-1) / MIN_MATCH)
249 /* Number of bits by which ins_h and del_h must be shifted at each
250 * input step. It must be such that after MIN_MATCH steps, the oldest
251 * byte no longer takes part in the hash key, that is:
252 * H_SHIFT * MIN_MATCH >= HASH_BITS
255 unsigned prev_length;
257 /* Length of the best match at previous step. Matches not greater than this
258 * are discarded. This is used in the lazy match evaluation.
261 unsigned strstart; /* start of string to insert */
262 unsigned match_start; /* start of matching string */
263 unsigned lookahead; /* number of valid bytes ahead in window */
265 /* ===========================================================================
267 #define DECLARE(type, array, size) \
269 #define ALLOC(type, array, size) \
270 array = xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type))
271 #define FREE(array) \
272 do { free(array); array = NULL; } while (0)
276 /* buffer for literals or lengths */
277 /* DECLARE(uch, l_buf, LIT_BUFSIZE); */
278 DECLARE(uch, l_buf, INBUFSIZ);
280 DECLARE(ush, d_buf, DIST_BUFSIZE);
281 DECLARE(uch, outbuf, OUTBUFSIZ);
283 /* Sliding window. Input bytes are read into the second half of the window,
284 * and move to the first half later to keep a dictionary of at least WSIZE
285 * bytes. With this organization, matches are limited to a distance of
286 * WSIZE-MAX_MATCH bytes, but this ensures that IO is always
287 * performed with a length multiple of the block size. Also, it limits
288 * the window size to 64K, which is quite useful on MSDOS.
289 * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
290 * be less efficient).
292 DECLARE(uch, window, 2L * WSIZE);
294 /* Link to older string with same hash index. To limit the size of this
295 * array to 64K, this link is maintained only for the last 32K strings.
296 * An index in this array is thus a window index modulo 32K.
298 /* DECLARE(Pos, prev, WSIZE); */
299 DECLARE(ush, prev, 1L << BITS);
301 /* Heads of the hash chains or 0. */
302 /* DECLARE(Pos, head, 1<<HASH_BITS); */
303 #define head (G1.prev + WSIZE) /* hash head (see deflate.c) */
305 /* number of input bytes */
306 ulg isize; /* only 32 bits stored in .gz file */
308 /* bbox always use stdin/stdout */
309 #define ifd STDIN_FILENO /* input file descriptor */
310 #define ofd STDOUT_FILENO /* output file descriptor */
313 unsigned insize; /* valid bytes in l_buf */
315 unsigned outcnt; /* bytes in output buffer */
317 smallint eofile; /* flag set at end of input file */
319 /* ===========================================================================
320 * Local data used by the "bit string" routines.
323 unsigned short bi_buf;
325 /* Output buffer. bits are inserted starting at the bottom (least significant
330 #define BUF_SIZE (8 * sizeof(G1.bi_buf))
331 /* Number of bits used within bi_buf. (bi_buf might be implemented on
332 * more than 16 bits on some systems.)
337 /* Current input function. Set to mem_read for in-memory compression */
340 ulg bits_sent; /* bit length of the compressed data */
343 uint32_t *crc_32_tab;
344 uint32_t crc; /* shift register contents */
347 #define G1 (*(ptr_to_globals - 1))
350 /* ===========================================================================
351 * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
352 * (used for the compressed data only)
354 static void flush_outbuf(void)
359 xwrite(ofd, (char *) G1.outbuf, G1.outcnt);
364 /* ===========================================================================
366 /* put_8bit is used for the compressed output */
367 #define put_8bit(c) \
369 G1.outbuf[G1.outcnt++] = (c); \
370 if (G1.outcnt == OUTBUFSIZ) flush_outbuf(); \
373 /* Output a 16 bit value, lsb first */
374 static void put_16bit(ush w)
376 if (G1.outcnt < OUTBUFSIZ - 2) {
377 G1.outbuf[G1.outcnt++] = w;
378 G1.outbuf[G1.outcnt++] = w >> 8;
385 static void put_32bit(ulg n)
391 /* ===========================================================================
392 * Run a set of bytes through the crc shift register. If s is a NULL
393 * pointer, then initialize the crc shift register contents instead.
394 * Return the current crc in either case.
396 static uint32_t updcrc(uch * s, unsigned n)
400 c = G1.crc_32_tab[(uch)(c ^ *s++)] ^ (c >> 8);
408 /* ===========================================================================
409 * Read a new buffer from the current input file, perform end-of-line
410 * translation, and update the crc and input file size.
411 * IN assertion: size >= 2 (for end-of-line translation)
413 static unsigned file_read(void *buf, unsigned size)
417 Assert(G1.insize == 0, "l_buf not empty");
419 len = safe_read(ifd, buf, size);
420 if (len == (unsigned)(-1) || len == 0)
429 /* ===========================================================================
430 * Send a value on a given number of bits.
431 * IN assertion: length <= 16 and value fits in length bits.
433 static void send_bits(int value, int length)
436 Tracev((stderr, " l %2d v %4x ", length, value));
437 Assert(length > 0 && length <= 15, "invalid length");
438 G1.bits_sent += length;
440 /* If not enough room in bi_buf, use (valid) bits from bi_buf and
441 * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
442 * unused bits in value.
444 if (G1.bi_valid > (int) BUF_SIZE - length) {
445 G1.bi_buf |= (value << G1.bi_valid);
446 put_16bit(G1.bi_buf);
447 G1.bi_buf = (ush) value >> (BUF_SIZE - G1.bi_valid);
448 G1.bi_valid += length - BUF_SIZE;
450 G1.bi_buf |= value << G1.bi_valid;
451 G1.bi_valid += length;
456 /* ===========================================================================
457 * Reverse the first len bits of a code, using straightforward code (a faster
458 * method would use a table)
459 * IN assertion: 1 <= len <= 15
461 static unsigned bi_reverse(unsigned code, int len)
467 if (--len <= 0) return res;
474 /* ===========================================================================
475 * Write out any remaining bits in an incomplete byte.
477 static void bi_windup(void)
479 if (G1.bi_valid > 8) {
480 put_16bit(G1.bi_buf);
481 } else if (G1.bi_valid > 0) {
487 G1.bits_sent = (G1.bits_sent + 7) & ~7;
492 /* ===========================================================================
493 * Copy a stored block to the zip file, storing first the length and its
494 * one's complement if requested.
496 static void copy_block(char *buf, unsigned len, int header)
498 bi_windup(); /* align on byte boundary */
504 G1.bits_sent += 2 * 16;
508 G1.bits_sent += (ulg) len << 3;
516 /* ===========================================================================
517 * Fill the window when the lookahead becomes insufficient.
518 * Updates strstart and lookahead, and sets eofile if end of input file.
519 * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
520 * OUT assertions: at least one byte has been read, or eofile is set;
521 * file reads are performed for at least two bytes (required for the
522 * translate_eol option).
524 static void fill_window(void)
527 unsigned more = WINDOW_SIZE - G1.lookahead - G1.strstart;
528 /* Amount of free space at the end of the window. */
530 /* If the window is almost full and there is insufficient lookahead,
531 * move the upper half to the lower one to make room in the upper half.
533 if (more == (unsigned) -1) {
534 /* Very unlikely, but possible on 16 bit machine if strstart == 0
535 * and lookahead == 1 (input done one byte at time)
538 } else if (G1.strstart >= WSIZE + MAX_DIST) {
539 /* By the IN assertion, the window is not empty so we can't confuse
540 * more == 0 with more == 64K on a 16 bit machine.
542 Assert(WINDOW_SIZE == 2 * WSIZE, "no sliding with BIG_MEM");
544 memcpy(G1.window, G1.window + WSIZE, WSIZE);
545 G1.match_start -= WSIZE;
546 G1.strstart -= WSIZE; /* we now have strstart >= MAX_DIST: */
548 G1.block_start -= WSIZE;
550 for (n = 0; n < HASH_SIZE; n++) {
552 head[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
554 for (n = 0; n < WSIZE; n++) {
556 G1.prev[n] = (Pos) (m >= WSIZE ? m - WSIZE : 0);
557 /* If n is not on any hash chain, prev[n] is garbage but
558 * its value will never be used.
563 /* At this point, more >= 2 */
565 n = file_read(G1.window + G1.strstart + G1.lookahead, more);
566 if (n == 0 || n == (unsigned) -1) {
575 /* ===========================================================================
576 * Set match_start to the longest match starting at the given string and
577 * return its length. Matches shorter or equal to prev_length are discarded,
578 * in which case the result is equal to prev_length and match_start is
580 * IN assertions: cur_match is the head of the hash chain for the current
581 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
584 /* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or
585 * match.s. The code is functionally equivalent, so you can use the C version
588 static int longest_match(IPos cur_match)
590 unsigned chain_length = max_chain_length; /* max hash chain length */
591 uch *scan = G1.window + G1.strstart; /* current string */
592 uch *match; /* matched string */
593 int len; /* length of current match */
594 int best_len = G1.prev_length; /* best match length so far */
595 IPos limit = G1.strstart > (IPos) MAX_DIST ? G1.strstart - (IPos) MAX_DIST : 0;
596 /* Stop when cur_match becomes <= limit. To simplify the code,
597 * we prevent matches with the string of window index 0.
600 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
601 * It is easy to get rid of this optimization if necessary.
603 #if HASH_BITS < 8 || MAX_MATCH != 258
604 # error Code too clever
606 uch *strend = G1.window + G1.strstart + MAX_MATCH;
607 uch scan_end1 = scan[best_len - 1];
608 uch scan_end = scan[best_len];
610 /* Do not waste too much time if we already have a good match: */
611 if (G1.prev_length >= good_match) {
614 Assert(G1.strstart <= WINDOW_SIZE - MIN_LOOKAHEAD, "insufficient lookahead");
617 Assert(cur_match < G1.strstart, "no future");
618 match = G1.window + cur_match;
620 /* Skip to next match if the match length cannot increase
621 * or if the match length is less than 2:
623 if (match[best_len] != scan_end ||
624 match[best_len - 1] != scan_end1 ||
625 *match != *scan || *++match != scan[1])
628 /* The check at best_len-1 can be removed because it will be made
629 * again later. (This heuristic is not always a win.)
630 * It is not necessary to compare scan[2] and match[2] since they
631 * are always equal when the other bytes match, given that
632 * the hash keys are equal and that HASH_BITS >= 8.
636 /* We check for insufficient lookahead only every 8th comparison;
637 * the 256th check will be made at strstart+258.
640 } while (*++scan == *++match && *++scan == *++match &&
641 *++scan == *++match && *++scan == *++match &&
642 *++scan == *++match && *++scan == *++match &&
643 *++scan == *++match && *++scan == *++match && scan < strend);
645 len = MAX_MATCH - (int) (strend - scan);
646 scan = strend - MAX_MATCH;
648 if (len > best_len) {
649 G1.match_start = cur_match;
651 if (len >= nice_match)
653 scan_end1 = scan[best_len - 1];
654 scan_end = scan[best_len];
656 } while ((cur_match = G1.prev[cur_match & WMASK]) > limit
657 && --chain_length != 0);
664 /* ===========================================================================
665 * Check that the match at match_start is indeed a match.
667 static void check_match(IPos start, IPos match, int length)
669 /* check that the match is indeed a match */
670 if (memcmp(G1.window + match, G1.window + start, length) != 0) {
671 bb_error_msg(" start %d, match %d, length %d", start, match, length);
672 bb_error_msg("invalid match");
675 bb_error_msg("\\[%d,%d]", start - match, length);
677 fputc(G1.window[start++], stderr);
678 } while (--length != 0);
682 # define check_match(start, match, length) ((void)0)
686 /* trees.c -- output deflated data using Huffman coding
687 * Copyright (C) 1992-1993 Jean-loup Gailly
688 * This is free software; you can redistribute it and/or modify it under the
689 * terms of the GNU General Public License, see the file COPYING.
693 * Encode various sets of source values using variable-length
697 * The PKZIP "deflation" process uses several Huffman trees. The more
698 * common source values are represented by shorter bit sequences.
700 * Each code tree is stored in the ZIP file in a compressed form
701 * which is itself a Huffman encoding of the lengths of
702 * all the code strings (in ascending order by source values).
703 * The actual code strings are reconstructed from the lengths in
704 * the UNZIP process, as described in the "application note"
705 * (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
709 * Data Compression: Techniques and Applications, pp. 53-55.
710 * Lifetime Learning Publications, 1985. ISBN 0-534-03418-7.
713 * Data Compression: Methods and Theory, pp. 49-50.
714 * Computer Science Press, 1988. ISBN 0-7167-8156-5.
718 * Addison-Wesley, 1983. ISBN 0-201-06672-6.
722 * Allocate the match buffer, initialize the various tables [and save
723 * the location of the internal file attribute (ascii/binary) and
724 * method (DEFLATE/STORE) -- deleted in bbox]
726 * void ct_tally(int dist, int lc);
727 * Save the match info and tally the frequency counts.
729 * ulg flush_block(char *buf, ulg stored_len, int eof)
730 * Determine the best encoding for the current block: dynamic trees,
731 * static trees or store, and output the encoded block to the zip
732 * file. Returns the total compressed length for the file so far.
736 /* All codes must not exceed MAX_BITS bits */
738 #define MAX_BL_BITS 7
739 /* Bit length codes must not exceed MAX_BL_BITS bits */
741 #define LENGTH_CODES 29
742 /* number of length codes, not counting the special END_BLOCK code */
745 /* number of literal bytes 0..255 */
747 #define END_BLOCK 256
748 /* end of block literal code */
750 #define L_CODES (LITERALS+1+LENGTH_CODES)
751 /* number of Literal or Length codes, including the END_BLOCK code */
754 /* number of distance codes */
757 /* number of codes used to transfer the bit lengths */
759 /* extra bits for each length code */
760 static const uint8_t extra_lbits[LENGTH_CODES] ALIGN1 = {
761 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
765 /* extra bits for each distance code */
766 static const uint8_t extra_dbits[D_CODES] ALIGN1 = {
767 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
768 10, 10, 11, 11, 12, 12, 13, 13
771 /* extra bits for each bit length code */
772 static const uint8_t extra_blbits[BL_CODES] ALIGN1 = {
773 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
775 /* number of codes at each bit length for an optimal tree */
776 static const uint8_t bl_order[BL_CODES] ALIGN1 = {
777 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
779 #define STORED_BLOCK 0
780 #define STATIC_TREES 1
782 /* The three kinds of block type */
786 # define LIT_BUFSIZE 0x2000
789 # define LIT_BUFSIZE 0x4000
791 # define LIT_BUFSIZE 0x8000
796 # define DIST_BUFSIZE LIT_BUFSIZE
798 /* Sizes of match buffers for literals/lengths and distances. There are
799 * 4 reasons for limiting LIT_BUFSIZE to 64K:
800 * - frequencies can be kept in 16 bit counters
801 * - if compression is not successful for the first block, all input data is
802 * still in the window so we can still emit a stored block even when input
803 * comes from standard input. (This can also be done for all blocks if
804 * LIT_BUFSIZE is not greater than 32K.)
805 * - if compression is not successful for a file smaller than 64K, we can
806 * even emit a stored file instead of a stored block (saving 5 bytes).
807 * - creating new Huffman trees less frequently may not provide fast
808 * adaptation to changes in the input data statistics. (Take for
809 * example a binary file with poorly compressible code followed by
810 * a highly compressible string table.) Smaller buffer sizes give
811 * fast adaptation but have of course the overhead of transmitting trees
813 * - I can't count above 4
814 * The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
815 * memory at the expense of compression). Some optimizations would be possible
816 * if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
819 /* repeat previous bit length 3-6 times (2 bits of repeat count) */
821 /* repeat a zero length 3-10 times (3 bits of repeat count) */
822 #define REPZ_11_138 18
823 /* repeat a zero length 11-138 times (7 bits of repeat count) */
825 /* ===========================================================================
827 /* Data structure describing a single value and its code string. */
828 typedef struct ct_data {
830 ush freq; /* frequency count */
831 ush code; /* bit string */
834 ush dad; /* father node in Huffman tree */
835 ush len; /* length of bit string */
844 #define HEAP_SIZE (2*L_CODES + 1)
845 /* maximum heap size */
847 typedef struct tree_desc {
848 ct_data *dyn_tree; /* the dynamic tree */
849 ct_data *static_tree; /* corresponding static tree or NULL */
850 const uint8_t *extra_bits; /* extra bits for each code or NULL */
851 int extra_base; /* base index for extra_bits */
852 int elems; /* max number of elements in the tree */
853 int max_length; /* max bit length for the codes */
854 int max_code; /* largest code with non zero frequency */
859 ush heap[HEAP_SIZE]; /* heap used to build the Huffman trees */
860 int heap_len; /* number of elements in the heap */
861 int heap_max; /* element of largest frequency */
863 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
864 * The same heap array is used to build all trees.
867 ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */
868 ct_data dyn_dtree[2 * D_CODES + 1]; /* distance tree */
870 ct_data static_ltree[L_CODES + 2];
872 /* The static literal tree. Since the bit lengths are imposed, there is no
873 * need for the L_CODES extra codes used during heap construction. However
874 * The codes 286 and 287 are needed to build a canonical tree (see ct_init
878 ct_data static_dtree[D_CODES];
880 /* The static distance tree. (Actually a trivial tree since all codes use
884 ct_data bl_tree[2 * BL_CODES + 1];
886 /* Huffman tree for the bit lengths */
892 ush bl_count[MAX_BITS + 1];
894 /* The lengths of the bit length codes are sent in order of decreasing
895 * probability, to avoid transmitting the lengths for unused bit length codes.
898 uch depth[2 * L_CODES + 1];
900 /* Depth of each subtree used as tie breaker for trees of equal frequency */
902 uch length_code[MAX_MATCH - MIN_MATCH + 1];
904 /* length code for each normalized match length (0 == MIN_MATCH) */
908 /* distance codes. The first 256 values correspond to the distances
909 * 3 .. 258, the last 256 values correspond to the top 8 bits of
910 * the 15 bit distances.
913 int base_length[LENGTH_CODES];
915 /* First normalized length for each code (0 = MIN_MATCH) */
917 int base_dist[D_CODES];
919 /* First normalized distance for each code (0 = distance of 1) */
921 uch flag_buf[LIT_BUFSIZE / 8];
923 /* flag_buf is a bit array distinguishing literals from lengths in
924 * l_buf, thus indicating the presence or absence of a distance.
927 unsigned last_lit; /* running index in l_buf */
928 unsigned last_dist; /* running index in d_buf */
929 unsigned last_flags; /* running index in flag_buf */
930 uch flags; /* current flags not yet saved in flag_buf */
931 uch flag_bit; /* current bit used in flags */
933 /* bits are filled in flags starting at bit 0 (least significant).
934 * Note: these flags are overkill in the current code since we don't
935 * take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
938 ulg opt_len; /* bit length of current block with optimal trees */
939 ulg static_len; /* bit length of current block with static trees */
941 ulg compressed_len; /* total bit length of compressed file */
944 #define G2ptr ((struct globals2*)(ptr_to_globals))
948 /* ===========================================================================
950 static void gen_codes(ct_data * tree, int max_code);
951 static void build_tree(tree_desc * desc);
952 static void scan_tree(ct_data * tree, int max_code);
953 static void send_tree(ct_data * tree, int max_code);
954 static int build_bl_tree(void);
955 static void send_all_trees(int lcodes, int dcodes, int blcodes);
956 static void compress_block(ct_data * ltree, ct_data * dtree);
960 /* Send a code of the given tree. c and tree must not have side effects */
961 # define SEND_CODE(c, tree) send_bits(tree[c].Code, tree[c].Len)
963 # define SEND_CODE(c, tree) \
965 if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \
966 send_bits(tree[c].Code, tree[c].Len); \
970 #define D_CODE(dist) \
971 ((dist) < 256 ? G2.dist_code[dist] : G2.dist_code[256 + ((dist)>>7)])
972 /* Mapping from a distance to a distance code. dist is the distance - 1 and
973 * must not have side effects. dist_code[256] and dist_code[257] are never
975 * The arguments must not have side effects.
979 /* ===========================================================================
980 * Initialize a new block.
982 static void init_block(void)
984 int n; /* iterates over tree elements */
986 /* Initialize the trees. */
987 for (n = 0; n < L_CODES; n++)
988 G2.dyn_ltree[n].Freq = 0;
989 for (n = 0; n < D_CODES; n++)
990 G2.dyn_dtree[n].Freq = 0;
991 for (n = 0; n < BL_CODES; n++)
992 G2.bl_tree[n].Freq = 0;
994 G2.dyn_ltree[END_BLOCK].Freq = 1;
995 G2.opt_len = G2.static_len = 0;
996 G2.last_lit = G2.last_dist = G2.last_flags = 0;
1002 /* ===========================================================================
1003 * Restore the heap property by moving down the tree starting at node k,
1004 * exchanging a node with the smallest of its two sons if necessary, stopping
1005 * when the heap property is re-established (each father smaller than its
1009 /* Compares to subtrees, using the tree depth as tie breaker when
1010 * the subtrees have equal frequency. This minimizes the worst case length. */
1011 #define SMALLER(tree, n, m) \
1012 (tree[n].Freq < tree[m].Freq \
1013 || (tree[n].Freq == tree[m].Freq && G2.depth[n] <= G2.depth[m]))
1015 static void pqdownheap(ct_data * tree, int k)
1018 int j = k << 1; /* left son of k */
1020 while (j <= G2.heap_len) {
1021 /* Set j to the smallest of the two sons: */
1022 if (j < G2.heap_len && SMALLER(tree, G2.heap[j + 1], G2.heap[j]))
1025 /* Exit if v is smaller than both sons */
1026 if (SMALLER(tree, v, G2.heap[j]))
1029 /* Exchange v with the smallest son */
1030 G2.heap[k] = G2.heap[j];
1033 /* And continue down the tree, setting j to the left son of k */
1040 /* ===========================================================================
1041 * Compute the optimal bit lengths for a tree and update the total bit length
1042 * for the current block.
1043 * IN assertion: the fields freq and dad are set, heap[heap_max] and
1044 * above are the tree nodes sorted by increasing frequency.
1045 * OUT assertions: the field len is set to the optimal bit length, the
1046 * array bl_count contains the frequencies for each bit length.
1047 * The length opt_len is updated; static_len is also updated if stree is
1050 static void gen_bitlen(tree_desc * desc)
1052 ct_data *tree = desc->dyn_tree;
1053 const uint8_t *extra = desc->extra_bits;
1054 int base = desc->extra_base;
1055 int max_code = desc->max_code;
1056 int max_length = desc->max_length;
1057 ct_data *stree = desc->static_tree;
1058 int h; /* heap index */
1059 int n, m; /* iterate over the tree elements */
1060 int bits; /* bit length */
1061 int xbits; /* extra bits */
1062 ush f; /* frequency */
1063 int overflow = 0; /* number of elements with bit length too large */
1065 for (bits = 0; bits <= MAX_BITS; bits++)
1066 G2.bl_count[bits] = 0;
1068 /* In a first pass, compute the optimal bit lengths (which may
1069 * overflow in the case of the bit length tree).
1071 tree[G2.heap[G2.heap_max]].Len = 0; /* root of the heap */
1073 for (h = G2.heap_max + 1; h < HEAP_SIZE; h++) {
1075 bits = tree[tree[n].Dad].Len + 1;
1076 if (bits > max_length) {
1080 tree[n].Len = (ush) bits;
1081 /* We overwrite tree[n].Dad which is no longer needed */
1084 continue; /* not a leaf node */
1086 G2.bl_count[bits]++;
1089 xbits = extra[n - base];
1091 G2.opt_len += (ulg) f *(bits + xbits);
1094 G2.static_len += (ulg) f * (stree[n].Len + xbits);
1099 Trace((stderr, "\nbit length overflow\n"));
1100 /* This happens for example on obj2 and pic of the Calgary corpus */
1102 /* Find the first bit length which could increase: */
1104 bits = max_length - 1;
1105 while (G2.bl_count[bits] == 0)
1107 G2.bl_count[bits]--; /* move one leaf down the tree */
1108 G2.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
1109 G2.bl_count[max_length]--;
1110 /* The brother of the overflow item also moves one step up,
1111 * but this does not affect bl_count[max_length]
1114 } while (overflow > 0);
1116 /* Now recompute all bit lengths, scanning in increasing frequency.
1117 * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
1118 * lengths instead of fixing only the wrong ones. This idea is taken
1119 * from 'ar' written by Haruhiko Okumura.)
1121 for (bits = max_length; bits != 0; bits--) {
1122 n = G2.bl_count[bits];
1127 if (tree[m].Len != (unsigned) bits) {
1128 Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits));
1129 G2.opt_len += ((int32_t) bits - tree[m].Len) * tree[m].Freq;
1138 /* ===========================================================================
1139 * Generate the codes for a given tree and bit counts (which need not be
1141 * IN assertion: the array bl_count contains the bit length statistics for
1142 * the given tree and the field len is set for all tree elements.
1143 * OUT assertion: the field code is set for all tree elements of non
1146 static void gen_codes(ct_data * tree, int max_code)
1148 ush next_code[MAX_BITS + 1]; /* next code value for each bit length */
1149 ush code = 0; /* running code value */
1150 int bits; /* bit index */
1151 int n; /* code index */
1153 /* The distribution counts are first used to generate the code values
1154 * without bit reversal.
1156 for (bits = 1; bits <= MAX_BITS; bits++) {
1157 next_code[bits] = code = (code + G2.bl_count[bits - 1]) << 1;
1159 /* Check that the bit counts in bl_count are consistent. The last code
1162 Assert(code + G2.bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
1163 "inconsistent bit counts");
1164 Tracev((stderr, "\ngen_codes: max_code %d ", max_code));
1166 for (n = 0; n <= max_code; n++) {
1167 int len = tree[n].Len;
1171 /* Now reverse the bits */
1172 tree[n].Code = bi_reverse(next_code[len]++, len);
1174 Tracec(tree != G2.static_ltree,
1175 (stderr, "\nn %3d %c l %2d c %4x (%x) ", n,
1176 (n > ' ' ? n : ' '), len, tree[n].Code,
1177 next_code[len] - 1));
1182 /* ===========================================================================
1183 * Construct one Huffman tree and assigns the code bit strings and lengths.
1184 * Update the total bit length for the current block.
1185 * IN assertion: the field freq is set for all tree elements.
1186 * OUT assertions: the fields len and code are set to the optimal bit length
1187 * and corresponding code. The length opt_len is updated; static_len is
1188 * also updated if stree is not null. The field max_code is set.
1191 /* Remove the smallest element from the heap and recreate the heap with
1192 * one less element. Updates heap and heap_len. */
1195 /* Index within the heap array of least frequent node in the Huffman tree */
1197 #define PQREMOVE(tree, top) \
1199 top = G2.heap[SMALLEST]; \
1200 G2.heap[SMALLEST] = G2.heap[G2.heap_len--]; \
1201 pqdownheap(tree, SMALLEST); \
1204 static void build_tree(tree_desc * desc)
1206 ct_data *tree = desc->dyn_tree;
1207 ct_data *stree = desc->static_tree;
1208 int elems = desc->elems;
1209 int n, m; /* iterate over heap elements */
1210 int max_code = -1; /* largest code with non zero frequency */
1211 int node = elems; /* next internal node of the tree */
1213 /* Construct the initial heap, with least frequent element in
1214 * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
1215 * heap[0] is not used.
1218 G2.heap_max = HEAP_SIZE;
1220 for (n = 0; n < elems; n++) {
1221 if (tree[n].Freq != 0) {
1222 G2.heap[++G2.heap_len] = max_code = n;
1229 /* The pkzip format requires that at least one distance code exists,
1230 * and that at least one bit should be sent even if there is only one
1231 * possible code. So to avoid special checks later on we force at least
1232 * two codes of non zero frequency.
1234 while (G2.heap_len < 2) {
1235 int new = G2.heap[++G2.heap_len] = (max_code < 2 ? ++max_code : 0);
1241 G2.static_len -= stree[new].Len;
1242 /* new is 0 or 1 so it does not have extra bits */
1244 desc->max_code = max_code;
1246 /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
1247 * establish sub-heaps of increasing lengths:
1249 for (n = G2.heap_len / 2; n >= 1; n--)
1250 pqdownheap(tree, n);
1252 /* Construct the Huffman tree by repeatedly combining the least two
1256 PQREMOVE(tree, n); /* n = node of least frequency */
1257 m = G2.heap[SMALLEST]; /* m = node of next least frequency */
1259 G2.heap[--G2.heap_max] = n; /* keep the nodes sorted by frequency */
1260 G2.heap[--G2.heap_max] = m;
1262 /* Create a new node father of n and m */
1263 tree[node].Freq = tree[n].Freq + tree[m].Freq;
1264 G2.depth[node] = MAX(G2.depth[n], G2.depth[m]) + 1;
1265 tree[n].Dad = tree[m].Dad = (ush) node;
1267 if (tree == G2.bl_tree) {
1268 bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)",
1269 node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
1272 /* and insert the new node in the heap */
1273 G2.heap[SMALLEST] = node++;
1274 pqdownheap(tree, SMALLEST);
1276 } while (G2.heap_len >= 2);
1278 G2.heap[--G2.heap_max] = G2.heap[SMALLEST];
1280 /* At this point, the fields freq and dad are set. We can now
1281 * generate the bit lengths.
1283 gen_bitlen((tree_desc *) desc);
1285 /* The field len is now set, we can generate the bit codes */
1286 gen_codes((ct_data *) tree, max_code);
1290 /* ===========================================================================
1291 * Scan a literal or distance tree to determine the frequencies of the codes
1292 * in the bit length tree. Updates opt_len to take into account the repeat
1293 * counts. (The contribution of the bit length codes will be added later
1294 * during the construction of bl_tree.)
1296 static void scan_tree(ct_data * tree, int max_code)
1298 int n; /* iterates over all tree elements */
1299 int prevlen = -1; /* last emitted length */
1300 int curlen; /* length of current code */
1301 int nextlen = tree[0].Len; /* length of next code */
1302 int count = 0; /* repeat count of the current code */
1303 int max_count = 7; /* max repeat count */
1304 int min_count = 4; /* min repeat count */
1310 tree[max_code + 1].Len = 0xffff; /* guard */
1312 for (n = 0; n <= max_code; n++) {
1314 nextlen = tree[n + 1].Len;
1315 if (++count < max_count && curlen == nextlen)
1318 if (count < min_count) {
1319 G2.bl_tree[curlen].Freq += count;
1320 } else if (curlen != 0) {
1321 if (curlen != prevlen)
1322 G2.bl_tree[curlen].Freq++;
1323 G2.bl_tree[REP_3_6].Freq++;
1324 } else if (count <= 10) {
1325 G2.bl_tree[REPZ_3_10].Freq++;
1327 G2.bl_tree[REPZ_11_138].Freq++;
1337 } else if (curlen == nextlen) {
1345 /* ===========================================================================
1346 * Send a literal or distance tree in compressed form, using the codes in
1349 static void send_tree(ct_data * tree, int max_code)
1351 int n; /* iterates over all tree elements */
1352 int prevlen = -1; /* last emitted length */
1353 int curlen; /* length of current code */
1354 int nextlen = tree[0].Len; /* length of next code */
1355 int count = 0; /* repeat count of the current code */
1356 int max_count = 7; /* max repeat count */
1357 int min_count = 4; /* min repeat count */
1359 /* tree[max_code+1].Len = -1; *//* guard already set */
1361 max_count = 138, min_count = 3;
1363 for (n = 0; n <= max_code; n++) {
1365 nextlen = tree[n + 1].Len;
1366 if (++count < max_count && curlen == nextlen) {
1368 } else if (count < min_count) {
1370 SEND_CODE(curlen, G2.bl_tree);
1372 } else if (curlen != 0) {
1373 if (curlen != prevlen) {
1374 SEND_CODE(curlen, G2.bl_tree);
1377 Assert(count >= 3 && count <= 6, " 3_6?");
1378 SEND_CODE(REP_3_6, G2.bl_tree);
1379 send_bits(count - 3, 2);
1380 } else if (count <= 10) {
1381 SEND_CODE(REPZ_3_10, G2.bl_tree);
1382 send_bits(count - 3, 3);
1384 SEND_CODE(REPZ_11_138, G2.bl_tree);
1385 send_bits(count - 11, 7);
1392 } else if (curlen == nextlen) {
1403 /* ===========================================================================
1404 * Construct the Huffman tree for the bit lengths and return the index in
1405 * bl_order of the last bit length code to send.
1407 static int build_bl_tree(void)
1409 int max_blindex; /* index of last bit length code of non zero freq */
1411 /* Determine the bit length frequencies for literal and distance trees */
1412 scan_tree(G2.dyn_ltree, G2.l_desc.max_code);
1413 scan_tree(G2.dyn_dtree, G2.d_desc.max_code);
1415 /* Build the bit length tree: */
1416 build_tree(&G2.bl_desc);
1417 /* opt_len now includes the length of the tree representations, except
1418 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
1421 /* Determine the number of bit length codes to send. The pkzip format
1422 * requires that at least 4 bit length codes be sent. (appnote.txt says
1423 * 3 but the actual value used is 4.)
1425 for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
1426 if (G2.bl_tree[bl_order[max_blindex]].Len != 0)
1429 /* Update opt_len to include the bit length tree and counts */
1430 G2.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
1431 Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", G2.opt_len, G2.static_len));
1437 /* ===========================================================================
1438 * Send the header for a block using dynamic Huffman trees: the counts, the
1439 * lengths of the bit length codes, the literal tree and the distance tree.
1440 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
1442 static void send_all_trees(int lcodes, int dcodes, int blcodes)
1444 int rank; /* index in bl_order */
1446 Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
1447 Assert(lcodes <= L_CODES && dcodes <= D_CODES
1448 && blcodes <= BL_CODES, "too many codes");
1449 Tracev((stderr, "\nbl counts: "));
1450 send_bits(lcodes - 257, 5); /* not +255 as stated in appnote.txt */
1451 send_bits(dcodes - 1, 5);
1452 send_bits(blcodes - 4, 4); /* not -3 as stated in appnote.txt */
1453 for (rank = 0; rank < blcodes; rank++) {
1454 Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
1455 send_bits(G2.bl_tree[bl_order[rank]].Len, 3);
1457 Tracev((stderr, "\nbl tree: sent %ld", G1.bits_sent));
1459 send_tree((ct_data *) G2.dyn_ltree, lcodes - 1); /* send the literal tree */
1460 Tracev((stderr, "\nlit tree: sent %ld", G1.bits_sent));
1462 send_tree((ct_data *) G2.dyn_dtree, dcodes - 1); /* send the distance tree */
1463 Tracev((stderr, "\ndist tree: sent %ld", G1.bits_sent));
1467 /* ===========================================================================
1468 * Save the match info and tally the frequency counts. Return true if
1469 * the current block must be flushed.
1471 static int ct_tally(int dist, int lc)
1473 G1.l_buf[G2.last_lit++] = lc;
1475 /* lc is the unmatched char */
1476 G2.dyn_ltree[lc].Freq++;
1478 /* Here, lc is the match length - MIN_MATCH */
1479 dist--; /* dist = match distance - 1 */
1480 Assert((ush) dist < (ush) MAX_DIST
1481 && (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH)
1482 && (ush) D_CODE(dist) < (ush) D_CODES, "ct_tally: bad match"
1485 G2.dyn_ltree[G2.length_code[lc] + LITERALS + 1].Freq++;
1486 G2.dyn_dtree[D_CODE(dist)].Freq++;
1488 G1.d_buf[G2.last_dist++] = dist;
1489 G2.flags |= G2.flag_bit;
1493 /* Output the flags if they fill a byte: */
1494 if ((G2.last_lit & 7) == 0) {
1495 G2.flag_buf[G2.last_flags++] = G2.flags;
1499 /* Try to guess if it is profitable to stop the current block here */
1500 if ((G2.last_lit & 0xfff) == 0) {
1501 /* Compute an upper bound for the compressed length */
1502 ulg out_length = G2.last_lit * 8L;
1503 ulg in_length = (ulg) G1.strstart - G1.block_start;
1506 for (dcode = 0; dcode < D_CODES; dcode++) {
1507 out_length += G2.dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]);
1511 "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
1512 G2.last_lit, G2.last_dist, in_length, out_length,
1513 100L - out_length * 100L / in_length));
1514 if (G2.last_dist < G2.last_lit / 2 && out_length < in_length / 2)
1517 return (G2.last_lit == LIT_BUFSIZE - 1 || G2.last_dist == DIST_BUFSIZE);
1518 /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
1519 * on 16 bit machines and because stored blocks are restricted to
1524 /* ===========================================================================
1525 * Send the block data compressed using the given Huffman trees
1527 static void compress_block(ct_data * ltree, ct_data * dtree)
1529 unsigned dist; /* distance of matched string */
1530 int lc; /* match length or unmatched char (if dist == 0) */
1531 unsigned lx = 0; /* running index in l_buf */
1532 unsigned dx = 0; /* running index in d_buf */
1533 unsigned fx = 0; /* running index in flag_buf */
1534 uch flag = 0; /* current flags */
1535 unsigned code; /* the code to send */
1536 int extra; /* number of extra bits to send */
1538 if (G2.last_lit != 0) do {
1540 flag = G2.flag_buf[fx++];
1541 lc = G1.l_buf[lx++];
1542 if ((flag & 1) == 0) {
1543 SEND_CODE(lc, ltree); /* send a literal byte */
1544 Tracecv(lc > ' ', (stderr, " '%c' ", lc));
1546 /* Here, lc is the match length - MIN_MATCH */
1547 code = G2.length_code[lc];
1548 SEND_CODE(code + LITERALS + 1, ltree); /* send the length code */
1549 extra = extra_lbits[code];
1551 lc -= G2.base_length[code];
1552 send_bits(lc, extra); /* send the extra length bits */
1554 dist = G1.d_buf[dx++];
1555 /* Here, dist is the match distance - 1 */
1556 code = D_CODE(dist);
1557 Assert(code < D_CODES, "bad d_code");
1559 SEND_CODE(code, dtree); /* send the distance code */
1560 extra = extra_dbits[code];
1562 dist -= G2.base_dist[code];
1563 send_bits(dist, extra); /* send the extra distance bits */
1565 } /* literal or match pair ? */
1567 } while (lx < G2.last_lit);
1569 SEND_CODE(END_BLOCK, ltree);
1573 /* ===========================================================================
1574 * Determine the best encoding for the current block: dynamic trees, static
1575 * trees or store, and output the encoded block to the zip file. This function
1576 * returns the total compressed length for the file so far.
1578 static ulg flush_block(char *buf, ulg stored_len, int eof)
1580 ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
1581 int max_blindex; /* index of last bit length code of non zero freq */
1583 G2.flag_buf[G2.last_flags] = G2.flags; /* Save the flags for the last 8 items */
1585 /* Construct the literal and distance trees */
1586 build_tree(&G2.l_desc);
1587 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", G2.opt_len, G2.static_len));
1589 build_tree(&G2.d_desc);
1590 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", G2.opt_len, G2.static_len));
1591 /* At this point, opt_len and static_len are the total bit lengths of
1592 * the compressed block data, excluding the tree representations.
1595 /* Build the bit length tree for the above two trees, and get the index
1596 * in bl_order of the last bit length code to send.
1598 max_blindex = build_bl_tree();
1600 /* Determine the best encoding. Compute first the block length in bytes */
1601 opt_lenb = (G2.opt_len + 3 + 7) >> 3;
1602 static_lenb = (G2.static_len + 3 + 7) >> 3;
1605 "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
1606 opt_lenb, G2.opt_len, static_lenb, G2.static_len, stored_len,
1607 G2.last_lit, G2.last_dist));
1609 if (static_lenb <= opt_lenb)
1610 opt_lenb = static_lenb;
1612 /* If compression failed and this is the first and last block,
1613 * and if the zip file can be seeked (to rewrite the local header),
1614 * the whole file is transformed into a stored file:
1616 if (stored_len <= opt_lenb && eof && G2.compressed_len == 0L && seekable()) {
1617 /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
1619 bb_error_msg("block vanished");
1621 copy_block(buf, (unsigned) stored_len, 0); /* without header */
1622 G2.compressed_len = stored_len << 3;
1624 } else if (stored_len + 4 <= opt_lenb && buf != NULL) {
1625 /* 4: two words for the lengths */
1626 /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
1627 * Otherwise we can't have processed more than WSIZE input bytes since
1628 * the last block flush, because compression would have been
1629 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
1630 * transform a block into a stored block.
1632 send_bits((STORED_BLOCK << 1) + eof, 3); /* send block type */
1633 G2.compressed_len = (G2.compressed_len + 3 + 7) & ~7L;
1634 G2.compressed_len += (stored_len + 4) << 3;
1636 copy_block(buf, (unsigned) stored_len, 1); /* with header */
1638 } else if (static_lenb == opt_lenb) {
1639 send_bits((STATIC_TREES << 1) + eof, 3);
1640 compress_block((ct_data *) G2.static_ltree, (ct_data *) G2.static_dtree);
1641 G2.compressed_len += 3 + G2.static_len;
1643 send_bits((DYN_TREES << 1) + eof, 3);
1644 send_all_trees(G2.l_desc.max_code + 1, G2.d_desc.max_code + 1,
1646 compress_block((ct_data *) G2.dyn_ltree, (ct_data *) G2.dyn_dtree);
1647 G2.compressed_len += 3 + G2.opt_len;
1649 Assert(G2.compressed_len == G1.bits_sent, "bad compressed size");
1654 G2.compressed_len += 7; /* align on byte boundary */
1656 Tracev((stderr, "\ncomprlen %lu(%lu) ", G2.compressed_len >> 3,
1657 G2.compressed_len - 7 * eof));
1659 return G2.compressed_len >> 3;
1663 /* ===========================================================================
1664 * Update a hash value with the given input byte
1665 * IN assertion: all calls to to UPDATE_HASH are made with consecutive
1666 * input characters, so that a running hash key can be computed from the
1667 * previous key instead of complete recalculation each time.
1669 #define UPDATE_HASH(h, c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
1672 /* ===========================================================================
1673 * Same as above, but achieves better compression. We use a lazy
1674 * evaluation for matches: a match is finally adopted only if there is
1675 * no better match at the next window position.
1677 * Processes a new input file and return its compressed length. Sets
1678 * the compressed length, crc, deflate flags and internal file
1682 /* Flush the current block, with given end-of-file flag.
1683 * IN assertion: strstart is set to the end of the current match. */
1684 #define FLUSH_BLOCK(eof) \
1686 G1.block_start >= 0L \
1687 ? (char*)&G1.window[(unsigned)G1.block_start] \
1689 (ulg)G1.strstart - G1.block_start, \
1693 /* Insert string s in the dictionary and set match_head to the previous head
1694 * of the hash chain (the most recent string with same hash key). Return
1695 * the previous length of the hash chain.
1696 * IN assertion: all calls to to INSERT_STRING are made with consecutive
1697 * input characters and the first MIN_MATCH bytes of s are valid
1698 * (except for the last MIN_MATCH-1 bytes of the input file). */
1699 #define INSERT_STRING(s, match_head) \
1701 UPDATE_HASH(G1.ins_h, G1.window[(s) + MIN_MATCH-1]); \
1702 G1.prev[(s) & WMASK] = match_head = head[G1.ins_h]; \
1703 head[G1.ins_h] = (s); \
1706 static ulg deflate(void)
1708 IPos hash_head; /* head of hash chain */
1709 IPos prev_match; /* previous match */
1710 int flush; /* set if current block must be flushed */
1711 int match_available = 0; /* set if previous match exists */
1712 unsigned match_length = MIN_MATCH - 1; /* length of best match */
1714 /* Process the input block. */
1715 while (G1.lookahead != 0) {
1716 /* Insert the string window[strstart .. strstart+2] in the
1717 * dictionary, and set hash_head to the head of the hash chain:
1719 INSERT_STRING(G1.strstart, hash_head);
1721 /* Find the longest match, discarding those <= prev_length.
1723 G1.prev_length = match_length;
1724 prev_match = G1.match_start;
1725 match_length = MIN_MATCH - 1;
1727 if (hash_head != 0 && G1.prev_length < max_lazy_match
1728 && G1.strstart - hash_head <= MAX_DIST
1730 /* To simplify the code, we prevent matches with the string
1731 * of window index 0 (in particular we have to avoid a match
1732 * of the string with itself at the start of the input file).
1734 match_length = longest_match(hash_head);
1735 /* longest_match() sets match_start */
1736 if (match_length > G1.lookahead)
1737 match_length = G1.lookahead;
1739 /* Ignore a length 3 match if it is too distant: */
1740 if (match_length == MIN_MATCH && G1.strstart - G1.match_start > TOO_FAR) {
1741 /* If prev_match is also MIN_MATCH, G1.match_start is garbage
1742 * but we will ignore the current match anyway.
1747 /* If there was a match at the previous step and the current
1748 * match is not better, output the previous match:
1750 if (G1.prev_length >= MIN_MATCH && match_length <= G1.prev_length) {
1751 check_match(G1.strstart - 1, prev_match, G1.prev_length);
1752 flush = ct_tally(G1.strstart - 1 - prev_match, G1.prev_length - MIN_MATCH);
1754 /* Insert in hash table all strings up to the end of the match.
1755 * strstart-1 and strstart are already inserted.
1757 G1.lookahead -= G1.prev_length - 1;
1758 G1.prev_length -= 2;
1761 INSERT_STRING(G1.strstart, hash_head);
1762 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
1763 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
1764 * these bytes are garbage, but it does not matter since the
1765 * next lookahead bytes will always be emitted as literals.
1767 } while (--G1.prev_length != 0);
1768 match_available = 0;
1769 match_length = MIN_MATCH - 1;
1773 G1.block_start = G1.strstart;
1775 } else if (match_available) {
1776 /* If there was no match at the previous position, output a
1777 * single literal. If there was a match but the current match
1778 * is longer, truncate the previous match to a single literal.
1780 Tracevv((stderr, "%c", G1.window[G1.strstart - 1]));
1781 if (ct_tally(0, G1.window[G1.strstart - 1])) {
1783 G1.block_start = G1.strstart;
1788 /* There is no previous match to compare with, wait for
1789 * the next step to decide.
1791 match_available = 1;
1795 Assert(G1.strstart <= G1.isize && lookahead <= G1.isize, "a bit too far");
1797 /* Make sure that we always have enough lookahead, except
1798 * at the end of the input file. We need MAX_MATCH bytes
1799 * for the next match, plus MIN_MATCH bytes to insert the
1800 * string following the next match.
1802 while (G1.lookahead < MIN_LOOKAHEAD && !G1.eofile)
1805 if (match_available)
1806 ct_tally(0, G1.window[G1.strstart - 1]);
1808 return FLUSH_BLOCK(1); /* eof */
1812 /* ===========================================================================
1813 * Initialize the bit string routines.
1815 static void bi_init(void)
1825 /* ===========================================================================
1826 * Initialize the "longest match" routines for a new file
1828 static void lm_init(ush * flagsp)
1832 /* Initialize the hash table. */
1833 memset(head, 0, HASH_SIZE * sizeof(*head));
1834 /* prev will be initialized on the fly */
1836 /* speed options for the general purpose bit flag */
1837 *flagsp |= 2; /* FAST 4, SLOW 2 */
1838 /* ??? reduce max_chain_length for binary files */
1841 G1.block_start = 0L;
1843 G1.lookahead = file_read(G1.window,
1844 sizeof(int) <= 2 ? (unsigned) WSIZE : 2 * WSIZE);
1846 if (G1.lookahead == 0 || G1.lookahead == (unsigned) -1) {
1852 /* Make sure that we always have enough lookahead. This is important
1853 * if input comes from a device such as a tty.
1855 while (G1.lookahead < MIN_LOOKAHEAD && !G1.eofile)
1859 for (j = 0; j < MIN_MATCH - 1; j++)
1860 UPDATE_HASH(G1.ins_h, G1.window[j]);
1861 /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
1862 * not important since only literal bytes will be emitted.
1867 /* ===========================================================================
1868 * Allocate the match buffer, initialize the various tables and save the
1869 * location of the internal file attribute (ascii/binary) and method
1871 * One callsite in zip()
1873 static void ct_init(void)
1875 int n; /* iterates over tree elements */
1876 int length; /* length value */
1877 int code; /* code value */
1878 int dist; /* distance index */
1880 G2.compressed_len = 0L;
1883 if (G2.static_dtree[0].Len != 0)
1884 return; /* ct_init already called */
1887 /* Initialize the mapping length (0..255) -> length code (0..28) */
1889 for (code = 0; code < LENGTH_CODES - 1; code++) {
1890 G2.base_length[code] = length;
1891 for (n = 0; n < (1 << extra_lbits[code]); n++) {
1892 G2.length_code[length++] = code;
1895 Assert(length == 256, "ct_init: length != 256");
1896 /* Note that the length 255 (match length 258) can be represented
1897 * in two different ways: code 284 + 5 bits or code 285, so we
1898 * overwrite length_code[255] to use the best encoding:
1900 G2.length_code[length - 1] = code;
1902 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
1904 for (code = 0; code < 16; code++) {
1905 G2.base_dist[code] = dist;
1906 for (n = 0; n < (1 << extra_dbits[code]); n++) {
1907 G2.dist_code[dist++] = code;
1910 Assert(dist == 256, "ct_init: dist != 256");
1911 dist >>= 7; /* from now on, all distances are divided by 128 */
1912 for (; code < D_CODES; code++) {
1913 G2.base_dist[code] = dist << 7;
1914 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
1915 G2.dist_code[256 + dist++] = code;
1918 Assert(dist == 256, "ct_init: 256+dist != 512");
1920 /* Construct the codes of the static literal tree */
1921 /* already zeroed - it's in bss
1922 for (n = 0; n <= MAX_BITS; n++)
1923 G2.bl_count[n] = 0; */
1927 G2.static_ltree[n++].Len = 8;
1931 G2.static_ltree[n++].Len = 9;
1935 G2.static_ltree[n++].Len = 7;
1939 G2.static_ltree[n++].Len = 8;
1942 /* Codes 286 and 287 do not exist, but we must include them in the
1943 * tree construction to get a canonical Huffman tree (longest code
1946 gen_codes((ct_data *) G2.static_ltree, L_CODES + 1);
1948 /* The static distance tree is trivial: */
1949 for (n = 0; n < D_CODES; n++) {
1950 G2.static_dtree[n].Len = 5;
1951 G2.static_dtree[n].Code = bi_reverse(n, 5);
1954 /* Initialize the first block of the first file: */
1959 /* ===========================================================================
1960 * Deflate in to out.
1961 * IN assertions: the input and output buffers are cleared.
1964 static void zip(ulg time_stamp)
1966 ush deflate_flags = 0; /* pkzip -es, -en or -ex equivalent */
1970 /* Write the header to the gzip file. See algorithm.doc for the format */
1971 /* magic header for gzip files: 1F 8B */
1972 /* compression method: 8 (DEFLATED) */
1973 /* general flags: 0 */
1974 put_32bit(0x00088b1f);
1975 put_32bit(time_stamp);
1977 /* Write deflated file to zip file */
1982 lm_init(&deflate_flags);
1984 put_8bit(deflate_flags); /* extra flags */
1985 put_8bit(3); /* OS identifier = 3 (Unix) */
1989 /* Write the crc and uncompressed size */
1991 put_32bit(G1.isize);
1997 /* ======================================================================== */
1999 char* make_new_name_gzip(char *filename)
2001 return xasprintf("%s.gz", filename);
2005 IF_DESKTOP(long long) int pack_gzip(unpack_info_t *info UNUSED_PARAM)
2009 /* Clear input and output buffers */
2017 memset(&G2, 0, sizeof(G2));
2018 G2.l_desc.dyn_tree = G2.dyn_ltree;
2019 G2.l_desc.static_tree = G2.static_ltree;
2020 G2.l_desc.extra_bits = extra_lbits;
2021 G2.l_desc.extra_base = LITERALS + 1;
2022 G2.l_desc.elems = L_CODES;
2023 G2.l_desc.max_length = MAX_BITS;
2024 //G2.l_desc.max_code = 0;
2025 G2.d_desc.dyn_tree = G2.dyn_dtree;
2026 G2.d_desc.static_tree = G2.static_dtree;
2027 G2.d_desc.extra_bits = extra_dbits;
2028 //G2.d_desc.extra_base = 0;
2029 G2.d_desc.elems = D_CODES;
2030 G2.d_desc.max_length = MAX_BITS;
2031 //G2.d_desc.max_code = 0;
2032 G2.bl_desc.dyn_tree = G2.bl_tree;
2033 //G2.bl_desc.static_tree = NULL;
2034 G2.bl_desc.extra_bits = extra_blbits,
2035 //G2.bl_desc.extra_base = 0;
2036 G2.bl_desc.elems = BL_CODES;
2037 G2.bl_desc.max_length = MAX_BL_BITS;
2038 //G2.bl_desc.max_code = 0;
2041 fstat(STDIN_FILENO, &s);
2046 #if ENABLE_FEATURE_GZIP_LONG_OPTIONS
2047 static const char gzip_longopts[] ALIGN1 =
2048 "stdout\0" No_argument "c"
2049 "to-stdout\0" No_argument "c"
2050 "force\0" No_argument "f"
2051 "verbose\0" No_argument "v"
2053 "decompress\0" No_argument "d"
2054 "uncompress\0" No_argument "d"
2055 "test\0" No_argument "t"
2057 "quiet\0" No_argument "q"
2058 "fast\0" No_argument "1"
2059 "best\0" No_argument "9"
2064 * Linux kernel build uses gzip -d -n. We accept and ignore it.
2067 * gzip: do not save the original file name and time stamp.
2068 * (The original name is always saved if the name had to be truncated.)
2069 * gunzip: do not restore the original file name/time even if present
2070 * (remove only the gzip suffix from the compressed file name).
2071 * This option is the default when decompressing.
2073 * gzip: always save the original file name and time stamp (this is the default)
2074 * gunzip: restore the original file name and time stamp if present.
2077 int gzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
2079 int gzip_main(int argc, char **argv)
2081 int gzip_main(int argc UNUSED_PARAM, char **argv)
2086 #if ENABLE_FEATURE_GZIP_LONG_OPTIONS
2087 applet_long_options = gzip_longopts;
2089 /* Must match bbunzip's constants OPT_STDOUT, OPT_FORCE! */
2090 opt = getopt32(argv, "cfv" IF_GUNZIP("dt") "q123456789n");
2091 #if ENABLE_GUNZIP /* gunzip_main may not be visible... */
2092 if (opt & 0x18) // -d and/or -t
2093 return gunzip_main(argc, argv);
2095 option_mask32 &= 0x7; /* ignore -q, -0..9 */
2096 //if (opt & 0x1) // -c
2097 //if (opt & 0x2) // -f
2098 //if (opt & 0x4) // -v
2101 SET_PTR_TO_GLOBALS((char *)xzalloc(sizeof(struct globals)+sizeof(struct globals2))
2102 + sizeof(struct globals));
2104 /* Allocate all global buffers (for DYN_ALLOC option) */
2105 ALLOC(uch, G1.l_buf, INBUFSIZ);
2106 ALLOC(uch, G1.outbuf, OUTBUFSIZ);
2107 ALLOC(ush, G1.d_buf, DIST_BUFSIZE);
2108 ALLOC(uch, G1.window, 2L * WSIZE);
2109 ALLOC(ush, G1.prev, 1L << BITS);
2111 /* Initialise the CRC32 table */
2112 G1.crc_32_tab = crc32_filltable(NULL, 0);
2114 return bbunpack(argv, make_new_name_gzip, pack_gzip);