Lines Matching +full:no +full:- +full:scan +full:- +full:on +full:- +full:init
1 /* deflate.c -- compress data using the deflation algorithm
2 * Copyright (C) 1995-2024 Jean-loup Gailly and Mark Adler
9 * The "deflation" process depends on being able to identify portions
23 * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
33 * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
43 * "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
46 * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
55 " deflate 1.3.1 Copyright 1995-2024 Jean-loup Gailly and Mark Adler ";
67 finish_done /* finish done, accept no more input or output */
93 /* Values for max_lazy_match, good_match and max_chain_length, depending on
110 /* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */
115 /* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */
133 #define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
141 #define UPDATE_HASH(s,h,c) (h = (((h) << s->hash_shift) ^ (c)) & s->hash_mask)
148 * If this file is compiled with -DFASTEST, the compression level is forced
149 * to 1, and no hash chains are maintained.
152 * the last MIN_MATCH-1 bytes of the input file).
156 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
157 match_head = s->head[s->ins_h], \
158 s->head[s->ins_h] = (Pos)(str))
161 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
162 match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
163 s->head[s->ins_h] = (Pos)(str))
168 * prev[] will be initialized on the fly.
172 s->head[s->hash_size - 1] = NIL; \
173 zmemzero((Bytef *)s->head, \
174 (unsigned)(s->hash_size - 1)*sizeof(*s->head)); \
190 uInt wsize = s->w_size; in slide_hash()
192 n = s->hash_size; in slide_hash()
193 p = &s->head[n]; in slide_hash()
195 m = *--p; in slide_hash()
196 *p = (Pos)(m >= wsize ? m - wsize : NIL); in slide_hash()
197 } while (--n); in slide_hash()
200 p = &s->prev[n]; in slide_hash()
202 m = *--p; in slide_hash()
203 *p = (Pos)(m >= wsize ? m - wsize : NIL); in slide_hash()
204 /* If n is not on any hash chain, prev[n] is garbage but in slide_hash()
207 } while (--n); in slide_hash()
215 * allocating a large strm->next_in buffer and copying from it.
219 unsigned len = strm->avail_in; in read_buf()
224 strm->avail_in -= len; in read_buf()
226 zmemcpy(buf, strm->next_in, len); in read_buf()
227 if (strm->state->wrap == 1) { in read_buf()
228 strm->adler = adler32(strm->adler, buf, len); in read_buf()
231 else if (strm->state->wrap == 2) { in read_buf()
232 strm->adler = crc32(strm->adler, buf, len); in read_buf()
235 strm->next_in += len; in read_buf()
236 strm->total_in += len; in read_buf()
246 * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
249 * option -- not supported here).
254 uInt wsize = s->w_size; in fill_window()
256 Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); in fill_window()
259 more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); in fill_window()
263 if (more == 0 && s->strstart == 0 && s->lookahead == 0) { in fill_window()
266 } else if (more == (unsigned)(-1)) { in fill_window()
267 /* Very unlikely, but possible on 16 bit machine if in fill_window()
270 more--; in fill_window()
277 if (s->strstart >= wsize + MAX_DIST(s)) { in fill_window()
279 zmemcpy(s->window, s->window + wsize, (unsigned)wsize - more); in fill_window()
280 s->match_start -= wsize; in fill_window()
281 s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ in fill_window()
282 s->block_start -= (long) wsize; in fill_window()
283 if (s->insert > s->strstart) in fill_window()
284 s->insert = s->strstart; in fill_window()
288 if (s->strm->avail_in == 0) break; in fill_window()
290 /* If there was no sliding: in fill_window()
291 * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && in fill_window()
292 * more == window_size - lookahead - strstart in fill_window()
293 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) in fill_window()
294 * => more >= window_size - 2*WSIZE + 2 in fill_window()
297 * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. in fill_window()
303 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); in fill_window()
304 s->lookahead += n; in fill_window()
307 if (s->lookahead + s->insert >= MIN_MATCH) { in fill_window()
308 uInt str = s->strstart - s->insert; in fill_window()
309 s->ins_h = s->window[str]; in fill_window()
310 UPDATE_HASH(s, s->ins_h, s->window[str + 1]); in fill_window()
312 Call UPDATE_HASH() MIN_MATCH-3 more times in fill_window()
314 while (s->insert) { in fill_window()
315 UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); in fill_window()
317 s->prev[str & s->w_mask] = s->head[s->ins_h]; in fill_window()
319 s->head[s->ins_h] = (Pos)str; in fill_window()
321 s->insert--; in fill_window()
322 if (s->lookahead + s->insert < MIN_MATCH) in fill_window()
330 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); in fill_window()
339 if (s->high_water < s->window_size) { in fill_window()
340 ulg curr = s->strstart + (ulg)(s->lookahead); in fill_window()
341 ulg init; in fill_window() local
343 if (s->high_water < curr) { in fill_window()
344 /* Previous high water mark below current data -- zero WIN_INIT in fill_window()
347 init = s->window_size - curr; in fill_window()
348 if (init > WIN_INIT) in fill_window()
349 init = WIN_INIT; in fill_window()
350 zmemzero(s->window + curr, (unsigned)init); in fill_window()
351 s->high_water = curr + init; in fill_window()
353 else if (s->high_water < (ulg)curr + WIN_INIT) { in fill_window()
355 * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up in fill_window()
358 init = (ulg)curr + WIN_INIT - s->high_water; in fill_window()
359 if (init > s->window_size - s->high_water) in fill_window()
360 init = s->window_size - s->high_water; in fill_window()
361 zmemzero(s->window + s->high_water, (unsigned)init); in fill_window()
362 s->high_water += init; in fill_window()
366 Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, in fill_window()
375 /* To do: ignore strm->next_in if we use it as window */ in deflateInit_()
392 strm->msg = Z_NULL; in deflateInit2_()
393 if (strm->zalloc == (alloc_func)0) { in deflateInit2_()
397 strm->zalloc = zcalloc; in deflateInit2_()
398 strm->opaque = (voidpf)0; in deflateInit2_()
401 if (strm->zfree == (free_func)0) in deflateInit2_()
405 strm->zfree = zcfree; in deflateInit2_()
416 if (windowBits < -15) in deflateInit2_()
418 windowBits = -windowBits; in deflateInit2_()
423 windowBits -= 16; in deflateInit2_()
431 if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ in deflateInit2_()
434 strm->state = (struct internal_state FAR *)s; in deflateInit2_()
435 s->strm = strm; in deflateInit2_()
436 s->status = INIT_STATE; /* to pass state test in deflateReset() */ in deflateInit2_()
438 s->wrap = wrap; in deflateInit2_()
439 s->gzhead = Z_NULL; in deflateInit2_()
440 s->w_bits = (uInt)windowBits; in deflateInit2_()
441 s->w_size = 1 << s->w_bits; in deflateInit2_()
442 s->w_mask = s->w_size - 1; in deflateInit2_()
444 s->hash_bits = (uInt)memLevel + 7; in deflateInit2_()
445 s->hash_size = 1 << s->hash_bits; in deflateInit2_()
446 s->hash_mask = s->hash_size - 1; in deflateInit2_()
447 s->hash_shift = ((s->hash_bits + MIN_MATCH-1) / MIN_MATCH); in deflateInit2_()
449 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); in deflateInit2_()
450 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); in deflateInit2_()
451 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); in deflateInit2_()
453 s->high_water = 0; /* nothing written to s->window yet */ in deflateInit2_()
455 s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ in deflateInit2_()
464 * possible fixed-codes length/distance pair is then 31 bits total. in deflateInit2_()
466 * sym_buf starts one-fourth of the way into pending_buf. So there are in deflateInit2_()
468 * in sym_buf is three bytes -- two for the distance and one for the in deflateInit2_()
473 * code is written. At that time, 31*(n - 2) bits have been written, just in deflateInit2_()
474 * after 24*(n - 2) bits have been consumed from sym_buf. sym_buf starts at in deflateInit2_()
475 * 8*n bits into pending_buf. (Note that the symbol buffer fills when n - 1 in deflateInit2_()
483 * due to the three-bit fixed-code block header. in deflateInit2_()
489 * blocks. A dynamic-code block will only be chosen to be emitted if it has in deflateInit2_()
490 * fewer bits than a fixed-code block would for the same set of symbols. in deflateInit2_()
496 s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, LIT_BUFS); in deflateInit2_()
497 s->pending_buf_size = (ulg)s->lit_bufsize * 4; in deflateInit2_()
499 if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || in deflateInit2_()
500 s->pending_buf == Z_NULL) { in deflateInit2_()
501 s->status = FINISH_STATE; in deflateInit2_()
502 strm->msg = ERR_MSG(Z_MEM_ERROR); in deflateInit2_()
507 s->d_buf = (ushf *)(s->pending_buf + (s->lit_bufsize << 1)); in deflateInit2_()
508 s->l_buf = s->pending_buf + (s->lit_bufsize << 2); in deflateInit2_()
509 s->sym_end = s->lit_bufsize - 1; in deflateInit2_()
511 s->sym_buf = s->pending_buf + s->lit_bufsize; in deflateInit2_()
512 s->sym_end = (s->lit_bufsize - 1) * 3; in deflateInit2_()
515 * on 16 bit machines and because stored blocks are restricted to in deflateInit2_()
516 * 64K-1 bytes. in deflateInit2_()
519 s->level = level; in deflateInit2_()
520 s->strategy = strategy; in deflateInit2_()
521 s->method = (Byte)method; in deflateInit2_()
532 strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) in deflateStateCheck()
534 s = strm->state; in deflateStateCheck()
535 if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE && in deflateStateCheck()
537 s->status != GZIP_STATE && in deflateStateCheck()
539 s->status != EXTRA_STATE && in deflateStateCheck()
540 s->status != NAME_STATE && in deflateStateCheck()
541 s->status != COMMENT_STATE && in deflateStateCheck()
542 s->status != HCRC_STATE && in deflateStateCheck()
543 s->status != BUSY_STATE && in deflateStateCheck()
544 s->status != FINISH_STATE)) in deflateStateCheck()
560 s = strm->state; in deflateSetDictionary()
561 wrap = s->wrap; in deflateSetDictionary()
562 if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead) in deflateSetDictionary()
565 /* when using zlib wrappers, compute Adler-32 for provided dictionary */ in deflateSetDictionary()
567 strm->adler = adler32(strm->adler, dictionary, dictLength); in deflateSetDictionary()
568 s->wrap = 0; /* avoid computing Adler-32 in read_buf */ in deflateSetDictionary()
571 if (dictLength >= s->w_size) { in deflateSetDictionary()
574 s->strstart = 0; in deflateSetDictionary()
575 s->block_start = 0L; in deflateSetDictionary()
576 s->insert = 0; in deflateSetDictionary()
578 dictionary += dictLength - s->w_size; /* use the tail */ in deflateSetDictionary()
579 dictLength = s->w_size; in deflateSetDictionary()
583 avail = strm->avail_in; in deflateSetDictionary()
584 next = strm->next_in; in deflateSetDictionary()
585 strm->avail_in = dictLength; in deflateSetDictionary()
586 strm->next_in = (z_const Bytef *)dictionary; in deflateSetDictionary()
588 while (s->lookahead >= MIN_MATCH) { in deflateSetDictionary()
589 str = s->strstart; in deflateSetDictionary()
590 n = s->lookahead - (MIN_MATCH-1); in deflateSetDictionary()
592 UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); in deflateSetDictionary()
594 s->prev[str & s->w_mask] = s->head[s->ins_h]; in deflateSetDictionary()
596 s->head[s->ins_h] = (Pos)str; in deflateSetDictionary()
598 } while (--n); in deflateSetDictionary()
599 s->strstart = str; in deflateSetDictionary()
600 s->lookahead = MIN_MATCH-1; in deflateSetDictionary()
603 s->strstart += s->lookahead; in deflateSetDictionary()
604 s->block_start = (long)s->strstart; in deflateSetDictionary()
605 s->insert = s->lookahead; in deflateSetDictionary()
606 s->lookahead = 0; in deflateSetDictionary()
607 s->match_length = s->prev_length = MIN_MATCH-1; in deflateSetDictionary()
608 s->match_available = 0; in deflateSetDictionary()
609 strm->next_in = next; in deflateSetDictionary()
610 strm->avail_in = avail; in deflateSetDictionary()
611 s->wrap = wrap; in deflateSetDictionary()
623 s = strm->state; in deflateGetDictionary()
624 len = s->strstart + s->lookahead; in deflateGetDictionary()
625 if (len > s->w_size) in deflateGetDictionary()
626 len = s->w_size; in deflateGetDictionary()
628 zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len); in deflateGetDictionary()
642 strm->total_in = strm->total_out = 0; in deflateResetKeep()
643 strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ in deflateResetKeep()
644 strm->data_type = Z_UNKNOWN; in deflateResetKeep()
646 s = (deflate_state *)strm->state; in deflateResetKeep()
647 s->pending = 0; in deflateResetKeep()
648 s->pending_out = s->pending_buf; in deflateResetKeep()
650 if (s->wrap < 0) { in deflateResetKeep()
651 s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ in deflateResetKeep()
653 s->status = in deflateResetKeep()
655 s->wrap == 2 ? GZIP_STATE : in deflateResetKeep()
658 strm->adler = in deflateResetKeep()
660 s->wrap == 2 ? crc32(0L, Z_NULL, 0) : in deflateResetKeep()
663 s->last_flush = -2; in deflateResetKeep()
674 s->window_size = (ulg)2L*s->w_size; in lm_init()
680 s->max_lazy_match = configuration_table[s->level].max_lazy; in lm_init()
681 s->good_match = configuration_table[s->level].good_length; in lm_init()
682 s->nice_match = configuration_table[s->level].nice_length; in lm_init()
683 s->max_chain_length = configuration_table[s->level].max_chain; in lm_init()
685 s->strstart = 0; in lm_init()
686 s->block_start = 0L; in lm_init()
687 s->lookahead = 0; in lm_init()
688 s->insert = 0; in lm_init()
689 s->match_length = s->prev_length = MIN_MATCH-1; in lm_init()
690 s->match_available = 0; in lm_init()
691 s->ins_h = 0; in lm_init()
700 lm_init(strm->state); in deflateReset()
706 if (deflateStateCheck(strm) || strm->state->wrap != 2) in deflateSetHeader()
708 strm->state->gzhead = head; in deflateSetHeader()
716 *pending = strm->state->pending; in deflatePending()
718 *bits = strm->state->bi_valid; in deflatePending()
728 s = strm->state; in deflatePrime()
731 (uchf *)s->d_buf < s->pending_out + ((Buf_size + 7) >> 3)) in deflatePrime()
735 s->sym_buf < s->pending_out + ((Buf_size + 7) >> 3)) in deflatePrime()
739 put = Buf_size - s->bi_valid; in deflatePrime()
742 s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid); in deflatePrime()
743 s->bi_valid += put; in deflatePrime()
746 bits -= put; in deflatePrime()
757 s = strm->state; in deflateParams()
767 func = configuration_table[s->level].func; in deflateParams()
769 if ((strategy != s->strategy || func != configuration_table[level].func) && in deflateParams()
770 s->last_flush != -2) { in deflateParams()
775 if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead) in deflateParams()
778 if (s->level != level) { in deflateParams()
779 if (s->level == 0 && s->matches != 0) { in deflateParams()
780 if (s->matches == 1) in deflateParams()
784 s->matches = 0; in deflateParams()
786 s->level = level; in deflateParams()
787 s->max_lazy_match = configuration_table[level].max_lazy; in deflateParams()
788 s->good_match = configuration_table[level].good_length; in deflateParams()
789 s->nice_match = configuration_table[level].nice_length; in deflateParams()
790 s->max_chain_length = configuration_table[level].max_chain; in deflateParams()
792 s->strategy = strategy; in deflateParams()
802 s = strm->state; in deflateTune()
803 s->good_match = (uInt)good_length; in deflateTune()
804 s->max_lazy_match = (uInt)max_lazy; in deflateTune()
805 s->nice_match = nice_length; in deflateTune()
806 s->max_chain_length = (uInt)max_chain; in deflateTune()
812 * close to exact, as well as small, upper bound on the compressed size. This
829 * per 8-bit byte, plus 10 bits for every block. The smallest block size for
838 /* upper bound for fixed blocks with 9-bit literals and length 255 in deflateBound()
839 (memLevel == 2, which is the lowest that may not use stored blocks) -- in deflateBound()
844 /* upper bound for stored blocks with length 127 (memLevel == 1) -- in deflateBound()
854 s = strm->state; in deflateBound()
855 switch (s->wrap) { in deflateBound()
860 wraplen = 6 + (s->strstart ? 4 : 0); in deflateBound()
865 if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ in deflateBound()
867 if (s->gzhead->extra != Z_NULL) in deflateBound()
868 wraplen += 2 + s->gzhead->extra_len; in deflateBound()
869 str = s->gzhead->name; in deflateBound()
874 str = s->gzhead->comment; in deflateBound()
879 if (s->gzhead->hcrc) in deflateBound()
889 if (s->w_bits != 15 || s->hash_bits != 8 + 7) in deflateBound()
890 return (s->w_bits <= s->hash_bits && s->level ? fixedlen : storelen) + in deflateBound()
893 /* default settings: return tight bound for that case -- ~0.03% overhead in deflateBound()
896 (sourceLen >> 25) + 13 - 6 + wraplen; in deflateBound()
900 * Put a short in the pending buffer. The 16-bit value is put in MSB order.
913 * strm->next_out buffer and copying into it. (See also read_buf()).
917 deflate_state *s = strm->state; in flush_pending()
920 len = s->pending; in flush_pending()
921 if (len > strm->avail_out) len = strm->avail_out; in flush_pending()
924 zmemcpy(strm->next_out, s->pending_out, len); in flush_pending()
925 strm->next_out += len; in flush_pending()
926 s->pending_out += len; in flush_pending()
927 strm->total_out += len; in flush_pending()
928 strm->avail_out -= len; in flush_pending()
929 s->pending -= len; in flush_pending()
930 if (s->pending == 0) { in flush_pending()
931 s->pending_out = s->pending_buf; in flush_pending()
936 * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
940 if (s->gzhead->hcrc && s->pending > (beg)) \
941 strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
942 s->pending - (beg)); \
953 s = strm->state; in deflate()
955 if (strm->next_out == Z_NULL || in deflate()
956 (strm->avail_in != 0 && strm->next_in == Z_NULL) || in deflate()
957 (s->status == FINISH_STATE && flush != Z_FINISH)) { in deflate()
960 if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); in deflate()
962 old_flush = s->last_flush; in deflate()
963 s->last_flush = flush; in deflate()
966 if (s->pending != 0) { in deflate()
968 if (strm->avail_out == 0) { in deflate()
975 s->last_flush = -1; in deflate()
983 } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && in deflate()
989 if (s->status == FINISH_STATE && strm->avail_in != 0) { in deflate()
994 if (s->status == INIT_STATE && s->wrap == 0) in deflate()
995 s->status = BUSY_STATE; in deflate()
996 if (s->status == INIT_STATE) { in deflate()
998 uInt header = (Z_DEFLATED + ((s->w_bits - 8) << 4)) << 8; in deflate()
1001 if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) in deflate()
1003 else if (s->level < 6) in deflate()
1005 else if (s->level == 6) in deflate()
1010 if (s->strstart != 0) header |= PRESET_DICT; in deflate()
1011 header += 31 - (header % 31); in deflate()
1016 if (s->strstart != 0) { in deflate()
1017 putShortMSB(s, (uInt)(strm->adler >> 16)); in deflate()
1018 putShortMSB(s, (uInt)(strm->adler & 0xffff)); in deflate()
1020 strm->adler = adler32(0L, Z_NULL, 0); in deflate()
1021 s->status = BUSY_STATE; in deflate()
1025 if (s->pending != 0) { in deflate()
1026 s->last_flush = -1; in deflate()
1031 if (s->status == GZIP_STATE) { in deflate()
1033 strm->adler = crc32(0L, Z_NULL, 0); in deflate()
1037 if (s->gzhead == Z_NULL) { in deflate()
1043 put_byte(s, s->level == 9 ? 2 : in deflate()
1044 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? in deflate()
1047 s->status = BUSY_STATE; in deflate()
1051 if (s->pending != 0) { in deflate()
1052 s->last_flush = -1; in deflate()
1057 put_byte(s, (s->gzhead->text ? 1 : 0) + in deflate()
1058 (s->gzhead->hcrc ? 2 : 0) + in deflate()
1059 (s->gzhead->extra == Z_NULL ? 0 : 4) + in deflate()
1060 (s->gzhead->name == Z_NULL ? 0 : 8) + in deflate()
1061 (s->gzhead->comment == Z_NULL ? 0 : 16) in deflate()
1063 put_byte(s, (Byte)(s->gzhead->time & 0xff)); in deflate()
1064 put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); in deflate()
1065 put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); in deflate()
1066 put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); in deflate()
1067 put_byte(s, s->level == 9 ? 2 : in deflate()
1068 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? in deflate()
1070 put_byte(s, s->gzhead->os & 0xff); in deflate()
1071 if (s->gzhead->extra != Z_NULL) { in deflate()
1072 put_byte(s, s->gzhead->extra_len & 0xff); in deflate()
1073 put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); in deflate()
1075 if (s->gzhead->hcrc) in deflate()
1076 strm->adler = crc32(strm->adler, s->pending_buf, in deflate()
1077 s->pending); in deflate()
1078 s->gzindex = 0; in deflate()
1079 s->status = EXTRA_STATE; in deflate()
1082 if (s->status == EXTRA_STATE) { in deflate()
1083 if (s->gzhead->extra != Z_NULL) { in deflate()
1084 ulg beg = s->pending; /* start of bytes to update crc */ in deflate()
1085 uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex; in deflate()
1086 while (s->pending + left > s->pending_buf_size) { in deflate()
1087 uInt copy = s->pending_buf_size - s->pending; in deflate()
1088 zmemcpy(s->pending_buf + s->pending, in deflate()
1089 s->gzhead->extra + s->gzindex, copy); in deflate()
1090 s->pending = s->pending_buf_size; in deflate()
1092 s->gzindex += copy; in deflate()
1094 if (s->pending != 0) { in deflate()
1095 s->last_flush = -1; in deflate()
1099 left -= copy; in deflate()
1101 zmemcpy(s->pending_buf + s->pending, in deflate()
1102 s->gzhead->extra + s->gzindex, left); in deflate()
1103 s->pending += left; in deflate()
1105 s->gzindex = 0; in deflate()
1107 s->status = NAME_STATE; in deflate()
1109 if (s->status == NAME_STATE) { in deflate()
1110 if (s->gzhead->name != Z_NULL) { in deflate()
1111 ulg beg = s->pending; /* start of bytes to update crc */ in deflate()
1114 if (s->pending == s->pending_buf_size) { in deflate()
1117 if (s->pending != 0) { in deflate()
1118 s->last_flush = -1; in deflate()
1123 val = s->gzhead->name[s->gzindex++]; in deflate()
1127 s->gzindex = 0; in deflate()
1129 s->status = COMMENT_STATE; in deflate()
1131 if (s->status == COMMENT_STATE) { in deflate()
1132 if (s->gzhead->comment != Z_NULL) { in deflate()
1133 ulg beg = s->pending; /* start of bytes to update crc */ in deflate()
1136 if (s->pending == s->pending_buf_size) { in deflate()
1139 if (s->pending != 0) { in deflate()
1140 s->last_flush = -1; in deflate()
1145 val = s->gzhead->comment[s->gzindex++]; in deflate()
1150 s->status = HCRC_STATE; in deflate()
1152 if (s->status == HCRC_STATE) { in deflate()
1153 if (s->gzhead->hcrc) { in deflate()
1154 if (s->pending + 2 > s->pending_buf_size) { in deflate()
1156 if (s->pending != 0) { in deflate()
1157 s->last_flush = -1; in deflate()
1161 put_byte(s, (Byte)(strm->adler & 0xff)); in deflate()
1162 put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); in deflate()
1163 strm->adler = crc32(0L, Z_NULL, 0); in deflate()
1165 s->status = BUSY_STATE; in deflate()
1169 if (s->pending != 0) { in deflate()
1170 s->last_flush = -1; in deflate()
1178 if (strm->avail_in != 0 || s->lookahead != 0 || in deflate()
1179 (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { in deflate()
1182 bstate = s->level == 0 ? deflate_stored(s, flush) : in deflate()
1183 s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : in deflate()
1184 s->strategy == Z_RLE ? deflate_rle(s, flush) : in deflate()
1185 (*(configuration_table[s->level].func))(s, flush); in deflate()
1188 s->status = FINISH_STATE; in deflate()
1191 if (strm->avail_out == 0) { in deflate()
1192 s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ in deflate()
1213 if (s->lookahead == 0) { in deflate()
1214 s->strstart = 0; in deflate()
1215 s->block_start = 0L; in deflate()
1216 s->insert = 0; in deflate()
1221 if (strm->avail_out == 0) { in deflate()
1222 s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ in deflate()
1229 if (s->wrap <= 0) return Z_STREAM_END; in deflate()
1233 if (s->wrap == 2) { in deflate()
1234 put_byte(s, (Byte)(strm->adler & 0xff)); in deflate()
1235 put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); in deflate()
1236 put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); in deflate()
1237 put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); in deflate()
1238 put_byte(s, (Byte)(strm->total_in & 0xff)); in deflate()
1239 put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); in deflate()
1240 put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); in deflate()
1241 put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); in deflate()
1246 putShortMSB(s, (uInt)(strm->adler >> 16)); in deflate()
1247 putShortMSB(s, (uInt)(strm->adler & 0xffff)); in deflate()
1253 if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ in deflate()
1254 return s->pending != 0 ? Z_OK : Z_STREAM_END; in deflate()
1263 status = strm->state->status; in deflateEnd()
1266 TRY_FREE(strm, strm->state->pending_buf); in deflateEnd()
1267 TRY_FREE(strm, strm->state->head); in deflateEnd()
1268 TRY_FREE(strm, strm->state->prev); in deflateEnd()
1269 TRY_FREE(strm, strm->state->window); in deflateEnd()
1271 ZFREE(strm, strm->state); in deflateEnd()
1272 strm->state = Z_NULL; in deflateEnd()
1279 * To simplify the source, this is not supported for 16-bit MSDOS (which
1296 ss = source->state; in deflateCopy()
1302 dest->state = (struct internal_state FAR *) ds; in deflateCopy()
1304 ds->strm = dest; in deflateCopy()
1306 ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); in deflateCopy()
1307 ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); in deflateCopy()
1308 ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); in deflateCopy()
1309 ds->pending_buf = (uchf *) ZALLOC(dest, ds->lit_bufsize, LIT_BUFS); in deflateCopy()
1311 if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || in deflateCopy()
1312 ds->pending_buf == Z_NULL) { in deflateCopy()
1316 /* following zmemcpy do not work for 16-bit MSDOS */ in deflateCopy()
1317 zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); in deflateCopy()
1318 zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos)); in deflateCopy()
1319 zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos)); in deflateCopy()
1320 zmemcpy(ds->pending_buf, ss->pending_buf, ds->lit_bufsize * LIT_BUFS); in deflateCopy()
1322 ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); in deflateCopy()
1324 ds->d_buf = (ushf *)(ds->pending_buf + (ds->lit_bufsize << 1)); in deflateCopy()
1325 ds->l_buf = ds->pending_buf + (ds->lit_bufsize << 2); in deflateCopy()
1327 ds->sym_buf = ds->pending_buf + ds->lit_bufsize; in deflateCopy()
1330 ds->l_desc.dyn_tree = ds->dyn_ltree; in deflateCopy()
1331 ds->d_desc.dyn_tree = ds->dyn_dtree; in deflateCopy()
1332 ds->bl_desc.dyn_tree = ds->bl_tree; in deflateCopy()
1346 * OUT assertion: the match length is not greater than s->lookahead.
1349 unsigned chain_length = s->max_chain_length;/* max hash chain length */ in longest_match()
1350 register Bytef *scan = s->window + s->strstart; /* current string */ in longest_match() local
1353 int best_len = (int)s->prev_length; /* best match length so far */ in longest_match()
1354 int nice_match = s->nice_match; /* stop if match long enough */ in longest_match()
1355 IPos limit = s->strstart > (IPos)MAX_DIST(s) ? in longest_match()
1356 s->strstart - (IPos)MAX_DIST(s) : NIL; in longest_match()
1360 Posf *prev = s->prev; in longest_match()
1361 uInt wmask = s->w_mask; in longest_match()
1365 * Try with and without -DUNALIGNED_OK to check. in longest_match()
1367 register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; in longest_match()
1368 register ush scan_start = *(ushf*)scan; in longest_match()
1369 register ush scan_end = *(ushf*)(scan + best_len - 1); in longest_match()
1371 register Bytef *strend = s->window + s->strstart + MAX_MATCH; in longest_match()
1372 register Byte scan_end1 = scan[best_len - 1]; in longest_match()
1373 register Byte scan_end = scan[best_len]; in longest_match()
1376 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. in longest_match()
1379 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); in longest_match()
1382 if (s->prev_length >= s->good_match) { in longest_match()
1388 if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead; in longest_match()
1390 Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, in longest_match()
1394 Assert(cur_match < s->strstart, "no future"); in longest_match()
1395 match = s->window + cur_match; in longest_match()
1401 * conditional jumps will be made that depend on those values. in longest_match()
1409 if (*(ushf*)(match + best_len - 1) != scan_end || in longest_match()
1412 /* It is not necessary to compare scan[2] and match[2] since they are in longest_match()
1417 * at strstart + 257. If MAX_MATCH-2 is not a multiple of 8, it is in longest_match()
1421 Assert(scan[2] == match[2], "scan[2]?"); in longest_match()
1422 scan++, match++; in longest_match()
1424 } while (*(ushf*)(scan += 2) == *(ushf*)(match += 2) && in longest_match()
1425 *(ushf*)(scan += 2) == *(ushf*)(match += 2) && in longest_match()
1426 *(ushf*)(scan += 2) == *(ushf*)(match += 2) && in longest_match()
1427 *(ushf*)(scan += 2) == *(ushf*)(match += 2) && in longest_match()
1428 scan < strend); in longest_match()
1429 /* The funny "do {}" generates better code on most compilers */ in longest_match()
1431 /* Here, scan <= window + strstart + 257 */ in longest_match()
1432 Assert(scan <= s->window + (unsigned)(s->window_size - 1), in longest_match()
1433 "wild scan"); in longest_match()
1434 if (*scan == *match) scan++; in longest_match()
1436 len = (MAX_MATCH - 1) - (int)(strend - scan); in longest_match()
1437 scan = strend - (MAX_MATCH-1); in longest_match()
1442 match[best_len - 1] != scan_end1 || in longest_match()
1443 *match != *scan || in longest_match()
1444 *++match != scan[1]) continue; in longest_match()
1446 /* The check at best_len - 1 can be removed because it will be made in longest_match()
1448 * It is not necessary to compare scan[2] and match[2] since they in longest_match()
1452 scan += 2, match++; in longest_match()
1453 Assert(*scan == *match, "match[2]?"); in longest_match()
1459 } while (*++scan == *++match && *++scan == *++match && in longest_match()
1460 *++scan == *++match && *++scan == *++match && in longest_match()
1461 *++scan == *++match && *++scan == *++match && in longest_match()
1462 *++scan == *++match && *++scan == *++match && in longest_match()
1463 scan < strend); in longest_match()
1465 Assert(scan <= s->window + (unsigned)(s->window_size - 1), in longest_match()
1466 "wild scan"); in longest_match()
1468 len = MAX_MATCH - (int)(strend - scan); in longest_match()
1469 scan = strend - MAX_MATCH; in longest_match()
1474 s->match_start = cur_match; in longest_match()
1478 scan_end = *(ushf*)(scan + best_len - 1); in longest_match()
1480 scan_end1 = scan[best_len - 1]; in longest_match()
1481 scan_end = scan[best_len]; in longest_match()
1485 && --chain_length != 0); in longest_match()
1487 if ((uInt)best_len <= s->lookahead) return (uInt)best_len; in longest_match()
1488 return s->lookahead; in longest_match()
1493 /* ---------------------------------------------------------------------------
1497 register Bytef *scan = s->window + s->strstart; /* current string */ in longest_match() local
1500 register Bytef *strend = s->window + s->strstart + MAX_MATCH; in longest_match()
1502 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. in longest_match()
1505 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); in longest_match()
1507 Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, in longest_match()
1510 Assert(cur_match < s->strstart, "no future"); in longest_match()
1512 match = s->window + cur_match; in longest_match()
1516 if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; in longest_match()
1518 /* The check at best_len - 1 can be removed because it will be made in longest_match()
1520 * It is not necessary to compare scan[2] and match[2] since they in longest_match()
1524 scan += 2, match += 2; in longest_match()
1525 Assert(*scan == *match, "match[2]?"); in longest_match()
1531 } while (*++scan == *++match && *++scan == *++match && in longest_match()
1532 *++scan == *++match && *++scan == *++match && in longest_match()
1533 *++scan == *++match && *++scan == *++match && in longest_match()
1534 *++scan == *++match && *++scan == *++match && in longest_match()
1535 scan < strend); in longest_match()
1537 Assert(scan <= s->window + (unsigned)(s->window_size - 1), "wild scan"); in longest_match()
1539 len = MAX_MATCH - (int)(strend - scan); in longest_match()
1541 if (len < MIN_MATCH) return MIN_MATCH - 1; in longest_match()
1543 s->match_start = cur_match; in longest_match()
1544 return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; in longest_match()
1559 Bytef *back = s->window + (int)match, *here = s->window + start; in check_match()
1561 if (match == (IPos)-1) { in check_match()
1562 /* match starts one byte before the current window -- just compare the in check_match()
1563 subsequent length-1 bytes */ in check_match()
1566 len--; in check_match()
1573 } while (--len != 0); in check_match()
1577 fprintf(stderr,"\\[%d,%d]", start - match, length); in check_match()
1578 do { putc(s->window[start++], stderr); } while (--length != 0); in check_match()
1586 * Flush the current block, with given end-of-file flag.
1590 _tr_flush_block(s, (s->block_start >= 0L ? \
1591 (charf *)&s->window[(unsigned)s->block_start] : \
1593 (ulg)((long)s->strstart - s->block_start), \
1595 s->block_start = s->strstart; \
1596 flush_pending(s->strm); \
1603 if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
1618 * In case deflateParams() is used to later switch to a non-zero compression
1619 * level, s->matches (otherwise unused when storing) keeps track of the number
1620 * of hash table slides to perform. If s->matches is 1, then one hash table
1621 * slide will be done when switching. If s->matches is 2, the maximum value
1634 unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size); in deflate_stored()
1641 unsigned used = s->strm->avail_in; in deflate_stored()
1648 have = (s->bi_valid + 42) >> 3; /* number of header bytes */ in deflate_stored()
1649 if (s->strm->avail_out < have) /* need room for header */ in deflate_stored()
1652 have = s->strm->avail_out - have; in deflate_stored()
1653 left = s->strstart - s->block_start; /* bytes left in window */ in deflate_stored()
1654 if (len > (ulg)left + s->strm->avail_in) in deflate_stored()
1655 len = left + s->strm->avail_in; /* limit len to the input */ in deflate_stored()
1662 * write an empty block when flushing -- deflate() does that. in deflate_stored()
1666 len != left + s->strm->avail_in)) in deflate_stored()
1672 last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0; in deflate_stored()
1676 s->pending_buf[s->pending - 4] = len; in deflate_stored()
1677 s->pending_buf[s->pending - 3] = len >> 8; in deflate_stored()
1678 s->pending_buf[s->pending - 2] = ~len; in deflate_stored()
1679 s->pending_buf[s->pending - 1] = ~len >> 8; in deflate_stored()
1682 flush_pending(s->strm); in deflate_stored()
1686 s->compressed_len += len << 3; in deflate_stored()
1687 s->bits_sent += len << 3; in deflate_stored()
1694 zmemcpy(s->strm->next_out, s->window + s->block_start, left); in deflate_stored()
1695 s->strm->next_out += left; in deflate_stored()
1696 s->strm->avail_out -= left; in deflate_stored()
1697 s->strm->total_out += left; in deflate_stored()
1698 s->block_start += left; in deflate_stored()
1699 len -= left; in deflate_stored()
1706 read_buf(s->strm, s->strm->next_out, len); in deflate_stored()
1707 s->strm->next_out += len; in deflate_stored()
1708 s->strm->avail_out -= len; in deflate_stored()
1709 s->strm->total_out += len; in deflate_stored()
1713 /* Update the sliding window with the last s->w_size bytes of the copied in deflate_stored()
1715 * than s->w_size bytes were copied. Also update the number of bytes to in deflate_stored()
1717 * a non-zero compression level. in deflate_stored()
1719 used -= s->strm->avail_in; /* number of input bytes directly copied */ in deflate_stored()
1721 /* If any input was used, then no unused input remains in the window, in deflate_stored()
1722 * therefore s->block_start == s->strstart. in deflate_stored()
1724 if (used >= s->w_size) { /* supplant the previous history */ in deflate_stored()
1725 s->matches = 2; /* clear hash */ in deflate_stored()
1726 zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size); in deflate_stored()
1727 s->strstart = s->w_size; in deflate_stored()
1728 s->insert = s->strstart; in deflate_stored()
1731 if (s->window_size - s->strstart <= used) { in deflate_stored()
1733 s->strstart -= s->w_size; in deflate_stored()
1734 zmemcpy(s->window, s->window + s->w_size, s->strstart); in deflate_stored()
1735 if (s->matches < 2) in deflate_stored()
1736 s->matches++; /* add a pending slide_hash() */ in deflate_stored()
1737 if (s->insert > s->strstart) in deflate_stored()
1738 s->insert = s->strstart; in deflate_stored()
1740 zmemcpy(s->window + s->strstart, s->strm->next_in - used, used); in deflate_stored()
1741 s->strstart += used; in deflate_stored()
1742 s->insert += MIN(used, s->w_size - s->insert); in deflate_stored()
1744 s->block_start = s->strstart; in deflate_stored()
1746 if (s->high_water < s->strstart) in deflate_stored()
1747 s->high_water = s->strstart; in deflate_stored()
1755 s->strm->avail_in == 0 && (long)s->strstart == s->block_start) in deflate_stored()
1759 have = s->window_size - s->strstart; in deflate_stored()
1760 if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) { in deflate_stored()
1762 s->block_start -= s->w_size; in deflate_stored()
1763 s->strstart -= s->w_size; in deflate_stored()
1764 zmemcpy(s->window, s->window + s->w_size, s->strstart); in deflate_stored()
1765 if (s->matches < 2) in deflate_stored()
1766 s->matches++; /* add a pending slide_hash() */ in deflate_stored()
1767 have += s->w_size; /* more space now */ in deflate_stored()
1768 if (s->insert > s->strstart) in deflate_stored()
1769 s->insert = s->strstart; in deflate_stored()
1771 if (have > s->strm->avail_in) in deflate_stored()
1772 have = s->strm->avail_in; in deflate_stored()
1774 read_buf(s->strm, s->window + s->strstart, have); in deflate_stored()
1775 s->strstart += have; in deflate_stored()
1776 s->insert += MIN(have, s->w_size - s->insert); in deflate_stored()
1778 if (s->high_water < s->strstart) in deflate_stored()
1779 s->high_water = s->strstart; in deflate_stored()
1786 have = (s->bi_valid + 42) >> 3; /* number of header bytes */ in deflate_stored()
1788 have = MIN(s->pending_buf_size - have, MAX_STORED); in deflate_stored()
1789 min_block = MIN(have, s->w_size); in deflate_stored()
1790 left = s->strstart - s->block_start; in deflate_stored()
1793 s->strm->avail_in == 0 && left <= have)) { in deflate_stored()
1795 last = flush == Z_FINISH && s->strm->avail_in == 0 && in deflate_stored()
1797 _tr_stored_block(s, (charf *)s->window + s->block_start, len, last); in deflate_stored()
1798 s->block_start += len; in deflate_stored()
1799 flush_pending(s->strm); in deflate_stored()
1823 if (s->lookahead < MIN_LOOKAHEAD) { in deflate_fast()
1825 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { in deflate_fast()
1828 if (s->lookahead == 0) break; /* flush the current block */ in deflate_fast()
1835 if (s->lookahead >= MIN_MATCH) { in deflate_fast()
1836 INSERT_STRING(s, s->strstart, hash_head); in deflate_fast()
1842 if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { in deflate_fast()
1847 s->match_length = longest_match (s, hash_head); in deflate_fast()
1850 if (s->match_length >= MIN_MATCH) { in deflate_fast()
1851 check_match(s, s->strstart, s->match_start, s->match_length); in deflate_fast()
1853 _tr_tally_dist(s, s->strstart - s->match_start, in deflate_fast()
1854 s->match_length - MIN_MATCH, bflush); in deflate_fast()
1856 s->lookahead -= s->match_length; in deflate_fast()
1862 if (s->match_length <= s->max_insert_length && in deflate_fast()
1863 s->lookahead >= MIN_MATCH) { in deflate_fast()
1864 s->match_length--; /* string at strstart already in table */ in deflate_fast()
1866 s->strstart++; in deflate_fast()
1867 INSERT_STRING(s, s->strstart, hash_head); in deflate_fast()
1868 /* strstart never exceeds WSIZE-MAX_MATCH, so there are in deflate_fast()
1871 } while (--s->match_length != 0); in deflate_fast()
1872 s->strstart++; in deflate_fast()
1876 s->strstart += s->match_length; in deflate_fast()
1877 s->match_length = 0; in deflate_fast()
1878 s->ins_h = s->window[s->strstart]; in deflate_fast()
1879 UPDATE_HASH(s, s->ins_h, s->window[s->strstart + 1]); in deflate_fast()
1881 Call UPDATE_HASH() MIN_MATCH-3 more times in deflate_fast()
1888 /* No match, output a literal byte */ in deflate_fast()
1889 Tracevv((stderr,"%c", s->window[s->strstart])); in deflate_fast()
1890 _tr_tally_lit(s, s->window[s->strstart], bflush); in deflate_fast()
1891 s->lookahead--; in deflate_fast()
1892 s->strstart++; in deflate_fast()
1896 s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; in deflate_fast()
1901 if (s->sym_next) in deflate_fast()
1910 * no better match at the next window position.
1923 if (s->lookahead < MIN_LOOKAHEAD) { in deflate_slow()
1925 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { in deflate_slow()
1928 if (s->lookahead == 0) break; /* flush the current block */ in deflate_slow()
1935 if (s->lookahead >= MIN_MATCH) { in deflate_slow()
1936 INSERT_STRING(s, s->strstart, hash_head); in deflate_slow()
1941 s->prev_length = s->match_length, s->prev_match = s->match_start; in deflate_slow()
1942 s->match_length = MIN_MATCH-1; in deflate_slow()
1944 if (hash_head != NIL && s->prev_length < s->max_lazy_match && in deflate_slow()
1945 s->strstart - hash_head <= MAX_DIST(s)) { in deflate_slow()
1950 s->match_length = longest_match (s, hash_head); in deflate_slow()
1953 if (s->match_length <= 5 && (s->strategy == Z_FILTERED in deflate_slow()
1955 || (s->match_length == MIN_MATCH && in deflate_slow()
1956 s->strstart - s->match_start > TOO_FAR) in deflate_slow()
1963 s->match_length = MIN_MATCH-1; in deflate_slow()
1969 if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { in deflate_slow()
1970 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; in deflate_slow()
1973 check_match(s, s->strstart - 1, s->prev_match, s->prev_length); in deflate_slow()
1975 _tr_tally_dist(s, s->strstart - 1 - s->prev_match, in deflate_slow()
1976 s->prev_length - MIN_MATCH, bflush); in deflate_slow()
1979 * strstart - 1 and strstart are already inserted. If there is not in deflate_slow()
1983 s->lookahead -= s->prev_length - 1; in deflate_slow()
1984 s->prev_length -= 2; in deflate_slow()
1986 if (++s->strstart <= max_insert) { in deflate_slow()
1987 INSERT_STRING(s, s->strstart, hash_head); in deflate_slow()
1989 } while (--s->prev_length != 0); in deflate_slow()
1990 s->match_available = 0; in deflate_slow()
1991 s->match_length = MIN_MATCH-1; in deflate_slow()
1992 s->strstart++; in deflate_slow()
1996 } else if (s->match_available) { in deflate_slow()
1997 /* If there was no match at the previous position, output a in deflate_slow()
2001 Tracevv((stderr,"%c", s->window[s->strstart - 1])); in deflate_slow()
2002 _tr_tally_lit(s, s->window[s->strstart - 1], bflush); in deflate_slow()
2006 s->strstart++; in deflate_slow()
2007 s->lookahead--; in deflate_slow()
2008 if (s->strm->avail_out == 0) return need_more; in deflate_slow()
2010 /* There is no previous match to compare with, wait for in deflate_slow()
2013 s->match_available = 1; in deflate_slow()
2014 s->strstart++; in deflate_slow()
2015 s->lookahead--; in deflate_slow()
2018 Assert (flush != Z_NO_FLUSH, "no flush?"); in deflate_slow()
2019 if (s->match_available) { in deflate_slow()
2020 Tracevv((stderr,"%c", s->window[s->strstart - 1])); in deflate_slow()
2021 _tr_tally_lit(s, s->window[s->strstart - 1], bflush); in deflate_slow()
2022 s->match_available = 0; in deflate_slow()
2024 s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; in deflate_slow()
2029 if (s->sym_next) in deflate_slow()
2043 Bytef *scan, *strend; /* scan goes up to strend for length of run */ in deflate_rle() local
2050 if (s->lookahead <= MAX_MATCH) { in deflate_rle()
2052 if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { in deflate_rle()
2055 if (s->lookahead == 0) break; /* flush the current block */ in deflate_rle()
2059 s->match_length = 0; in deflate_rle()
2060 if (s->lookahead >= MIN_MATCH && s->strstart > 0) { in deflate_rle()
2061 scan = s->window + s->strstart - 1; in deflate_rle()
2062 prev = *scan; in deflate_rle()
2063 if (prev == *++scan && prev == *++scan && prev == *++scan) { in deflate_rle()
2064 strend = s->window + s->strstart + MAX_MATCH; in deflate_rle()
2066 } while (prev == *++scan && prev == *++scan && in deflate_rle()
2067 prev == *++scan && prev == *++scan && in deflate_rle()
2068 prev == *++scan && prev == *++scan && in deflate_rle()
2069 prev == *++scan && prev == *++scan && in deflate_rle()
2070 scan < strend); in deflate_rle()
2071 s->match_length = MAX_MATCH - (uInt)(strend - scan); in deflate_rle()
2072 if (s->match_length > s->lookahead) in deflate_rle()
2073 s->match_length = s->lookahead; in deflate_rle()
2075 Assert(scan <= s->window + (uInt)(s->window_size - 1), in deflate_rle()
2076 "wild scan"); in deflate_rle()
2080 if (s->match_length >= MIN_MATCH) { in deflate_rle()
2081 check_match(s, s->strstart, s->strstart - 1, s->match_length); in deflate_rle()
2083 _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); in deflate_rle()
2085 s->lookahead -= s->match_length; in deflate_rle()
2086 s->strstart += s->match_length; in deflate_rle()
2087 s->match_length = 0; in deflate_rle()
2089 /* No match, output a literal byte */ in deflate_rle()
2090 Tracevv((stderr,"%c", s->window[s->strstart])); in deflate_rle()
2091 _tr_tally_lit(s, s->window[s->strstart], bflush); in deflate_rle()
2092 s->lookahead--; in deflate_rle()
2093 s->strstart++; in deflate_rle()
2097 s->insert = 0; in deflate_rle()
2102 if (s->sym_next) in deflate_rle()
2116 if (s->lookahead == 0) { in deflate_huff()
2118 if (s->lookahead == 0) { in deflate_huff()
2126 s->match_length = 0; in deflate_huff()
2127 Tracevv((stderr,"%c", s->window[s->strstart])); in deflate_huff()
2128 _tr_tally_lit(s, s->window[s->strstart], bflush); in deflate_huff()
2129 s->lookahead--; in deflate_huff()
2130 s->strstart++; in deflate_huff()
2133 s->insert = 0; in deflate_huff()
2138 if (s->sym_next) in deflate_huff()