This source file includes following definitions.
- send_bits
- tr_static_init
- zlib_tr_init
- init_block
- pqdownheap
- gen_bitlen
- gen_codes
- build_tree
- scan_tree
- send_tree
- build_bl_tree
- send_all_trees
- zlib_tr_stored_block
- zlib_tr_stored_type_only
- zlib_tr_align
- zlib_tr_flush_block
- zlib_tr_tally
- compress_block
- set_data_type
- copy_block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 #include <linux/zutil.h>
38 #include <linux/bitrev.h>
39 #include "defutil.h"
40
41 #ifdef DEBUG_ZLIB
42 # include <ctype.h>
43 #endif
44
45
46
47
48
49 #define MAX_BL_BITS 7
50
51
52 #define END_BLOCK 256
53
54
55 #define REP_3_6 16
56
57
58 #define REPZ_3_10 17
59
60
61 #define REPZ_11_138 18
62
63
64 static const int extra_lbits[LENGTH_CODES]
65 = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
66
67 static const int extra_dbits[D_CODES]
68 = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
69
70 static const int extra_blbits[BL_CODES]
71 = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
72
73 static const uch bl_order[BL_CODES]
74 = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
75
76
77
78
79 #define Buf_size (8 * 2*sizeof(char))
80
81
82
83
84
85
86
87
88 static ct_data static_ltree[L_CODES+2];
89
90
91
92
93
94
95 static ct_data static_dtree[D_CODES];
96
97
98
99
100 static uch dist_code[512];
101
102
103
104
105
106 static uch length_code[MAX_MATCH-MIN_MATCH+1];
107
108
109 static int base_length[LENGTH_CODES];
110
111
112 static int base_dist[D_CODES];
113
114
115 struct static_tree_desc_s {
116 const ct_data *static_tree;
117 const int *extra_bits;
118 int extra_base;
119 int elems;
120 int max_length;
121 };
122
123 static static_tree_desc static_l_desc =
124 {static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
125
126 static static_tree_desc static_d_desc =
127 {static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
128
129 static static_tree_desc static_bl_desc =
130 {(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
131
132
133
134
135
136 static void tr_static_init (void);
137 static void init_block (deflate_state *s);
138 static void pqdownheap (deflate_state *s, ct_data *tree, int k);
139 static void gen_bitlen (deflate_state *s, tree_desc *desc);
140 static void gen_codes (ct_data *tree, int max_code, ush *bl_count);
141 static void build_tree (deflate_state *s, tree_desc *desc);
142 static void scan_tree (deflate_state *s, ct_data *tree, int max_code);
143 static void send_tree (deflate_state *s, ct_data *tree, int max_code);
144 static int build_bl_tree (deflate_state *s);
145 static void send_all_trees (deflate_state *s, int lcodes, int dcodes,
146 int blcodes);
147 static void compress_block (deflate_state *s, ct_data *ltree,
148 ct_data *dtree);
149 static void set_data_type (deflate_state *s);
150 static void bi_windup (deflate_state *s);
151 static void bi_flush (deflate_state *s);
152 static void copy_block (deflate_state *s, char *buf, unsigned len,
153 int header);
154
155 #ifndef DEBUG_ZLIB
156 # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
157
158
159 #else
160 # define send_code(s, c, tree) \
161 { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
162 send_bits(s, tree[c].Code, tree[c].Len); }
163 #endif
164
165 #define d_code(dist) \
166 ((dist) < 256 ? dist_code[dist] : dist_code[256+((dist)>>7)])
167
168
169
170
171
172
173
174
175
176 #ifdef DEBUG_ZLIB
177 static void send_bits (deflate_state *s, int value, int length);
178
179 static void send_bits(
180 deflate_state *s,
181 int value,
182 int length
183 )
184 {
185 Tracevv((stderr," l %2d v %4x ", length, value));
186 Assert(length > 0 && length <= 15, "invalid length");
187 s->bits_sent += (ulg)length;
188
189
190
191
192
193 if (s->bi_valid > (int)Buf_size - length) {
194 s->bi_buf |= (value << s->bi_valid);
195 put_short(s, s->bi_buf);
196 s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
197 s->bi_valid += length - Buf_size;
198 } else {
199 s->bi_buf |= value << s->bi_valid;
200 s->bi_valid += length;
201 }
202 }
203 #else
204
205 #define send_bits(s, value, length) \
206 { int len = length;\
207 if (s->bi_valid > (int)Buf_size - len) {\
208 int val = value;\
209 s->bi_buf |= (val << s->bi_valid);\
210 put_short(s, s->bi_buf);\
211 s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
212 s->bi_valid += len - Buf_size;\
213 } else {\
214 s->bi_buf |= (value) << s->bi_valid;\
215 s->bi_valid += len;\
216 }\
217 }
218 #endif
219
220
221
222
223
224
225 static void tr_static_init(void)
226 {
227 static int static_init_done;
228 int n;
229 int bits;
230 int length;
231 int code;
232 int dist;
233 ush bl_count[MAX_BITS+1];
234
235
236 if (static_init_done) return;
237
238
239 length = 0;
240 for (code = 0; code < LENGTH_CODES-1; code++) {
241 base_length[code] = length;
242 for (n = 0; n < (1<<extra_lbits[code]); n++) {
243 length_code[length++] = (uch)code;
244 }
245 }
246 Assert (length == 256, "tr_static_init: length != 256");
247
248
249
250
251 length_code[length-1] = (uch)code;
252
253
254 dist = 0;
255 for (code = 0 ; code < 16; code++) {
256 base_dist[code] = dist;
257 for (n = 0; n < (1<<extra_dbits[code]); n++) {
258 dist_code[dist++] = (uch)code;
259 }
260 }
261 Assert (dist == 256, "tr_static_init: dist != 256");
262 dist >>= 7;
263 for ( ; code < D_CODES; code++) {
264 base_dist[code] = dist << 7;
265 for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
266 dist_code[256 + dist++] = (uch)code;
267 }
268 }
269 Assert (dist == 256, "tr_static_init: 256+dist != 512");
270
271
272 for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
273 n = 0;
274 while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
275 while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
276 while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
277 while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
278
279
280
281
282 gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
283
284
285 for (n = 0; n < D_CODES; n++) {
286 static_dtree[n].Len = 5;
287 static_dtree[n].Code = bitrev32((u32)n) >> (32 - 5);
288 }
289 static_init_done = 1;
290 }
291
292
293
294
295 void zlib_tr_init(
296 deflate_state *s
297 )
298 {
299 tr_static_init();
300
301 s->compressed_len = 0L;
302
303 s->l_desc.dyn_tree = s->dyn_ltree;
304 s->l_desc.stat_desc = &static_l_desc;
305
306 s->d_desc.dyn_tree = s->dyn_dtree;
307 s->d_desc.stat_desc = &static_d_desc;
308
309 s->bl_desc.dyn_tree = s->bl_tree;
310 s->bl_desc.stat_desc = &static_bl_desc;
311
312 s->bi_buf = 0;
313 s->bi_valid = 0;
314 s->last_eob_len = 8;
315 #ifdef DEBUG_ZLIB
316 s->bits_sent = 0L;
317 #endif
318
319
320 init_block(s);
321 }
322
323
324
325
326 static void init_block(
327 deflate_state *s
328 )
329 {
330 int n;
331
332
333 for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
334 for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
335 for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
336
337 s->dyn_ltree[END_BLOCK].Freq = 1;
338 s->opt_len = s->static_len = 0L;
339 s->last_lit = s->matches = 0;
340 }
341
342 #define SMALLEST 1
343
344
345
346
347
348
349
350 #define pqremove(s, tree, top) \
351 {\
352 top = s->heap[SMALLEST]; \
353 s->heap[SMALLEST] = s->heap[s->heap_len--]; \
354 pqdownheap(s, tree, SMALLEST); \
355 }
356
357
358
359
360
361 #define smaller(tree, n, m, depth) \
362 (tree[n].Freq < tree[m].Freq || \
363 (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
364
365
366
367
368
369
370
371 static void pqdownheap(
372 deflate_state *s,
373 ct_data *tree,
374 int k
375 )
376 {
377 int v = s->heap[k];
378 int j = k << 1;
379 while (j <= s->heap_len) {
380
381 if (j < s->heap_len &&
382 smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
383 j++;
384 }
385
386 if (smaller(tree, v, s->heap[j], s->depth)) break;
387
388
389 s->heap[k] = s->heap[j]; k = j;
390
391
392 j <<= 1;
393 }
394 s->heap[k] = v;
395 }
396
397
398
399
400
401
402
403
404
405
406
407 static void gen_bitlen(
408 deflate_state *s,
409 tree_desc *desc
410 )
411 {
412 ct_data *tree = desc->dyn_tree;
413 int max_code = desc->max_code;
414 const ct_data *stree = desc->stat_desc->static_tree;
415 const int *extra = desc->stat_desc->extra_bits;
416 int base = desc->stat_desc->extra_base;
417 int max_length = desc->stat_desc->max_length;
418 int h;
419 int n, m;
420 int bits;
421 int xbits;
422 ush f;
423 int overflow = 0;
424
425 for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
426
427
428
429
430 tree[s->heap[s->heap_max]].Len = 0;
431
432 for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
433 n = s->heap[h];
434 bits = tree[tree[n].Dad].Len + 1;
435 if (bits > max_length) bits = max_length, overflow++;
436 tree[n].Len = (ush)bits;
437
438
439 if (n > max_code) continue;
440
441 s->bl_count[bits]++;
442 xbits = 0;
443 if (n >= base) xbits = extra[n-base];
444 f = tree[n].Freq;
445 s->opt_len += (ulg)f * (bits + xbits);
446 if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
447 }
448 if (overflow == 0) return;
449
450 Trace((stderr,"\nbit length overflow\n"));
451
452
453
454 do {
455 bits = max_length-1;
456 while (s->bl_count[bits] == 0) bits--;
457 s->bl_count[bits]--;
458 s->bl_count[bits+1] += 2;
459 s->bl_count[max_length]--;
460
461
462
463 overflow -= 2;
464 } while (overflow > 0);
465
466
467
468
469
470
471 for (bits = max_length; bits != 0; bits--) {
472 n = s->bl_count[bits];
473 while (n != 0) {
474 m = s->heap[--h];
475 if (m > max_code) continue;
476 if (tree[m].Len != (unsigned) bits) {
477 Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
478 s->opt_len += ((long)bits - (long)tree[m].Len)
479 *(long)tree[m].Freq;
480 tree[m].Len = (ush)bits;
481 }
482 n--;
483 }
484 }
485 }
486
487
488
489
490
491
492
493
494
495 static void gen_codes(
496 ct_data *tree,
497 int max_code,
498 ush *bl_count
499 )
500 {
501 ush next_code[MAX_BITS+1];
502 ush code = 0;
503 int bits;
504 int n;
505
506
507
508
509 for (bits = 1; bits <= MAX_BITS; bits++) {
510 next_code[bits] = code = (code + bl_count[bits-1]) << 1;
511 }
512
513
514
515 Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
516 "inconsistent bit counts");
517 Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
518
519 for (n = 0; n <= max_code; n++) {
520 int len = tree[n].Len;
521 if (len == 0) continue;
522
523 tree[n].Code = bitrev32((u32)(next_code[len]++)) >> (32 - len);
524
525 Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
526 n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
527 }
528 }
529
530
531
532
533
534
535
536
537
538 static void build_tree(
539 deflate_state *s,
540 tree_desc *desc
541 )
542 {
543 ct_data *tree = desc->dyn_tree;
544 const ct_data *stree = desc->stat_desc->static_tree;
545 int elems = desc->stat_desc->elems;
546 int n, m;
547 int max_code = -1;
548 int node;
549
550
551
552
553
554 s->heap_len = 0, s->heap_max = HEAP_SIZE;
555
556 for (n = 0; n < elems; n++) {
557 if (tree[n].Freq != 0) {
558 s->heap[++(s->heap_len)] = max_code = n;
559 s->depth[n] = 0;
560 } else {
561 tree[n].Len = 0;
562 }
563 }
564
565
566
567
568
569
570 while (s->heap_len < 2) {
571 node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
572 tree[node].Freq = 1;
573 s->depth[node] = 0;
574 s->opt_len--; if (stree) s->static_len -= stree[node].Len;
575
576 }
577 desc->max_code = max_code;
578
579
580
581
582 for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
583
584
585
586
587 node = elems;
588 do {
589 pqremove(s, tree, n);
590 m = s->heap[SMALLEST];
591
592 s->heap[--(s->heap_max)] = n;
593 s->heap[--(s->heap_max)] = m;
594
595
596 tree[node].Freq = tree[n].Freq + tree[m].Freq;
597 s->depth[node] = (uch) (max(s->depth[n], s->depth[m]) + 1);
598 tree[n].Dad = tree[m].Dad = (ush)node;
599 #ifdef DUMP_BL_TREE
600 if (tree == s->bl_tree) {
601 fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
602 node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
603 }
604 #endif
605
606 s->heap[SMALLEST] = node++;
607 pqdownheap(s, tree, SMALLEST);
608
609 } while (s->heap_len >= 2);
610
611 s->heap[--(s->heap_max)] = s->heap[SMALLEST];
612
613
614
615
616 gen_bitlen(s, (tree_desc *)desc);
617
618
619 gen_codes ((ct_data *)tree, max_code, s->bl_count);
620 }
621
622
623
624
625
626 static void scan_tree(
627 deflate_state *s,
628 ct_data *tree,
629 int max_code
630 )
631 {
632 int n;
633 int prevlen = -1;
634 int curlen;
635 int nextlen = tree[0].Len;
636 int count = 0;
637 int max_count = 7;
638 int min_count = 4;
639
640 if (nextlen == 0) max_count = 138, min_count = 3;
641 tree[max_code+1].Len = (ush)0xffff;
642
643 for (n = 0; n <= max_code; n++) {
644 curlen = nextlen; nextlen = tree[n+1].Len;
645 if (++count < max_count && curlen == nextlen) {
646 continue;
647 } else if (count < min_count) {
648 s->bl_tree[curlen].Freq += count;
649 } else if (curlen != 0) {
650 if (curlen != prevlen) s->bl_tree[curlen].Freq++;
651 s->bl_tree[REP_3_6].Freq++;
652 } else if (count <= 10) {
653 s->bl_tree[REPZ_3_10].Freq++;
654 } else {
655 s->bl_tree[REPZ_11_138].Freq++;
656 }
657 count = 0; prevlen = curlen;
658 if (nextlen == 0) {
659 max_count = 138, min_count = 3;
660 } else if (curlen == nextlen) {
661 max_count = 6, min_count = 3;
662 } else {
663 max_count = 7, min_count = 4;
664 }
665 }
666 }
667
668
669
670
671
672 static void send_tree(
673 deflate_state *s,
674 ct_data *tree,
675 int max_code
676 )
677 {
678 int n;
679 int prevlen = -1;
680 int curlen;
681 int nextlen = tree[0].Len;
682 int count = 0;
683 int max_count = 7;
684 int min_count = 4;
685
686
687 if (nextlen == 0) max_count = 138, min_count = 3;
688
689 for (n = 0; n <= max_code; n++) {
690 curlen = nextlen; nextlen = tree[n+1].Len;
691 if (++count < max_count && curlen == nextlen) {
692 continue;
693 } else if (count < min_count) {
694 do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
695
696 } else if (curlen != 0) {
697 if (curlen != prevlen) {
698 send_code(s, curlen, s->bl_tree); count--;
699 }
700 Assert(count >= 3 && count <= 6, " 3_6?");
701 send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
702
703 } else if (count <= 10) {
704 send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
705
706 } else {
707 send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
708 }
709 count = 0; prevlen = curlen;
710 if (nextlen == 0) {
711 max_count = 138, min_count = 3;
712 } else if (curlen == nextlen) {
713 max_count = 6, min_count = 3;
714 } else {
715 max_count = 7, min_count = 4;
716 }
717 }
718 }
719
720
721
722
723
724 static int build_bl_tree(
725 deflate_state *s
726 )
727 {
728 int max_blindex;
729
730
731 scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
732 scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
733
734
735 build_tree(s, (tree_desc *)(&(s->bl_desc)));
736
737
738
739
740
741
742
743
744 for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
745 if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
746 }
747
748 s->opt_len += 3*(max_blindex+1) + 5+5+4;
749 Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
750 s->opt_len, s->static_len));
751
752 return max_blindex;
753 }
754
755
756
757
758
759
760 static void send_all_trees(
761 deflate_state *s,
762 int lcodes,
763 int dcodes,
764 int blcodes
765 )
766 {
767 int rank;
768
769 Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
770 Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
771 "too many codes");
772 Tracev((stderr, "\nbl counts: "));
773 send_bits(s, lcodes-257, 5);
774 send_bits(s, dcodes-1, 5);
775 send_bits(s, blcodes-4, 4);
776 for (rank = 0; rank < blcodes; rank++) {
777 Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
778 send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
779 }
780 Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
781
782 send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1);
783 Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
784
785 send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1);
786 Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
787 }
788
789
790
791
792 void zlib_tr_stored_block(
793 deflate_state *s,
794 char *buf,
795 ulg stored_len,
796 int eof
797 )
798 {
799 send_bits(s, (STORED_BLOCK<<1)+eof, 3);
800 s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
801 s->compressed_len += (stored_len + 4) << 3;
802
803 copy_block(s, buf, (unsigned)stored_len, 1);
804 }
805
806
807
808 void zlib_tr_stored_type_only(
809 deflate_state *s
810 )
811 {
812 send_bits(s, (STORED_BLOCK << 1), 3);
813 bi_windup(s);
814 s->compressed_len = (s->compressed_len + 3) & ~7L;
815 }
816
817
818
819
820
821
822
823
824
825
826
827
828
829 void zlib_tr_align(
830 deflate_state *s
831 )
832 {
833 send_bits(s, STATIC_TREES<<1, 3);
834 send_code(s, END_BLOCK, static_ltree);
835 s->compressed_len += 10L;
836 bi_flush(s);
837
838
839
840
841
842 if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
843 send_bits(s, STATIC_TREES<<1, 3);
844 send_code(s, END_BLOCK, static_ltree);
845 s->compressed_len += 10L;
846 bi_flush(s);
847 }
848 s->last_eob_len = 7;
849 }
850
851
852
853
854
855
856 ulg zlib_tr_flush_block(
857 deflate_state *s,
858 char *buf,
859 ulg stored_len,
860 int eof
861 )
862 {
863 ulg opt_lenb, static_lenb;
864 int max_blindex = 0;
865
866
867 if (s->level > 0) {
868
869
870 if (s->data_type == Z_UNKNOWN) set_data_type(s);
871
872
873 build_tree(s, (tree_desc *)(&(s->l_desc)));
874 Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
875 s->static_len));
876
877 build_tree(s, (tree_desc *)(&(s->d_desc)));
878 Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
879 s->static_len));
880
881
882
883
884
885
886
887 max_blindex = build_bl_tree(s);
888
889
890 opt_lenb = (s->opt_len+3+7)>>3;
891 static_lenb = (s->static_len+3+7)>>3;
892
893 Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
894 opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
895 s->last_lit));
896
897 if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
898
899 } else {
900 Assert(buf != (char*)0, "lost buf");
901 opt_lenb = static_lenb = stored_len + 5;
902 }
903
904
905
906
907
908 #ifdef STORED_FILE_OK
909 # ifdef FORCE_STORED_FILE
910 if (eof && s->compressed_len == 0L) {
911 # else
912 if (stored_len <= opt_lenb && eof && s->compressed_len==0L && seekable()) {
913 # endif
914
915 if (buf == (char*)0) error ("block vanished");
916
917 copy_block(s, buf, (unsigned)stored_len, 0);
918 s->compressed_len = stored_len << 3;
919 s->method = STORED;
920 } else
921 #endif
922
923 #ifdef FORCE_STORED
924 if (buf != (char*)0) {
925 #else
926 if (stored_len+4 <= opt_lenb && buf != (char*)0) {
927
928 #endif
929
930
931
932
933
934
935 zlib_tr_stored_block(s, buf, stored_len, eof);
936
937 #ifdef FORCE_STATIC
938 } else if (static_lenb >= 0) {
939 #else
940 } else if (static_lenb == opt_lenb) {
941 #endif
942 send_bits(s, (STATIC_TREES<<1)+eof, 3);
943 compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
944 s->compressed_len += 3 + s->static_len;
945 } else {
946 send_bits(s, (DYN_TREES<<1)+eof, 3);
947 send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
948 max_blindex+1);
949 compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
950 s->compressed_len += 3 + s->opt_len;
951 }
952 Assert (s->compressed_len == s->bits_sent, "bad compressed size");
953 init_block(s);
954
955 if (eof) {
956 bi_windup(s);
957 s->compressed_len += 7;
958 }
959 Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
960 s->compressed_len-7*eof));
961
962 return s->compressed_len >> 3;
963 }
964
965
966
967
968
969 int zlib_tr_tally(
970 deflate_state *s,
971 unsigned dist,
972 unsigned lc
973 )
974 {
975 s->d_buf[s->last_lit] = (ush)dist;
976 s->l_buf[s->last_lit++] = (uch)lc;
977 if (dist == 0) {
978
979 s->dyn_ltree[lc].Freq++;
980 } else {
981 s->matches++;
982
983 dist--;
984 Assert((ush)dist < (ush)MAX_DIST(s) &&
985 (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
986 (ush)d_code(dist) < (ush)D_CODES, "zlib_tr_tally: bad match");
987
988 s->dyn_ltree[length_code[lc]+LITERALS+1].Freq++;
989 s->dyn_dtree[d_code(dist)].Freq++;
990 }
991
992
993 if ((s->last_lit & 0xfff) == 0 && s->level > 2) {
994
995 ulg out_length = (ulg)s->last_lit*8L;
996 ulg in_length = (ulg)((long)s->strstart - s->block_start);
997 int dcode;
998 for (dcode = 0; dcode < D_CODES; dcode++) {
999 out_length += (ulg)s->dyn_dtree[dcode].Freq *
1000 (5L+extra_dbits[dcode]);
1001 }
1002 out_length >>= 3;
1003 Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
1004 s->last_lit, in_length, out_length,
1005 100L - out_length*100L/in_length));
1006 if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
1007 }
1008 return (s->last_lit == s->lit_bufsize-1);
1009
1010
1011
1012
1013 }
1014
1015
1016
1017
1018 static void compress_block(
1019 deflate_state *s,
1020 ct_data *ltree,
1021 ct_data *dtree
1022 )
1023 {
1024 unsigned dist;
1025 int lc;
1026 unsigned lx = 0;
1027 unsigned code;
1028 int extra;
1029
1030 if (s->last_lit != 0) do {
1031 dist = s->d_buf[lx];
1032 lc = s->l_buf[lx++];
1033 if (dist == 0) {
1034 send_code(s, lc, ltree);
1035 Tracecv(isgraph(lc), (stderr," '%c' ", lc));
1036 } else {
1037
1038 code = length_code[lc];
1039 send_code(s, code+LITERALS+1, ltree);
1040 extra = extra_lbits[code];
1041 if (extra != 0) {
1042 lc -= base_length[code];
1043 send_bits(s, lc, extra);
1044 }
1045 dist--;
1046 code = d_code(dist);
1047 Assert (code < D_CODES, "bad d_code");
1048
1049 send_code(s, code, dtree);
1050 extra = extra_dbits[code];
1051 if (extra != 0) {
1052 dist -= base_dist[code];
1053 send_bits(s, dist, extra);
1054 }
1055 }
1056
1057
1058 Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
1059
1060 } while (lx < s->last_lit);
1061
1062 send_code(s, END_BLOCK, ltree);
1063 s->last_eob_len = ltree[END_BLOCK].Len;
1064 }
1065
1066
1067
1068
1069
1070
1071
1072 static void set_data_type(
1073 deflate_state *s
1074 )
1075 {
1076 int n = 0;
1077 unsigned ascii_freq = 0;
1078 unsigned bin_freq = 0;
1079 while (n < 7) bin_freq += s->dyn_ltree[n++].Freq;
1080 while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq;
1081 while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq;
1082 s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII);
1083 }
1084
1085
1086
1087
1088
1089 static void copy_block(
1090 deflate_state *s,
1091 char *buf,
1092 unsigned len,
1093 int header
1094 )
1095 {
1096 bi_windup(s);
1097 s->last_eob_len = 8;
1098
1099 if (header) {
1100 put_short(s, (ush)len);
1101 put_short(s, (ush)~len);
1102 #ifdef DEBUG_ZLIB
1103 s->bits_sent += 2*16;
1104 #endif
1105 }
1106 #ifdef DEBUG_ZLIB
1107 s->bits_sent += (ulg)len<<3;
1108 #endif
1109
1110 memcpy(&s->pending_buf[s->pending], buf, len);
1111 s->pending += len;
1112 }
1113