Lines Matching defs:s

139 local void init_block     OF((deflate_state *s));
140 local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
141 local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
143 local void build_tree OF((deflate_state *s, tree_desc *desc));
144 local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
145 local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
146 local int build_bl_tree OF((deflate_state *s));
147 local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
149 local void compress_block OF((deflate_state *s, const ct_data *ltree,
151 local int detect_data_type OF((deflate_state *s));
153 local void bi_windup OF((deflate_state *s));
154 local void bi_flush OF((deflate_state *s));
155 local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
163 # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
167 # define send_code(s, c, tree) \
169 send_bits(s, tree[c].Code, tree[c].Len); }
176 #define put_short(s, w) { \
177 put_byte(s, (uch)((w) & 0xff)); \
178 put_byte(s, (uch)((ush)(w) >> 8)); \
186 local void send_bits OF((deflate_state *s, int value, int length));
188 local void send_bits(s, value, length)
189 deflate_state *s;
195 s->bits_sent += (ulg)length;
201 if (s->bi_valid > (int)Buf_size - length) {
202 s->bi_buf |= (ush)value << s->bi_valid;
203 put_short(s, s->bi_buf);
204 s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
205 s->bi_valid += length - Buf_size;
207 s->bi_buf |= (ush)value << s->bi_valid;
208 s->bi_valid += length;
213 #define send_bits(s, value, length) \
215 if (s->bi_valid > (int)Buf_size - len) {\
217 s->bi_buf |= (ush)val << s->bi_valid;\
218 put_short(s, s->bi_buf);\
219 s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
220 s->bi_valid += len - Buf_size;\
222 s->bi_buf |= (ush)(value) << s->bi_valid;\
223 s->bi_valid += len;\
339 fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
345 fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
351 fprintf(header, "%2u%s", _dist_code[i],
358 fprintf(header, "%2u%s", _length_code[i],
364 fprintf(header, "%1u%s", base_length[i],
370 fprintf(header, "%5u%s", base_dist[i],
381 void ZLIB_INTERNAL _tr_init(s)
382 deflate_state *s;
386 s->l_desc.dyn_tree = s->dyn_ltree;
387 s->l_desc.stat_desc = &static_l_desc;
389 s->d_desc.dyn_tree = s->dyn_dtree;
390 s->d_desc.stat_desc = &static_d_desc;
392 s->bl_desc.dyn_tree = s->bl_tree;
393 s->bl_desc.stat_desc = &static_bl_desc;
395 s->bi_buf = 0;
396 s->bi_valid = 0;
398 s->compressed_len = 0L;
399 s->bits_sent = 0L;
403 init_block(s);
409 local void init_block(s)
410 deflate_state *s;
415 for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
416 for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
417 for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
419 s->dyn_ltree[END_BLOCK].Freq = 1;
420 s->opt_len = s->static_len = 0L;
421 s->last_lit = s->matches = 0;
432 #define pqremove(s, tree, top) \
434 top = s->heap[SMALLEST]; \
435 s->heap[SMALLEST] = s->heap[s->heap_len--]; \
436 pqdownheap(s, tree, SMALLEST); \
453 local void pqdownheap(s, tree, k)
454 deflate_state *s;
458 int v = s->heap[k];
460 while (j <= s->heap_len) {
462 if (j < s->heap_len &&
463 smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
467 if (smaller(tree, v, s->heap[j], s->depth)) break;
470 s->heap[k] = s->heap[j]; k = j;
475 s->heap[k] = v;
488 local void gen_bitlen(s, desc)
489 deflate_state *s;
505 for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
510 tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
512 for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
513 n = s->heap[h];
521 s->bl_count[bits]++;
525 s->opt_len += (ulg)f * (bits + xbits);
526 if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
536 while (s->bl_count[bits] == 0) bits--;
537 s->bl_count[bits]--; /* move one leaf down the tree */
538 s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
539 s->bl_count[max_length]--;
552 n = s->bl_count[bits];
554 m = s->heap[--h];
558 s->opt_len += ((long)bits - (long)tree[m].Len)
617 local void build_tree(s, desc)
618 deflate_state *s;
632 s->heap_len = 0, s->heap_max = HEAP_SIZE;
636 s->heap[++(s->heap_len)] = max_code = n;
637 s->depth[n] = 0;
648 while (s->heap_len < 2) {
649 node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
651 s->depth[node] = 0;
652 s->opt_len--; if (stree) s->static_len -= stree[node].Len;
660 for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
667 pqremove(s, tree, n); /* n = node of least frequency */
668 m = s->heap[SMALLEST]; /* m = node of next least frequency */
670 s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
671 s->heap[--(s->heap_max)] = m;
675 s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
676 s->depth[n] : s->depth[m]) + 1);
679 if (tree == s->bl_tree) {
685 s->heap[SMALLEST] = node++;
686 pqdownheap(s, tree, SMALLEST);
688 } while (s->heap_len >= 2);
690 s->heap[--(s->heap_max)] = s->heap[SMALLEST];
695 gen_bitlen(s, (tree_desc *)desc);
698 gen_codes ((ct_data *)tree, max_code, s->bl_count);
705 local void scan_tree (s, tree, max_code)
706 deflate_state *s;
726 s->bl_tree[curlen].Freq += count;
728 if (curlen != prevlen) s->bl_tree[curlen].Freq++;
729 s->bl_tree[REP_3_6].Freq++;
731 s->bl_tree[REPZ_3_10].Freq++;
733 s->bl_tree[REPZ_11_138].Freq++;
750 local void send_tree (s, tree, max_code)
751 deflate_state *s;
771 do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
775 send_code(s, curlen, s->bl_tree); count--;
778 send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
781 send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
784 send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
801 local int build_bl_tree(s)
802 deflate_state *s;
807 scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
808 scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
811 build_tree(s, (tree_desc *)(&(s->bl_desc)));
821 if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
824 s->opt_len += 3*(max_blindex+1) + 5+5+4;
826 s->opt_len, s->static_len));
836 local void send_all_trees(s, lcodes, dcodes, blcodes)
837 deflate_state *s;
846 send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
847 send_bits(s, dcodes-1, 5);
848 send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
851 send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
853 Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
855 send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
856 Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
858 send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
859 Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
865 void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
866 deflate_state *s;
871 send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
873 s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
874 s->compressed_len += (stored_len + 4) << 3;
876 copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
882 void ZLIB_INTERNAL _tr_flush_bits(s)
883 deflate_state *s;
885 bi_flush(s);
892 void ZLIB_INTERNAL _tr_align(s)
893 deflate_state *s;
895 send_bits(s, STATIC_TREES<<1, 3);
896 send_code(s, END_BLOCK, static_ltree);
898 s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
900 bi_flush(s);
907 void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
908 deflate_state *s;
917 if (s->level > 0) {
920 if (s->strm->data_type == Z_UNKNOWN)
921 s->strm->data_type = detect_data_type(s);
924 build_tree(s, (tree_desc *)(&(s->l_desc)));
925 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
926 s->static_len));
928 build_tree(s, (tree_desc *)(&(s->d_desc)));
929 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
930 s->static_len));
938 max_blindex = build_bl_tree(s);
941 opt_lenb = (s->opt_len+3+7)>>3;
942 static_lenb = (s->static_len+3+7)>>3;
945 opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
946 s->last_lit));
967 _tr_stored_block(s, buf, stored_len, last);
972 } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
974 send_bits(s, (STATIC_TREES<<1)+last, 3);
975 compress_block(s, (const ct_data *)static_ltree,
978 s->compressed_len += 3 + s->static_len;
981 send_bits(s, (DYN_TREES<<1)+last, 3);
982 send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
984 compress_block(s, (const ct_data *)s->dyn_ltree,
985 (const ct_data *)s->dyn_dtree);
987 s->compressed_len += 3 + s->opt_len;
990 Assert (s->compressed_len == s->bits_sent, "bad compressed size");
994 init_block(s);
997 bi_windup(s);
999 s->compressed_len += 7; /* align on byte boundary */
1002 Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
1003 s->compressed_len-7*last));
1010 int ZLIB_INTERNAL _tr_tally (s, dist, lc)
1011 deflate_state *s;
1015 s->d_buf[s->last_lit] = (ush)dist;
1016 s->l_buf[s->last_lit++] = (uch)lc;
1019 s->dyn_ltree[lc].Freq++;
1021 s->matches++;
1024 Assert((ush)dist < (ush)MAX_DIST(s) &&
1028 s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
1029 s->dyn_dtree[d_code(dist)].Freq++;
1034 if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
1036 ulg out_length = (ulg)s->last_lit*8L;
1037 ulg in_length = (ulg)((long)s->strstart - s->block_start);
1040 out_length += (ulg)s->dyn_dtree[dcode].Freq *
1045 s->last_lit, in_length, out_length,
1047 if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
1050 return (s->last_lit == s->lit_bufsize-1);
1060 local void compress_block(s, ltree, dtree)
1061 deflate_state *s;
1071 if (s->last_lit != 0) do {
1072 dist = s->d_buf[lx];
1073 lc = s->l_buf[lx++];
1075 send_code(s, lc, ltree); /* send a literal byte */
1080 send_code(s, code+LITERALS+1, ltree); /* send the length code */
1084 send_bits(s, lc, extra); /* send the extra length bits */
1090 send_code(s, code, dtree); /* send the distance code */
1094 send_bits(s, dist, extra); /* send the extra distance bits */
1099 Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
1102 } while (lx < s->last_lit);
1104 send_code(s, END_BLOCK, ltree);
1120 local int detect_data_type(s)
1121 deflate_state *s;
1132 if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
1136 if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
1137 || s->dyn_ltree[13].Freq != 0)
1140 if (s->dyn_ltree[n].Freq != 0)
1169 local void bi_flush(s)
1170 deflate_state *s;
1172 if (s->bi_valid == 16) {
1173 put_short(s, s->bi_buf);
1174 s->bi_buf = 0;
1175 s->bi_valid = 0;
1176 } else if (s->bi_valid >= 8) {
1177 put_byte(s, (Byte)s->bi_buf);
1178 s->bi_buf >>= 8;
1179 s->bi_valid -= 8;
1186 local void bi_windup(s)
1187 deflate_state *s;
1189 if (s->bi_valid > 8) {
1190 put_short(s, s->bi_buf);
1191 } else if (s->bi_valid > 0) {
1192 put_byte(s, (Byte)s->bi_buf);
1194 s->bi_buf = 0;
1195 s->bi_valid = 0;
1197 s->bits_sent = (s->bits_sent+7) & ~7;
1203 * one's complement if requested.
1205 local void copy_block(s, buf, len, header)
1206 deflate_state *s;
1211 bi_windup(s); /* align on byte boundary */
1214 put_short(s, (ush)len);
1215 put_short(s, (ush)~len);
1217 s->bits_sent += 2*16;
1221 s->bits_sent += (ulg)len<<3;
1224 put_byte(s, *buf++);