Lines Matching refs:s
95 # define zmemcpy(d, s, n) bcopy((s), (d), (n)) argument
130 #define TRY_FREE(s, p, n) {if (p) ZFREE(s, p, n);} argument
394 #define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} argument
402 #define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) argument
408 local void ct_init OF((deflate_state *s));
409 local int ct_tally OF((deflate_state *s, int dist, int lc));
410 local ulg ct_flush_block OF((deflate_state *s, charf *buf, ulg stored_len,
412 local void ct_align OF((deflate_state *s));
413 local void ct_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
415 local void ct_stored_type_only OF((deflate_state *s));
530 local void fill_window OF((deflate_state *s));
531 local int deflate_fast OF((deflate_state *s, int flush));
532 local int deflate_slow OF((deflate_state *s, int flush));
533 local void lm_init OF((deflate_state *s));
534 local int longest_match OF((deflate_state *s, IPos cur_match));
535 local void putShortMSB OF((deflate_state *s, uInt b));
543 local void check_match OF((deflate_state *s, IPos start, IPos match,
554 #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) argument
565 #define INSERT_STRING(s, str, match_head) \ argument
566 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
567 s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \
568 s->head[s->ins_h] = (str))
574 #define CLEAR_HASH(s) \ argument
575 s->head[s->hash_size-1] = NIL; \
576 zmemzero((charf *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
599 deflate_state *s; local
618 s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
619 if (s == Z_NULL) return Z_MEM_ERROR;
620 strm->state = (struct internal_state FAR *)s;
621 s->strm = strm;
623 s->noheader = noheader;
624 s->w_bits = windowBits;
625 s->w_size = 1 << s->w_bits;
626 s->w_mask = s->w_size - 1;
628 s->hash_bits = memLevel + 7;
629 s->hash_size = 1 << s->hash_bits;
630 s->hash_mask = s->hash_size - 1;
631 s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
633 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
634 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
635 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
637 s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
639 s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 2*sizeof(ush));
641 if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
642 s->pending_buf == Z_NULL) {
647 s->d_buf = (ushf *) &(s->pending_buf[s->lit_bufsize]);
648 s->l_buf = (uchf *) &(s->pending_buf[3*s->lit_bufsize]);
654 s->level = level;
655 s->strategy = strategy;
656 s->method = (Byte)method;
657 s->minCompr = minCompression;
658 s->blocks_in_packet = 0;
667 deflate_state *s; local
676 s = (deflate_state *)strm->state;
677 s->pending = 0;
678 s->pending_out = s->pending_buf;
680 if (s->noheader < 0) {
681 s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */
683 s->status = s->noheader ? BUSY_STATE : INIT_STATE;
684 s->adler = 1;
686 ct_init(s);
687 lm_init(s);
697 local void putShortMSB (s, b) in putShortMSB() argument
698 deflate_state *s; in putShortMSB()
701 put_byte(s, (Byte)(b >> 8));
702 put_byte(s, (Byte)(b & 0xff));
902 local void lm_init (s) in lm_init() argument
903 deflate_state *s; in lm_init()
905 s->window_size = (ulg)2L*s->w_size;
907 CLEAR_HASH(s);
911 s->max_lazy_match = configuration_table[s->level].max_lazy;
912 s->good_match = configuration_table[s->level].good_length;
913 s->nice_match = configuration_table[s->level].nice_length;
914 s->max_chain_length = configuration_table[s->level].max_chain;
916 s->strstart = 0;
917 s->block_start = 0L;
918 s->lookahead = 0;
919 s->match_length = MIN_MATCH-1;
920 s->match_available = 0;
921 s->ins_h = 0;
939 local int longest_match(s, cur_match) in longest_match() argument
940 deflate_state *s; in longest_match()
943 unsigned chain_length = s->max_chain_length;/* max hash chain length */
944 register Bytef *scan = s->window + s->strstart; /* current string */
947 int best_len = s->prev_length; /* best match length so far */
948 IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
949 s->strstart - (IPos)MAX_DIST(s) : NIL;
953 Posf *prev = s->prev;
954 uInt wmask = s->w_mask;
960 register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
964 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
972 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
975 if (s->prev_length >= s->good_match) {
978 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
981 Assert(cur_match < s->strstart, "no future");
982 match = s->window + cur_match;
1014 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1046 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1054 s->match_start = cur_match;
1056 if (len >= s->nice_match) break;
1075 local void check_match(s, start, match, length) in check_match() argument
1076 deflate_state *s; in check_match()
1081 if (memcmp((charf *)s->window + match,
1082 (charf *)s->window + start, length) != EQUAL) {
1086 do { fprintf(stderr, "%c%c", s->window[match++],
1087 s->window[start++]); } while (--length != 0);
1092 do { putc(s->window[start++], stderr); } while (--length != 0);
1096 # define check_match(s, start, match, length) argument
1109 local void fill_window(s) in fill_window() argument
1110 deflate_state *s; in fill_window()
1115 uInt wsize = s->w_size;
1118 more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
1121 if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
1132 } else if (s->strstart >= wsize+MAX_DIST(s)) {
1137 zmemcpy((charf *)s->window, (charf *)s->window+wsize,
1139 s->match_start -= wsize;
1140 s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
1142 s->block_start -= (long) wsize;
1147 n = s->hash_size;
1148 p = &s->head[n];
1155 p = &s->prev[n];
1166 if (s->strm->avail_in == 0) return;
1181 n = read_buf(s->strm, (charf *)s->window + s->strstart + s->lookahead,
1183 s->lookahead += n;
1186 if (s->lookahead >= MIN_MATCH) {
1187 s->ins_h = s->window[s->strstart];
1188 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1197 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
1204 #define FLUSH_BLOCK_ONLY(s, flush) { \ argument
1205 ct_flush_block(s, (s->block_start >= 0L ? \
1206 (charf *)&s->window[(unsigned)s->block_start] : \
1207 (charf *)Z_NULL), (long)s->strstart - s->block_start, (flush)); \
1208 s->block_start = s->strstart; \
1209 flush_pending(s->strm); \
1214 #define FLUSH_BLOCK(s, flush) { \ argument
1215 FLUSH_BLOCK_ONLY(s, flush); \
1216 if (s->strm->avail_out == 0) return 1; \
1226 local int deflate_fast(s, flush) in deflate_fast() argument
1227 deflate_state *s; in deflate_fast()
1233 s->prev_length = MIN_MATCH-1;
1241 if (s->lookahead < MIN_LOOKAHEAD) {
1242 fill_window(s);
1243 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
1245 if (s->lookahead == 0) break; /* flush the current block */
1251 if (s->lookahead >= MIN_MATCH) {
1252 INSERT_STRING(s, s->strstart, hash_head);
1258 if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
1263 if (s->strategy != Z_HUFFMAN_ONLY) {
1264 s->match_length = longest_match (s, hash_head);
1268 if (s->match_length > s->lookahead) s->match_length = s->lookahead;
1270 if (s->match_length >= MIN_MATCH) {
1271 check_match(s, s->strstart, s->match_start, s->match_length);
1273 bflush = ct_tally(s, s->strstart - s->match_start,
1274 s->match_length - MIN_MATCH);
1276 s->lookahead -= s->match_length;
1281 if (s->match_length <= s->max_insert_length &&
1282 s->lookahead >= MIN_MATCH) {
1283 s->match_length--; /* string at strstart already in hash table */
1285 s->strstart++;
1286 INSERT_STRING(s, s->strstart, hash_head);
1290 } while (--s->match_length != 0);
1291 s->strstart++;
1293 s->strstart += s->match_length;
1294 s->match_length = 0;
1295 s->ins_h = s->window[s->strstart];
1296 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1306 Tracevv((stderr,"%c", s->window[s->strstart]));
1307 bflush = ct_tally (s, 0, s->window[s->strstart]);
1308 s->lookahead--;
1309 s->strstart++;
1311 if (bflush) FLUSH_BLOCK(s, Z_NO_FLUSH);
1313 FLUSH_BLOCK(s, flush);
1322 local int deflate_slow(s, flush) in deflate_slow() argument
1323 deflate_state *s; in deflate_slow()
1336 if (s->lookahead < MIN_LOOKAHEAD) {
1337 fill_window(s);
1338 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1;
1340 if (s->lookahead == 0) break; /* flush the current block */
1346 if (s->lookahead >= MIN_MATCH) {
1347 INSERT_STRING(s, s->strstart, hash_head);
1352 s->prev_length = s->match_length, s->prev_match = s->match_start;
1353 s->match_length = MIN_MATCH-1;
1355 if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
1356 s->strstart - hash_head <= MAX_DIST(s)) {
1361 if (s->strategy != Z_HUFFMAN_ONLY) {
1362 s->match_length = longest_match (s, hash_head);
1365 if (s->match_length > s->lookahead) s->match_length = s->lookahead;
1367 if (s->match_length <= 5 && (s->strategy == Z_FILTERED ||
1368 (s->match_length == MIN_MATCH &&
1369 s->strstart - s->match_start > TOO_FAR))) {
1374 s->match_length = MIN_MATCH-1;
1380 if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
1381 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
1384 check_match(s, s->strstart-1, s->prev_match, s->prev_length);
1386 bflush = ct_tally(s, s->strstart -1 - s->prev_match,
1387 s->prev_length - MIN_MATCH);
1394 s->lookahead -= s->prev_length-1;
1395 s->prev_length -= 2;
1397 if (++s->strstart <= max_insert) {
1398 INSERT_STRING(s, s->strstart, hash_head);
1400 } while (--s->prev_length != 0);
1401 s->match_available = 0;
1402 s->match_length = MIN_MATCH-1;
1403 s->strstart++;
1405 if (bflush) FLUSH_BLOCK(s, Z_NO_FLUSH);
1407 } else if (s->match_available) {
1412 Tracevv((stderr,"%c", s->window[s->strstart-1]));
1413 if (ct_tally (s, 0, s->window[s->strstart-1])) {
1414 FLUSH_BLOCK_ONLY(s, Z_NO_FLUSH);
1416 s->strstart++;
1417 s->lookahead--;
1418 if (s->strm->avail_out == 0) return 1;
1423 s->match_available = 1;
1424 s->strstart++;
1425 s->lookahead--;
1429 if (s->match_available) {
1430 Tracevv((stderr,"%c", s->window[s->strstart-1]));
1431 ct_tally (s, 0, s->window[s->strstart-1]);
1432 s->match_available = 0;
1434 FLUSH_BLOCK(s, flush);
1570 local void init_block OF((deflate_state *s));
1571 local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
1572 local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
1574 local void build_tree OF((deflate_state *s, tree_desc *desc));
1575 local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
1576 local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
1577 local int build_bl_tree OF((deflate_state *s));
1578 local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
1580 local void compress_block OF((deflate_state *s, ct_data *ltree,
1582 local void set_data_type OF((deflate_state *s));
1584 local void bi_windup OF((deflate_state *s));
1585 local void bi_flush OF((deflate_state *s));
1586 local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
1590 # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) argument
1594 # define send_code(s, c, tree) \ argument
1596 send_bits(s, tree[c].Code, tree[c].Len); }
1610 #define put_short(s, w) { \ argument
1611 put_byte(s, (uch)((w) & 0xff)); \
1612 put_byte(s, (uch)((ush)(w) >> 8)); \
1620 local void send_bits OF((deflate_state *s, int value, int length));
1622 local void send_bits(s, value, length) in send_bits() argument
1623 deflate_state *s; in send_bits()
1629 s->bits_sent += (ulg)length;
1635 if (s->bi_valid > (int)Buf_size - length) {
1636 s->bi_buf |= (value << s->bi_valid);
1637 put_short(s, s->bi_buf);
1638 s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
1639 s->bi_valid += length - Buf_size;
1641 s->bi_buf |= value << s->bi_valid;
1642 s->bi_valid += length;
1647 #define send_bits(s, value, length) \ argument
1649 if (s->bi_valid > (int)Buf_size - len) {\
1651 s->bi_buf |= (val << s->bi_valid);\
1652 put_short(s, s->bi_buf);\
1653 s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
1654 s->bi_valid += len - Buf_size;\
1656 s->bi_buf |= (value) << s->bi_valid;\
1657 s->bi_valid += len;\
1736 local void ct_init(s) in ct_init() argument
1737 deflate_state *s; in ct_init()
1743 s->compressed_len = 0L;
1745 s->l_desc.dyn_tree = s->dyn_ltree;
1746 s->l_desc.stat_desc = &static_l_desc;
1748 s->d_desc.dyn_tree = s->dyn_dtree;
1749 s->d_desc.stat_desc = &static_d_desc;
1751 s->bl_desc.dyn_tree = s->bl_tree;
1752 s->bl_desc.stat_desc = &static_bl_desc;
1754 s->bi_buf = 0;
1755 s->bi_valid = 0;
1756 s->last_eob_len = 8; /* enough lookahead for inflate */
1758 s->bits_sent = 0L;
1760 s->blocks_in_packet = 0;
1763 init_block(s);
1769 local void init_block(s) in init_block() argument
1770 deflate_state *s; in init_block()
1775 for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
1776 for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
1777 for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
1779 s->dyn_ltree[END_BLOCK].Freq = 1;
1780 s->opt_len = s->static_len = 0L;
1781 s->last_lit = s->matches = 0;
1792 #define pqremove(s, tree, top) \ argument
1794 top = s->heap[SMALLEST]; \
1795 s->heap[SMALLEST] = s->heap[s->heap_len--]; \
1796 pqdownheap(s, tree, SMALLEST); \
1813 local void pqdownheap(s, tree, k) in pqdownheap() argument
1814 deflate_state *s; in pqdownheap()
1818 int v = s->heap[k];
1820 while (j <= s->heap_len) {
1822 if (j < s->heap_len &&
1823 smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
1827 if (smaller(tree, v, s->heap[j], s->depth)) break;
1830 s->heap[k] = s->heap[j]; k = j;
1835 s->heap[k] = v;
1848 local void gen_bitlen(s, desc) in gen_bitlen() argument
1849 deflate_state *s; in gen_bitlen()
1865 for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
1870 tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
1872 for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
1873 n = s->heap[h];
1881 s->bl_count[bits]++;
1885 s->opt_len += (ulg)f * (bits + xbits);
1886 if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
1896 while (s->bl_count[bits] == 0) bits--;
1897 s->bl_count[bits]--; /* move one leaf down the tree */
1898 s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
1899 s->bl_count[max_length]--;
1912 n = s->bl_count[bits];
1914 m = s->heap[--h];
1918 s->opt_len += ((long)bits - (long)tree[m].Len)
1977 local void build_tree(s, desc) in build_tree() argument
1978 deflate_state *s; in build_tree()
1992 s->heap_len = 0, s->heap_max = HEAP_SIZE;
1996 s->heap[++(s->heap_len)] = max_code = n;
1997 s->depth[n] = 0;
2008 while (s->heap_len < 2) {
2009 node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
2011 s->depth[node] = 0;
2012 s->opt_len--; if (stree) s->static_len -= stree[node].Len;
2020 for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
2027 pqremove(s, tree, n); /* n = node of least frequency */
2028 m = s->heap[SMALLEST]; /* m = node of next least frequency */
2030 s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
2031 s->heap[--(s->heap_max)] = m;
2035 s->depth[node] = (uch) (MAX(s->depth[n], s->depth[m]) + 1);
2038 if (tree == s->bl_tree) {
2044 s->heap[SMALLEST] = node++;
2045 pqdownheap(s, tree, SMALLEST);
2047 } while (s->heap_len >= 2);
2049 s->heap[--(s->heap_max)] = s->heap[SMALLEST];
2054 gen_bitlen(s, (tree_desc *)desc);
2057 gen_codes ((ct_data *)tree, max_code, s->bl_count);
2064 local void scan_tree (s, tree, max_code) in scan_tree() argument
2065 deflate_state *s; in scan_tree()
2085 s->bl_tree[curlen].Freq += count;
2087 if (curlen != prevlen) s->bl_tree[curlen].Freq++;
2088 s->bl_tree[REP_3_6].Freq++;
2090 s->bl_tree[REPZ_3_10].Freq++;
2092 s->bl_tree[REPZ_11_138].Freq++;
2109 local void send_tree (s, tree, max_code) in send_tree() argument
2110 deflate_state *s; in send_tree()
2130 do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
2134 send_code(s, curlen, s->bl_tree); count--;
2137 send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
2140 send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
2143 send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
2160 local int build_bl_tree(s) in build_bl_tree() argument
2161 deflate_state *s; in build_bl_tree()
2166 scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
2167 scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
2170 build_tree(s, (tree_desc *)(&(s->bl_desc)));
2180 if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
2183 s->opt_len += 3*(max_blindex+1) + 5+5+4;
2185 s->opt_len, s->static_len));
2195 local void send_all_trees(s, lcodes, dcodes, blcodes) in send_all_trees() argument
2196 deflate_state *s; in send_all_trees()
2205 send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
2206 send_bits(s, dcodes-1, 5);
2207 send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
2210 send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
2212 Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
2214 send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
2215 Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
2217 send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
2218 Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
2224 local void ct_stored_block(s, buf, stored_len, eof) in ct_stored_block() argument
2225 deflate_state *s; in ct_stored_block()
2230 send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */
2231 s->compressed_len = (s->compressed_len + 3 + 7) & ~7L;
2232 s->compressed_len += (stored_len + 4) << 3;
2234 copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
2239 local void ct_stored_type_only(s) in ct_stored_type_only() argument
2240 deflate_state *s; in ct_stored_type_only()
2242 send_bits(s, (STORED_BLOCK << 1), 3);
2243 bi_windup(s);
2244 s->compressed_len = (s->compressed_len + 3) & ~7L;
2256 local void ct_align(s) in ct_align() argument
2257 deflate_state *s; in ct_align()
2259 send_bits(s, STATIC_TREES<<1, 3);
2260 send_code(s, END_BLOCK, static_ltree);
2261 s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
2262 bi_flush(s);
2267 if (s->last_eob_len + 10 - s->bi_valid < 9) {
2268 send_bits(s, STATIC_TREES<<1, 3);
2269 send_code(s, END_BLOCK, static_ltree);
2270 s->compressed_len += 10L;
2271 bi_flush(s);
2273 s->last_eob_len = 7;
2281 local ulg ct_flush_block(s, buf, stored_len, flush) in ct_flush_block() argument
2282 deflate_state *s; in ct_flush_block()
2291 ++s->blocks_in_packet;
2294 if (s->data_type == UNKNOWN) set_data_type(s);
2297 build_tree(s, (tree_desc *)(&(s->l_desc)));
2298 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
2299 s->static_len));
2301 build_tree(s, (tree_desc *)(&(s->d_desc)));
2302 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
2303 s->static_len));
2311 max_blindex = build_bl_tree(s);
2314 opt_lenb = (s->opt_len+3+7)>>3;
2315 static_lenb = (s->static_len+3+7)>>3;
2318 opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
2319 s->last_lit));
2331 if (stored_len <= opt_lenb && eof && s->compressed_len==0L && seekable())
2338 s->compressed_len = stored_len << 3;
2339 s->method = STORED;
2348 if (flush == Z_PACKET_FLUSH && s->blocks_in_packet == 1
2349 && opt_lenb > stored_len - s->minCompr) {
2350 s->blocks_in_packet = 0;
2367 ct_stored_block(s, buf, stored_len, eof);
2376 send_bits(s, (STATIC_TREES<<1)+eof, 3);
2377 compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
2378 s->compressed_len += 3 + s->static_len;
2380 send_bits(s, (DYN_TREES<<1)+eof, 3);
2381 send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
2383 compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
2384 s->compressed_len += 3 + s->opt_len;
2386 Assert (s->compressed_len == s->bits_sent, "bad compressed size");
2387 init_block(s);
2390 bi_windup(s);
2391 s->compressed_len += 7; /* align on byte boundary */
2393 Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
2394 s->compressed_len-7*eof));
2396 return s->compressed_len >> 3;
2403 local int ct_tally (s, dist, lc) in ct_tally() argument
2404 deflate_state *s; in ct_tally()
2408 s->d_buf[s->last_lit] = (ush)dist;
2409 s->l_buf[s->last_lit++] = (uch)lc;
2412 s->dyn_ltree[lc].Freq++;
2414 s->matches++;
2417 Assert((ush)dist < (ush)MAX_DIST(s) &&
2421 s->dyn_ltree[length_code[lc]+LITERALS+1].Freq++;
2422 s->dyn_dtree[d_code(dist)].Freq++;
2426 if (s->level > 2 && (s->last_lit & 0xfff) == 0) {
2428 ulg out_length = (ulg)s->last_lit*8L;
2429 ulg in_length = (ulg)s->strstart - s->block_start;
2432 out_length += (ulg)s->dyn_dtree[dcode].Freq *
2437 s->last_lit, in_length, out_length,
2439 if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
2441 return (s->last_lit == s->lit_bufsize-1);
2451 local void compress_block(s, ltree, dtree) in compress_block() argument
2452 deflate_state *s; in compress_block()
2462 if (s->last_lit != 0) do {
2463 dist = s->d_buf[lx];
2464 lc = s->l_buf[lx++];
2466 send_code(s, lc, ltree); /* send a literal byte */
2471 send_code(s, code+LITERALS+1, ltree); /* send the length code */
2475 send_bits(s, lc, extra); /* send the extra length bits */
2481 send_code(s, code, dtree); /* send the distance code */
2485 send_bits(s, dist, extra); /* send the extra distance bits */
2490 Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
2492 } while (lx < s->last_lit);
2494 send_code(s, END_BLOCK, ltree);
2495 s->last_eob_len = ltree[END_BLOCK].Len;
2504 local void set_data_type(s) in set_data_type() argument
2505 deflate_state *s; in set_data_type()
2510 while (n < 7) bin_freq += s->dyn_ltree[n++].Freq;
2511 while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq;
2512 while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq;
2513 s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? BINARY : ASCII);
2536 local void bi_flush(s) in bi_flush() argument
2537 deflate_state *s; in bi_flush()
2539 if (s->bi_valid == 16) {
2540 put_short(s, s->bi_buf);
2541 s->bi_buf = 0;
2542 s->bi_valid = 0;
2543 } else if (s->bi_valid >= 8) {
2544 put_byte(s, (Byte)s->bi_buf);
2545 s->bi_buf >>= 8;
2546 s->bi_valid -= 8;
2553 local void bi_windup(s) in bi_windup() argument
2554 deflate_state *s; in bi_windup()
2556 if (s->bi_valid > 8) {
2557 put_short(s, s->bi_buf);
2558 } else if (s->bi_valid > 0) {
2559 put_byte(s, (Byte)s->bi_buf);
2561 s->bi_buf = 0;
2562 s->bi_valid = 0;
2564 s->bits_sent = (s->bits_sent+7) & ~7;
2572 local void copy_block(s, buf, len, header) in copy_block() argument
2573 deflate_state *s; in copy_block()
2578 bi_windup(s); /* align on byte boundary */
2579 s->last_eob_len = 8; /* enough lookahead for inflate */
2582 put_short(s, (ush)len);
2583 put_short(s, (ush)~len);
2585 s->bits_sent += 2*16;
2589 s->bits_sent += (ulg)len<<3;
2592 put_byte(s, *buf++);
3105 #define UPDBITS {s->bitb=b;s->bitk=k;}
3107 #define UPDOUT {s->write=q;}
3109 #define LEAVE {UPDATE return inflate_flush(s,z,r);}
3111 #define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
3117 #define WAVAIL (q<s->read?s->read-q-1:s->end-q)
3118 #define LOADOUT {q=s->write;m=WAVAIL;}
3119 #define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=WAVAIL;}}
3120 #define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
3215 local void inflate_blocks_reset(s, z, c) in inflate_blocks_reset() argument
3216 inflate_blocks_statef *s; in inflate_blocks_reset()
3220 if (s->checkfn != Z_NULL)
3221 *c = s->check;
3222 if (s->mode == BTREE || s->mode == DTREE)
3223 ZFREE(z, s->sub.trees.blens, s->sub.trees.nblens * sizeof(uInt));
3224 if (s->mode == CODES)
3226 inflate_codes_free(s->sub.decode.codes, z);
3227 inflate_trees_free(s->sub.decode.td, z);
3228 inflate_trees_free(s->sub.decode.tl, z);
3230 s->mode = TYPE;
3231 s->bitk = 0;
3232 s->bitb = 0;
3233 s->read = s->write = s->window;
3234 if (s->checkfn != Z_NULL)
3235 s->check = (*s->checkfn)(0L, Z_NULL, 0);
3245 inflate_blocks_statef *s; local
3247 if ((s = (inflate_blocks_statef *)ZALLOC
3249 return s;
3250 if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
3252 ZFREE(z, s, sizeof(struct inflate_blocks_state));
3255 s->end = s->window + w;
3256 s->checkfn = c;
3257 s->mode = TYPE;
3259 inflate_blocks_reset(s, z, &s->check);
3260 return s;
3264 local int inflate_blocks(s, z, r) in inflate_blocks() argument
3265 inflate_blocks_statef *s; in inflate_blocks()
3281 while (1) switch (s->mode)
3286 s->last = t & 1;
3291 s->last ? " (last)" : ""));
3295 s->mode = LENS; /* get length of stored block */
3299 s->last ? " (last)" : ""));
3305 s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
3306 if (s->sub.decode.codes == Z_NULL)
3311 s->sub.decode.tl = Z_NULL; /* don't try to free these */
3312 s->sub.decode.td = Z_NULL;
3315 s->mode = CODES;
3319 s->last ? " (last)" : ""));
3321 s->mode = TABLE;
3325 s->mode = BADB;
3335 s->mode = BADB;
3340 s->sub.left = (uInt)b & 0xffff;
3342 Tracev((stderr, "inflate: stored length %u\n", s->sub.left));
3343 s->mode = s->sub.left ? STORED : TYPE;
3349 t = s->sub.left;
3355 if ((s->sub.left -= t) != 0)
3358 z->total_out + (q >= s->read ? q - s->read :
3359 (s->end - s->read) + (q - s->window))));
3360 s->mode = s->last ? DRY : TYPE;
3364 s->sub.trees.table = t = (uInt)b & 0x3fff;
3368 s->mode = BADB;
3377 if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
3382 s->sub.trees.nblens = t;
3384 s->sub.trees.index = 0;
3386 s->mode = BTREE;
3388 while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
3391 s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
3394 while (s->sub.trees.index < 19)
3395 s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
3396 s->sub.trees.bb = 7;
3397 t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
3398 &s->sub.trees.tb, z);
3403 s->mode = BADB;
3406 s->sub.trees.index = 0;
3408 s->mode = DTREE;
3410 while (t = s->sub.trees.table,
3411 s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
3416 t = s->sub.trees.bb;
3418 h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
3424 s->sub.trees.blens[s->sub.trees.index++] = c;
3434 i = s->sub.trees.index;
3435 t = s->sub.trees.table;
3439 s->mode = BADB;
3444 c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
3446 s->sub.trees.blens[i++] = c;
3448 s->sub.trees.index = i;
3451 inflate_trees_free(s->sub.trees.tb, z);
3452 s->sub.trees.tb = Z_NULL;
3460 t = s->sub.trees.table;
3462 s->sub.trees.blens, &bl, &bd, &tl, &td, z);
3466 s->mode = BADB;
3478 ZFREE(z, s->sub.trees.blens, s->sub.trees.nblens * sizeof(uInt));
3479 s->sub.decode.codes = c;
3480 s->sub.decode.tl = tl;
3481 s->sub.decode.td = td;
3483 s->mode = CODES;
3487 if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
3488 return inflate_flush(s, z, r);
3490 inflate_codes_free(s->sub.decode.codes, z);
3491 inflate_trees_free(s->sub.decode.td, z);
3492 inflate_trees_free(s->sub.decode.tl, z);
3495 z->total_out + (q >= s->read ? q - s->read :
3496 (s->end - s->read) + (q - s->window))));
3497 if (!s->last)
3499 s->mode = TYPE;
3509 s->mode = DRY;
3513 if (s->read != s->write)
3515 s->mode = DONEB;
3530 local int inflate_blocks_free(s, z, c) in inflate_blocks_free() argument
3531 inflate_blocks_statef *s; in inflate_blocks_free()
3535 inflate_blocks_reset(s, z, c);
3536 ZFREE(z, s->window, s->end - s->window);
3537 ZFREE(z, s, sizeof(struct inflate_blocks_state));
3550 local int inflate_addhistory(s, z) in inflate_addhistory() argument
3551 inflate_blocks_statef *s; in inflate_addhistory()
3562 if (s->read != s->write)
3564 if (s->mode != TYPE)
3577 if (s->checkfn != Z_NULL)
3578 s->check = (*s->checkfn)(s->check, q, t);
3584 s->read = q; /* drag read pointer forward */
3586 if (q == s->end) {
3587 s->read = q = s->window;
3600 local int inflate_packet_flush(s) in inflate_packet_flush() argument
3601 inflate_blocks_statef *s; in inflate_packet_flush()
3603 if (s->mode != LENS)
3605 s->mode = TYPE;
3701 local int huft_build(b, n, s, d, e, t, m, zs) in huft_build() argument
3704 uInt s; /* number of simple-valued codes (0..s-1) */
3868 else if (*p < s)
3875 r.exop = (Byte)e[*p - s] + 16 + 64; /* non-simple--look up in lists */
3876 r.base = d[*p++ - s];
3987 local voidpf falloc(q, n, s) in falloc() argument
3990 uInt s; /* size of item */
3992 Assert(s == sizeof(inflate_huft) && n <= fixed_left,
3994 if (q) s++; /* to make some compilers happy */
4153 local int inflate_codes(s, z, r) in inflate_codes() argument
4154 inflate_blocks_statef *s; in inflate_codes()
4168 inflate_codes_statef *c = s->sub.decode.codes; /* codes state */
4181 r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
4275 f = (uInt)(q - s->window) < c->sub.copy.dist ?
4276 s->end - (c->sub.copy.dist - (q - s->window)) :
4280 if ((uInt)(q - s->window) < c->sub.copy.dist)
4281 f = s->end - (c->sub.copy.dist - (q - s->window));
4287 if (f == s->end)
4288 f = s->window;
4300 if (s->read != s->write)
4332 local int inflate_flush(s, z, r) in inflate_flush() argument
4333 inflate_blocks_statef *s; in inflate_flush()
4342 q = s->read;
4345 n = (uInt)((q <= s->write ? s->write : s->end) - q);
4354 if (s->checkfn != Z_NULL)
4355 s->check = (*s->checkfn)(s->check, q, n);
4365 if (q == s->end)
4368 q = s->window;
4369 if (s->write == s->end)
4370 s->write = s->window;
4373 n = (uInt)(s->write - q);
4382 if (s->checkfn != Z_NULL)
4383 s->check = (*s->checkfn)(s->check, q, n);
4395 s->read = q;
4423 local int inflate_fast(bl, bd, tl, td, s, z) in inflate_fast() argument
4426 inflate_blocks_statef *s;
4490 if ((uInt)(q - s->window) >= d) /* offset before dest */
4498 e = d - (q - s->window); /* bytes from offset to end */
4499 r = s->end - e; /* pointer to offset */
4506 r = s->window; /* copy rest from start of window */