@ -52,7 +52,7 @@
# include "deflate.h"
const char deflate_copyright [ ] =
" deflate 1.2.12 Copyright 1995-2022 Jean-loup Gailly and Mark Adler " ;
" deflate 1.2.13 Copyright 1995-2022 Jean-loup Gailly and Mark Adler " ;
/*
If you use the zlib library in a product , an acknowledgment is welcome
in the documentation of your product . If for some reason you cannot
@ -87,13 +87,7 @@ local void lm_init OF((deflate_state *s));
local void putShortMSB OF ( ( deflate_state * s , uInt b ) ) ;
local void flush_pending OF ( ( z_streamp strm ) ) ;
local unsigned read_buf OF ( ( z_streamp strm , Bytef * buf , unsigned size ) ) ;
# ifdef ASMV
# pragma message("Assembler code may have bugs -- use at your own risk")
void match_init OF ( ( void ) ) ; /* asm code initialization */
uInt longest_match OF ( ( deflate_state * s , IPos cur_match ) ) ;
# else
local uInt longest_match OF ( ( deflate_state * s , IPos cur_match ) ) ;
# endif
# ifdef ZLIB_DEBUG
local void check_match OF ( ( deflate_state * s , IPos start , IPos match ,
@ -160,7 +154,7 @@ local const config configuration_table[10] = {
* characters , so that a running hash key can be computed from the previous
* key instead of complete recalculation each time .
*/
# define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
# define UPDATE_HASH(s,h,c) (h = (((h) << s->hash_shift) ^ (c)) & s->hash_mask)
/* ===========================================================================
@ -191,9 +185,9 @@ local const config configuration_table[10] = {
*/
# define CLEAR_HASH(s) \
do { \
s - > head [ s - > hash_size - 1 ] = NIL ; \
s - > head [ s - > hash_size - 1 ] = NIL ; \
zmemzero ( ( Bytef * ) s - > head , \
( unsigned ) ( s - > hash_size - 1 ) * sizeof ( * s - > head ) ) ; \
( unsigned ) ( s - > hash_size - 1 ) * sizeof ( * s - > head ) ) ; \
} while ( 0 )
/* ===========================================================================
@ -285,6 +279,8 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
if ( windowBits < 0 ) { /* suppress zlib wrapper */
wrap = 0 ;
if ( windowBits < - 15 )
return Z_STREAM_ERROR ;
windowBits = - windowBits ;
}
# ifdef GZIP
@ -314,7 +310,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
s - > hash_bits = ( uInt ) memLevel + 7 ;
s - > hash_size = 1 < < s - > hash_bits ;
s - > hash_mask = s - > hash_size - 1 ;
s - > hash_shift = ( ( s - > hash_bits + MIN_MATCH - 1 ) / MIN_MATCH ) ;
s - > hash_shift = ( ( s - > hash_bits + MIN_MATCH - 1 ) / MIN_MATCH ) ;
s - > window = ( Bytef * ) ZALLOC ( strm , s - > w_size , 2 * sizeof ( Byte ) ) ;
s - > prev = ( Posf * ) ZALLOC ( strm , s - > w_size , sizeof ( Pos ) ) ;
@ -340,11 +336,11 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
* sym_buf value to read moves forward three bytes . From that symbol , up to
* 31 bits are written to pending_buf . The closest the written pending_buf
* bits gets to the next sym_buf symbol to read is just before the last
* code is written . At that time , 31 * ( n - 2 ) bits have been written , just
* after 24 * ( n - 2 ) bits have been consumed from sym_buf . sym_buf starts at
* 8 * n bits into pending_buf . ( Note that the symbol buffer fills when n - 1
* code is written . At that time , 31 * ( n - 2 ) bits have been written , just
* after 24 * ( n - 2 ) bits have been consumed from sym_buf . sym_buf starts at
* 8 * n bits into pending_buf . ( Note that the symbol buffer fills when n - 1
* symbols are written . ) The closest the writing gets to what is unread is
* then n + 14 bits . Here n is lit_bufsize , which is 16384 by default , and
* then n + 14 bits . Here n is lit_bufsize , which is 16384 by default , and
* can range from 128 to 32768.
*
* Therefore , at a minimum , there are 142 bits of space between what is
@ -390,7 +386,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
/* =========================================================================
* Check for a valid deflate stream state . Return 0 if ok , 1 if not .
*/
local int deflateStateCheck ( strm )
local int deflateStateCheck ( strm )
z_streamp strm ;
{
deflate_state * s ;
@ -413,7 +409,7 @@ local int deflateStateCheck (strm)
}
/* ========================================================================= */
int ZEXPORT deflateSetDictionary ( strm , dictionary , dictLength )
int ZEXPORT deflateSetDictionary ( strm , dictionary , dictLength )
z_streamp strm ;
const Bytef * dictionary ;
uInt dictLength ;
@ -482,7 +478,7 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
}
/* ========================================================================= */
int ZEXPORT deflateGetDictionary ( strm , dictionary , dictLength )
int ZEXPORT deflateGetDictionary ( strm , dictionary , dictLength )
z_streamp strm ;
Bytef * dictionary ;
uInt * dictLength ;
@ -504,7 +500,7 @@ int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)
}
/* ========================================================================= */
int ZEXPORT deflateResetKeep ( strm )
int ZEXPORT deflateResetKeep ( strm )
z_streamp strm ;
{
deflate_state * s ;
@ -542,7 +538,7 @@ int ZEXPORT deflateResetKeep (strm)
}
/* ========================================================================= */
int ZEXPORT deflateReset ( strm )
int ZEXPORT deflateReset ( strm )
z_streamp strm ;
{
int ret ;
@ -554,7 +550,7 @@ int ZEXPORT deflateReset (strm)
}
/* ========================================================================= */
int ZEXPORT deflateSetHeader ( strm , head )
int ZEXPORT deflateSetHeader ( strm , head )
z_streamp strm ;
gz_headerp head ;
{
@ -565,7 +561,7 @@ int ZEXPORT deflateSetHeader (strm, head)
}
/* ========================================================================= */
int ZEXPORT deflatePending ( strm , pending , bits )
int ZEXPORT deflatePending ( strm , pending , bits )
unsigned * pending ;
int * bits ;
z_streamp strm ;
@ -579,7 +575,7 @@ int ZEXPORT deflatePending (strm, pending, bits)
}
/* ========================================================================= */
int ZEXPORT deflatePrime ( strm , bits , value )
int ZEXPORT deflatePrime ( strm , bits , value )
z_streamp strm ;
int bits ;
int value ;
@ -674,36 +670,50 @@ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
}
/* =========================================================================
* For the default windowBits of 15 and memLevel of 8 , this function returns
* a close to exact , as well as small , upper bound on the compressed size .
* They are coded as constants here for a reason - - if the # define ' s are
* changed , then this function needs to be changed as well . The return
* value for 15 and 8 only works for those exact settings .
* For the default windowBits of 15 and memLevel of 8 , this function returns a
* close to exact , as well as small , upper bound on the compressed size . This
* is an expansion of ~ 0.03 % , plus a small constant .
*
* For any setting other than those defaults for windowBits and memLevel , one
* of two worst case bounds is returned . This is at most an expansion of ~ 4 % or
* ~ 13 % , plus a small constant .
*
* For any setting other than those defaults for windowBits and memLevel ,
* the value returned is a conservative worst case for the maximum expansion
* resulting from using fixed blocks instead of stored blocks , which deflat e
* can emit on compressed data for some combinations of the parameters .
* Both the 0.03 % and 4 % derive from the overhead of stored blocks . The first
* one is for stored blocks of 16383 bytes ( memLevel = = 8 ) , whereas the second
* is for stored blocks of 127 bytes ( the worst case memLevel = = 1 ) . Th e
* expansion results from five bytes of header for each stored block .
*
* This function could be more sophisticated to provide closer upper bounds for
* every combination of windowBits and memLevel . But even the conservative
* upper bound of about 14 % expansion does not seem onerous for output buffer
* allocation .
* The larger expansion of 13 % results from a window size less than or equal to
* the symbols buffer size ( windowBits < = memLevel + 7 ) . In that case some of
* the data being compressed may have slid out of the sliding window , impeding
* a stored block from being emitted . Then the only choice is a fixed or
* dynamic block , where a fixed block limits the maximum expansion to 9 bits
* per 8 - bit byte , plus 10 bits for every block . The smallest block size for
* which this can occur is 255 ( memLevel = = 2 ) .
*
* Shifts are used to approximate divisions , for speed .
*/
uLong ZEXPORT deflateBound ( strm , sourceLen )
z_streamp strm ;
uLong sourceLen ;
{
deflate_state * s ;
uLong complen , wraplen ;
uLong fixedlen , storelen , wraplen ;
/* upper bound for fixed blocks with 9-bit literals and length 255
( memLevel = = 2 , which is the lowest that may not use stored blocks ) - -
~ 13 % overhead plus a small constant */
fixedlen = sourceLen + ( sourceLen > > 3 ) + ( sourceLen > > 8 ) +
( sourceLen > > 9 ) + 4 ;
/* conservative upper bound for compressed data */
complen = sourceLen +
( ( sourceLen + 7 ) > > 3 ) + ( ( sourceLen + 63 ) > > 6 ) + 5 ;
/* upper bound for stored blocks with length 127 (memLevel == 1) --
~ 4 % overhead plus a small constant */
storelen = sourceLen + ( sourceLen > > 5 ) + ( sourceLen > > 7 ) +
( sourceLen > > 11 ) + 7 ;
/* if can't get parameters, return conservative bound plus zlib wrapper */
/* if can't get parameters, return larger bound plus a zlib wrapper */
if ( deflateStateCheck ( strm ) )
return complen + 6 ;
return ( fixedlen > storelen ? fixedlen : storelen ) + 6 ;
/* compute wrapper length */
s = strm - > state ;
@ -740,11 +750,12 @@ uLong ZEXPORT deflateBound(strm, sourceLen)
wraplen = 6 ;
}
/* if not default parameters, return conservative bound */
/* if not default parameters, return one of the conservative bounds */
if ( s - > w_bits ! = 15 | | s - > hash_bits ! = 8 + 7 )
return complen + wraplen ;
return ( s - > w_bits < = s - > hash_bits ? fixedlen : storelen ) + wraplen ;
/* default settings: return tight bound for that case */
/* default settings: return tight bound for that case -- ~0.03% overhead
plus a small constant */
return sourceLen + ( sourceLen > > 12 ) + ( sourceLen > > 14 ) +
( sourceLen > > 25 ) + 13 - 6 + wraplen ;
}
@ -754,7 +765,7 @@ uLong ZEXPORT deflateBound(strm, sourceLen)
* IN assertion : the stream state is correct and there is enough room in
* pending_buf .
*/
local void putShortMSB ( s , b )
local void putShortMSB ( s , b )
deflate_state * s ;
uInt b ;
{
@ -801,7 +812,7 @@ local void flush_pending(strm)
} while ( 0 )
/* ========================================================================= */
int ZEXPORT deflate ( strm , flush )
int ZEXPORT deflate ( strm , flush )
z_streamp strm ;
int flush ;
{
@ -856,7 +867,7 @@ int ZEXPORT deflate (strm, flush)
s - > status = BUSY_STATE ;
if ( s - > status = = INIT_STATE ) {
/* zlib header */
uInt header = ( Z_DEFLATED + ( ( s - > w_bits - 8 ) < < 4 ) ) < < 8 ;
uInt header = ( Z_DEFLATED + ( ( s - > w_bits - 8 ) < < 4 ) ) < < 8 ;
uInt level_flags ;
if ( s - > strategy > = Z_HUFFMAN_ONLY | | s - > level < 2 )
@ -1116,7 +1127,7 @@ int ZEXPORT deflate (strm, flush)
}
/* ========================================================================= */
int ZEXPORT deflateEnd ( strm )
int ZEXPORT deflateEnd ( strm )
z_streamp strm ;
{
int status ;
@ -1142,7 +1153,7 @@ int ZEXPORT deflateEnd (strm)
* To simplify the source , this is not supported for 16 - bit MSDOS ( which
* doesn ' t have enough memory anyway to duplicate compression states ) .
*/
int ZEXPORT deflateCopy ( dest , source )
int ZEXPORT deflateCopy ( dest , source )
z_streamp dest ;
z_streamp source ;
{
@ -1231,7 +1242,7 @@ local unsigned read_buf(strm, buf, size)
/* ===========================================================================
* Initialize the " longest match " routines for a new zlib stream
*/
local void lm_init ( s )
local void lm_init ( s )
deflate_state * s ;
{
s - > window_size = ( ulg ) 2L * s - > w_size ;
@ -1252,11 +1263,6 @@ local void lm_init (s)
s - > match_length = s - > prev_length = MIN_MATCH - 1 ;
s - > match_available = 0 ;
s - > ins_h = 0 ;
# ifndef FASTEST
# ifdef ASMV
match_init ( ) ; /* initialize the asm code */
# endif
# endif
}
# ifndef FASTEST
@ -1269,10 +1275,6 @@ local void lm_init (s)
* string ( strstart ) and its distance is < = MAX_DIST , and prev_length > = 1
* OUT assertion : the match length is not greater than s - > lookahead .
*/
# ifndef ASMV
/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
* match . S . The code will be functionally equivalent .
*/
local uInt longest_match ( s , cur_match )
deflate_state * s ;
IPos cur_match ; /* current match */
@ -1297,10 +1299,10 @@ local uInt longest_match(s, cur_match)
*/
register Bytef * strend = s - > window + s - > strstart + MAX_MATCH - 1 ;
register ush scan_start = * ( ushf * ) scan ;
register ush scan_end = * ( ushf * ) ( scan + best_len - 1 ) ;
register ush scan_end = * ( ushf * ) ( scan + best_len - 1 ) ;
# else
register Bytef * strend = s - > window + s - > strstart + MAX_MATCH ;
register Byte scan_end1 = scan [ best_len - 1 ] ;
register Byte scan_end1 = scan [ best_len - 1 ] ;
register Byte scan_end = scan [ best_len ] ;
# endif
@ -1318,7 +1320,8 @@ local uInt longest_match(s, cur_match)
*/
if ( ( uInt ) nice_match > s - > lookahead ) nice_match = ( int ) s - > lookahead ;
Assert ( ( ulg ) s - > strstart < = s - > window_size - MIN_LOOKAHEAD , " need lookahead " ) ;
Assert ( ( ulg ) s - > strstart < = s - > window_size - MIN_LOOKAHEAD ,
" need lookahead " ) ;
do {
Assert ( cur_match < s - > strstart , " no future " ) ;
@ -1336,43 +1339,44 @@ local uInt longest_match(s, cur_match)
/* This code assumes sizeof(unsigned short) == 2. Do not use
* UNALIGNED_OK if your compiler uses a different size .
*/
if ( * ( ushf * ) ( match + best_len - 1 ) ! = scan_end | |
if ( * ( ushf * ) ( match + best_len - 1 ) ! = scan_end | |
* ( ushf * ) match ! = scan_start ) continue ;
/* It is not necessary to compare scan[2] and match[2] since they are
* always equal when the other bytes match , given that the hash keys
* are equal and that HASH_BITS > = 8. Compare 2 bytes at a time at
* strstart + 3 , + 5 , . . . up to strstart + 257. We check for insufficient
* strstart + 3 , + 5 , up to strstart + 257. We check for insufficient
* lookahead only every 4 th comparison ; the 128 th check will be made
* at strstart + 257. If MAX_MATCH - 2 is not a multiple of 8 , it is
* at strstart + 257. If MAX_MATCH - 2 is not a multiple of 8 , it is
* necessary to put more guard bytes at the end of the window , or
* to check more often for insufficient lookahead .
*/
Assert ( scan [ 2 ] = = match [ 2 ] , " scan[2]? " ) ;
scan + + , match + + ;
do {
} while ( * ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
* ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
* ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
* ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
} while ( * ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
* ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
* ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
* ( ushf * ) ( scan + = 2 ) = = * ( ushf * ) ( match + = 2 ) & &
scan < strend ) ;
/* The funny "do {}" generates better code on most compilers */
/* Here, scan <= window+strstart+257 */
Assert ( scan < = s - > window + ( unsigned ) ( s - > window_size - 1 ) , " wild scan " ) ;
/* Here, scan <= window + strstart + 257 */
Assert ( scan < = s - > window + ( unsigned ) ( s - > window_size - 1 ) ,
" wild scan " ) ;
if ( * scan = = * match ) scan + + ;
len = ( MAX_MATCH - 1 ) - ( int ) ( strend - scan ) ;
len = ( MAX_MATCH - 1 ) - ( int ) ( strend - scan ) ;
scan = strend - ( MAX_MATCH - 1 ) ;
# else /* UNALIGNED_OK */
if ( match [ best_len ] ! = scan_end | |
match [ best_len - 1 ] ! = scan_end1 | |
* match ! = * scan | |
* + + match ! = scan [ 1 ] ) continue ;
if ( match [ best_len ] ! = scan_end | |
match [ best_len - 1 ] ! = scan_end1 | |
* match ! = * scan | |
* + + match ! = scan [ 1 ] ) continue ;
/* The check at best_len-1 can be removed because it will be made
/* The check at best_len - 1 can be removed because it will be made
* again later . ( This heuristic is not always a win . )
* It is not necessary to compare scan [ 2 ] and match [ 2 ] since they
* are always equal when the other bytes match , given that
@ -1382,7 +1386,7 @@ local uInt longest_match(s, cur_match)
Assert ( * scan = = * match , " match[2]? " ) ;
/* We check for insufficient lookahead only every 8th comparison;
* the 256 th check will be made at strstart + 258.
* the 256 th check will be made at strstart + 258.
*/
do {
} while ( * + + scan = = * + + match & & * + + scan = = * + + match & &
@ -1391,7 +1395,8 @@ local uInt longest_match(s, cur_match)
* + + scan = = * + + match & & * + + scan = = * + + match & &
scan < strend ) ;
Assert ( scan < = s - > window + ( unsigned ) ( s - > window_size - 1 ) , " wild scan " ) ;
Assert ( scan < = s - > window + ( unsigned ) ( s - > window_size - 1 ) ,
" wild scan " ) ;
len = MAX_MATCH - ( int ) ( strend - scan ) ;
scan = strend - MAX_MATCH ;
@ -1403,9 +1408,9 @@ local uInt longest_match(s, cur_match)
best_len = len ;
if ( len > = nice_match ) break ;
# ifdef UNALIGNED_OK
scan_end = * ( ushf * ) ( scan + best_len - 1 ) ;
scan_end = * ( ushf * ) ( scan + best_len - 1 ) ;
# else
scan_end1 = scan [ best_len - 1 ] ;
scan_end1 = scan [ best_len - 1 ] ;
scan_end = scan [ best_len ] ;
# endif
}
@ -1415,7 +1420,6 @@ local uInt longest_match(s, cur_match)
if ( ( uInt ) best_len < = s - > lookahead ) return ( uInt ) best_len ;
return s - > lookahead ;
}
# endif /* ASMV */
# else /* FASTEST */
@ -1436,7 +1440,8 @@ local uInt longest_match(s, cur_match)
*/
Assert ( s - > hash_bits > = 8 & & MAX_MATCH = = 258 , " Code too clever " ) ;
Assert ( ( ulg ) s - > strstart < = s - > window_size - MIN_LOOKAHEAD , " need lookahead " ) ;
Assert ( ( ulg ) s - > strstart < = s - > window_size - MIN_LOOKAHEAD ,
" need lookahead " ) ;
Assert ( cur_match < s - > strstart , " no future " ) ;
@ -1446,7 +1451,7 @@ local uInt longest_match(s, cur_match)
*/
if ( match [ 0 ] ! = scan [ 0 ] | | match [ 1 ] ! = scan [ 1 ] ) return MIN_MATCH - 1 ;
/* The check at best_len-1 can be removed because it will be made
/* The check at best_len - 1 can be removed because it will be made
* again later . ( This heuristic is not always a win . )
* It is not necessary to compare scan [ 2 ] and match [ 2 ] since they
* are always equal when the other bytes match , given that
@ -1456,7 +1461,7 @@ local uInt longest_match(s, cur_match)
Assert ( * scan = = * match , " match[2]? " ) ;
/* We check for insufficient lookahead only every 8th comparison;
* the 256 th check will be made at strstart + 258.
* the 256 th check will be made at strstart + 258.
*/
do {
} while ( * + + scan = = * + + match & & * + + scan = = * + + match & &
@ -1465,7 +1470,7 @@ local uInt longest_match(s, cur_match)
* + + scan = = * + + match & & * + + scan = = * + + match & &
scan < strend ) ;
Assert ( scan < = s - > window + ( unsigned ) ( s - > window_size - 1 ) , " wild scan " ) ;
Assert ( scan < = s - > window + ( unsigned ) ( s - > window_size - 1 ) , " wild scan " ) ;
len = MAX_MATCH - ( int ) ( strend - scan ) ;
@ -1501,7 +1506,7 @@ local void check_match(s, start, match, length)
z_error ( " invalid match " ) ;
}
if ( z_verbose > 1 ) {
fprintf ( stderr , " \\ [%d,%d] " , start - match , length ) ;
fprintf ( stderr , " \\ [%d,%d] " , start - match , length ) ;
do { putc ( s - > window [ start + + ] , stderr ) ; } while ( - - length ! = 0 ) ;
}
}
@ -1547,9 +1552,9 @@ local void fill_window(s)
/* If the window is almost full and there is insufficient lookahead,
* move the upper half to the lower one to make room in the upper half .
*/
if ( s - > strstart > = wsize + MAX_DIST ( s ) ) {
if ( s - > strstart > = wsize + MAX_DIST ( s ) ) {
zmemcpy ( s - > window , s - > window + wsize , ( unsigned ) wsize - more ) ;
zmemcpy ( s - > window , s - > window + wsize , ( unsigned ) wsize - more ) ;
s - > match_start - = wsize ;
s - > strstart - = wsize ; /* we now have strstart >= MAX_DIST */
s - > block_start - = ( long ) wsize ;
@ -1680,7 +1685,7 @@ local void fill_window(s)
*
* deflate_stored ( ) is written to minimize the number of times an input byte is
* copied . It is most efficient with large input and output buffers , which
* maximizes the opportunites to have a single copy from next_in to next_out .
* maximizes the opportuniti es to have a single copy from next_in to next_out .
*/
local block_state deflate_stored ( s , flush )
deflate_state * s ;
@ -1890,7 +1895,7 @@ local block_state deflate_fast(s, flush)
if ( s - > lookahead = = 0 ) break ; /* flush the current block */
}
/* Insert the string window[strstart .. strstart+2] in the
/* Insert the string window[strstart .. strstart + 2] in the
* dictionary , and set hash_head to the head of the hash chain :
*/
hash_head = NIL ;
@ -1938,7 +1943,7 @@ local block_state deflate_fast(s, flush)
s - > strstart + = s - > match_length ;
s - > match_length = 0 ;
s - > ins_h = s - > window [ s - > strstart ] ;
UPDATE_HASH ( s , s - > ins_h , s - > window [ s - > strstart + 1 ] ) ;
UPDATE_HASH ( s , s - > ins_h , s - > window [ s - > strstart + 1 ] ) ;
# if MIN_MATCH != 3
Call UPDATE_HASH ( ) MIN_MATCH - 3 more times
# endif
@ -1949,7 +1954,7 @@ local block_state deflate_fast(s, flush)
} else {
/* No match, output a literal byte */
Tracevv ( ( stderr , " %c " , s - > window [ s - > strstart ] ) ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart ] , bflush ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart ] , bflush ) ;
s - > lookahead - - ;
s - > strstart + + ;
}
@ -1993,7 +1998,7 @@ local block_state deflate_slow(s, flush)
if ( s - > lookahead = = 0 ) break ; /* flush the current block */
}
/* Insert the string window[strstart .. strstart+2] in the
/* Insert the string window[strstart .. strstart + 2] in the
* dictionary , and set hash_head to the head of the hash chain :
*/
hash_head = NIL ;
@ -2035,17 +2040,17 @@ local block_state deflate_slow(s, flush)
uInt max_insert = s - > strstart + s - > lookahead - MIN_MATCH ;
/* Do not insert strings in hash table beyond this. */
check_match ( s , s - > strstart - 1 , s - > prev_match , s - > prev_length ) ;
check_match ( s , s - > strstart - 1 , s - > prev_match , s - > prev_length ) ;
_tr_tally_dist ( s , s - > strstart - 1 - s - > prev_match ,
_tr_tally_dist ( s , s - > strstart - 1 - s - > prev_match ,
s - > prev_length - MIN_MATCH , bflush ) ;
/* Insert in hash table all strings up to the end of the match.
* strstart - 1 and strstart are already inserted . If there is not
* strstart - 1 and strstart are already inserted . If there is not
* enough lookahead , the last two strings are not inserted in
* the hash table .
*/
s - > lookahead - = s - > prev_length - 1 ;
s - > lookahead - = s - > prev_length - 1 ;
s - > prev_length - = 2 ;
do {
if ( + + s - > strstart < = max_insert ) {
@ -2063,8 +2068,8 @@ local block_state deflate_slow(s, flush)
* single literal . If there was a match but the current match
* is longer , truncate the previous match to a single literal .
*/
Tracevv ( ( stderr , " %c " , s - > window [ s - > strstart - 1 ] ) ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart - 1 ] , bflush ) ;
Tracevv ( ( stderr , " %c " , s - > window [ s - > strstart - 1 ] ) ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart - 1 ] , bflush ) ;
if ( bflush ) {
FLUSH_BLOCK_ONLY ( s , 0 ) ;
}
@ -2082,8 +2087,8 @@ local block_state deflate_slow(s, flush)
}
Assert ( flush ! = Z_NO_FLUSH , " no flush? " ) ;
if ( s - > match_available ) {
Tracevv ( ( stderr , " %c " , s - > window [ s - > strstart - 1 ] ) ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart - 1 ] , bflush ) ;
Tracevv ( ( stderr , " %c " , s - > window [ s - > strstart - 1 ] ) ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart - 1 ] , bflush ) ;
s - > match_available = 0 ;
}
s - > insert = s - > strstart < MIN_MATCH - 1 ? s - > strstart : MIN_MATCH - 1 ;
@ -2140,7 +2145,8 @@ local block_state deflate_rle(s, flush)
if ( s - > match_length > s - > lookahead )
s - > match_length = s - > lookahead ;
}
Assert ( scan < = s - > window + ( uInt ) ( s - > window_size - 1 ) , " wild scan " ) ;
Assert ( scan < = s - > window + ( uInt ) ( s - > window_size - 1 ) ,
" wild scan " ) ;
}
/* Emit match if have run of MIN_MATCH or longer, else emit literal */
@ -2155,7 +2161,7 @@ local block_state deflate_rle(s, flush)
} else {
/* No match, output a literal byte */
Tracevv ( ( stderr , " %c " , s - > window [ s - > strstart ] ) ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart ] , bflush ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart ] , bflush ) ;
s - > lookahead - - ;
s - > strstart + + ;
}
@ -2195,7 +2201,7 @@ local block_state deflate_huff(s, flush)
/* Output a literal byte */
s - > match_length = 0 ;
Tracevv ( ( stderr , " %c " , s - > window [ s - > strstart ] ) ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart ] , bflush ) ;
_tr_tally_lit ( s , s - > window [ s - > strstart ] , bflush ) ;
s - > lookahead - - ;
s - > strstart + + ;
if ( bflush ) FLUSH_BLOCK ( s , 0 ) ;
Alexander Alekhin
2 years ago
