WebSVN – Kolibri OS – Diff – /programs/fs/kfar/trunk/zlib/deflate.asm


; deflate.asm -- compress data using the deflation algorithm
; Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
; For conditions of distribution and use, see copyright notice in zlib.inc
 
;  ALGORITHM
 
;      The "deflation" process depends on being able to identify portions
;      of the input text which are identical to earlier input (within a
;      sliding window trailing behind the input currently being processed).
 
;      The most straightforward technique turns out to be the fastest for
;      most input files: try all possible matches and select the longest.
;      The key feature of this algorithm is that insertions into the string
;      dictionary are very simple and thus fast, and deletions are avoided
;      completely. Insertions are performed at each input character, whereas
;      string matches are performed only when the previous match ends. So it
;      is preferable to spend more time in matches to allow very fast string
;      insertions and avoid deletions. The matching algorithm for small
;      strings is inspired from that of Rabin & Karp. A brute force approach
;      is used to find longer strings when a small match has been found.
;      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
;      (by Leonid Broukhis).
;         A previous version of this file used a more sophisticated algorithm
;      (by Fiala and Greene) which is guaranteed to run in linear amortized
;      time, but has a larger average cost, uses more memory and is patented.
;      However the F&G algorithm may be faster for some highly redundant
;      files if the parameter max_chain_length (described below) is too large.
 
;  ACKNOWLEDGEMENTS
 
;      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
;      I found it in 'freeze' written by Leonid Broukhis.
;      Thanks to many people for bug reports and testing.
 
;  REFERENCES
 
;      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
;      Available in http://tools.ietf.org/html/rfc1951
 
;      A description of the Rabin and Karp algorithm is given in the book
;         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
 
;      Fiala,E.R., and Greene,D.H.
;         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
 
 
deflate_copyright db ' deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ',0
 
;  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
;  include such an acknowledgment, I would appreciate that you keep this
;  copyright string in the executable of your product.
 
; ===========================================================================
;  Function prototypes.
 
;enum block_state
need_more   equ 1 ;block not completed, need more input or more output
block_done  equ 2 ;block flush performed
finish_started equ 3 ;finish started, need only more output at next deflate
finish_done equ 4 ;finish done, accept no more input or output
 
; ===========================================================================
; Local data
 
NIL equ 0
; Tail of hash chains
 
TOO_FAR equ 4096
; Matches of length 3 are discarded if their distance exceeds TOO_FAR
 
; Values for max_lazy_match, good_match and max_chain_length, depending on
; the desired pack level (0..9). The values given below have been tuned to
; exclude worst case performance for pathological files. Better values may be
; found for specific files.
 
struct config_s ;config
	good_length dw ? ;uint_16 ;reduce lazy search above this match length
	max_lazy    dw ? ;uint_16 ;do not perform lazy search above this match length
	nice_length dw ? ;uint_16 ;quit search above this match length
	max_chain   dw ? ;uint_16
	co_func     dd ? ;compress_func
ends
 
align 16
configuration_table:
	config_s  0,   0,   0,    0, deflate_stored  ;store only
	config_s  4,   4,   8,    4, deflate_fast ;max speed, no lazy matches
if FASTEST eq 0
	config_s  4,   5,  16,    8, deflate_fast
	config_s  4,   6,  32,   32, deflate_fast
	config_s  4,   4,  16,   16, deflate_slow ;lazy matches
	config_s  8,  16,  32,   32, deflate_slow
	config_s  8,  16, 128,  128, deflate_slow
	config_s  8,  32, 128,  256, deflate_slow
	config_s 32, 128, 258, 1024, deflate_slow
	config_s 32, 258, 258, 4096, deflate_slow ;max compression
end if
 
; Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
; For deflate_fast() (levels <= 3) good is ignored and lazy has a different
; meaning.
 
 
EQUAL equ 0
; result of memcmp for equal strings
 
; rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH
macro RANK f, reg
{
local .end0
	xor reg,reg
	cmp f,4
	jle .end0
		sub reg,9
	.end0:
	add reg,f
	add reg,f
}
 
; ===========================================================================
; Update a hash value with the given input byte
; IN  assertion: all calls to to UPDATE_HASH are made with consecutive
;    input characters, so that a running hash key can be computed from the
;    previous key instead of complete recalculation each time.
 
macro UPDATE_HASH s,h,c
{
push ebx ecx
	mov ebx,h
	mov ecx,[s+deflate_state.hash_shift]
	shl ebx,cl
	xor ebx,c
	and ebx,[s+deflate_state.hash_mask]
	mov h,ebx
pop ecx ebx
}
 
; ===========================================================================
; Insert string str in the dictionary and set match_head to the previous head
; of the hash chain (the most recent string with same hash key). Return
; the previous length of the hash chain.
; If this file is compiled with -DFASTEST, the compression level is forced
; to 1, and no hash chains are maintained.
; IN  assertion: all calls to to INSERT_STRING are made with consecutive
;    input characters and the first MIN_MATCH bytes of str are valid
;    (except for the last MIN_MATCH-1 bytes of the input file).
 
macro INSERT_STRING s, str, match_head
{
	mov eax,[s+deflate_state.window]
	add eax,str
	add eax,MIN_MATCH-1
	movzx eax,byte[eax]
	UPDATE_HASH s, [s+deflate_state.ins_h], eax
	mov eax,[s+deflate_state.ins_h]
	shl eax,2
	add eax,[s+deflate_state.head]
	mov eax,[eax]
	mov match_head,eax
if FASTEST eq 0
push ebx
	mov ebx,[s+deflate_state.w_mask]
	and ebx,str
	shl ebx,2
	add ebx,[s+deflate_state.prev]
	mov [ebx],eax
pop ebx
end if
	mov eax,[s+deflate_state.ins_h]
	shl eax,2
	add eax,[s+deflate_state.head]
	push str
	pop dword[eax]
}
 
; ===========================================================================
; Initialize the hash table (avoiding 64K overflow for 16 bit systems).
; prev[] will be initialized on the fly.
 
macro CLEAR_HASH s
{
	;mov eax,[s+deflate_state.hash_size]
	;dec eax
	;shl eax,2
	;add eax,[s+deflate_state.head]
	;mov dword[eax],NIL
	mov eax,[s+deflate_state.hash_size]
	;dec eax
	shl eax,2 ;sizeof(*s.head)
	stdcall zmemzero, [s+deflate_state.head], eax
}
 
align 4
proc deflateInit, strm:dword, level:dword
	stdcall deflateInit_, [strm], [level], ZLIB_VERSION, sizeof.z_stream
	ret
endp
 
; =========================================================================
;int (strm, level, version, stream_size)
;    z_streamp strm
;    int level
;    const char *version
;    int stream_size
align 4
proc deflateInit_, strm:dword, level:dword, version:dword, stream_size:dword
	stdcall deflateInit2_, [strm], [level], Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,\
			Z_DEFAULT_STRATEGY, [version], [stream_size]
	; To do: ignore strm->next_in if we use it as window
	ret
endp
 
align 4
proc deflateInit2, strm:dword, level:dword, method:dword, windowBits:dword, memLevel:dword, strategy:dword
	stdcall deflateInit2_, [strm],[level],[method],[windowBits],[memLevel],\
		[strategy], ZLIB_VERSION, sizeof.z_stream
	ret
endp
 
; =========================================================================
;int (strm, level, method, windowBits, memLevel, strategy,
;                  version, stream_size)
;    z_streamp strm
;    int  level
;    int  method
;    int  windowBits
;    int  memLevel
;    int  strategy
;    const char *version
;    int stream_size
align 4
proc deflateInit2_ uses ebx ecx edx edi, strm:dword, level:dword, method:dword,\
	windowBits:dword, memLevel:dword, strategy:dword, version:dword, stream_size:dword
locals
	wrap dd 1 ;int
	overlay dd ? ;uint_16p
endl
	; We overlay pending_buf and d_buf+l_buf. This works since the average
	; output size for (length,distance) codes is <= 24 bits.
 
	mov eax,[version]
	cmp eax,Z_NULL
	je @f
	mov ebx,dword[ZLIB_VERSION]
	cmp dword[eax],ebx
	jne @f
	cmp dword[stream_size],sizeof.z_stream
	je .end0
	@@: ;if (..==0 || ..[0]!=..[0] || ..!=..)
		mov eax,Z_VERSION_ERROR
		jmp .end_f
	.end0:
	mov ebx,[strm]
	cmp ebx,Z_NULL
	jne @f ;if (..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:
 
	mov dword[ebx+z_stream.msg],Z_NULL
	cmp dword[ebx+z_stream.zalloc],0
	jne @f ;if (..==0)
if Z_SOLO eq 1
		mov eax,Z_STREAM_ERROR
		jmp .end_f
else
		mov dword[ebx+z_stream.zalloc],zcalloc
		mov dword[ebx+z_stream.opaque],0
end if
	@@:
	cmp dword[ebx+z_stream.zfree],0
	jne @f ;if (..==0)
if Z_SOLO eq 1
		mov eax,Z_STREAM_ERROR
		jmp .end_f
else
		mov dword[ebx+z_stream.zfree],zcfree
end if
	@@:
 
if FASTEST eq 1
	cmp dword[level],0
	je @f ;if (..!=0)
		mov dword[level],1
	@@:
else
	cmp dword[level],Z_DEFAULT_COMPRESSION
	jne @f ;if (..==0)
		mov dword[level],6
	@@:
end if
 
	cmp dword[windowBits],0
	jge @f ;if (..<0) ;suppress zlib wrapper
		mov dword[wrap],0
		neg dword[windowBits]
		inc dword[windowBits]
		jmp .end1
	@@:
if GZIP eq 1
	cmp dword[windowBits],15
	jle .end1 ;else if (..>15)
		mov dword[wrap],2 ;write gzip wrapper instead
		sub dword[windowBits],16
end if
	.end1:
	cmp dword[memLevel],1
	jl .end2
	cmp dword[memLevel],MAX_MEM_LEVEL
	jg .end2
	cmp dword[method],Z_DEFLATED
	jne .end2
	cmp dword[windowBits],8
	jl .end2
	cmp dword[windowBits],15
	jg .end2
	cmp dword[level],0
	jl .end2
	cmp dword[level],9
	jg .end2
	cmp dword[strategy],0
	jl .end2
	cmp dword[strategy],Z_FIXED
	jle @f
	.end2: ;if (..<.. || ..>.. || ..!=.. || ..<.. || ..>.. || ..<0 || ..>.. || ..<0 || ..>..)
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:
	cmp dword[windowBits],8
	jne @f ;if (..==..)
		inc dword[windowBits] ;until 256-byte window bug fixed
	@@:
	ZALLOC ebx, 1, sizeof.deflate_state
	;eax = s
	cmp eax,Z_NULL
	jne @f ;if (..==0)
		mov eax,Z_MEM_ERROR
		jmp .end_f
	@@:
	mov edi,eax ;edi = s
	mov [ebx+z_stream.state],edi
	mov [edi+deflate_state.strm],ebx
 
	mov eax,[wrap]
	mov [edi+deflate_state.wrap],eax
	mov [edi+deflate_state.gzhead],Z_NULL
	mov ecx,[windowBits]
	mov [edi+deflate_state.w_bits],ecx
	xor eax,eax
	inc eax
	shl eax,cl
	mov [edi+deflate_state.w_size],eax
	dec eax
	mov [edi+deflate_state.w_mask],eax
 
	mov ecx,[memLevel]
	add ecx,7
	mov [edi+deflate_state.hash_bits],ecx
	xor eax,eax
	inc eax
	shl eax,cl
	mov [edi+deflate_state.hash_size],eax
	dec eax
	mov [edi+deflate_state.hash_mask],eax
	add ecx,MIN_MATCH-1
	xor edx,edx
	mov eax,ecx
	mov ecx,MIN_MATCH
	div ecx
	mov [edi+deflate_state.hash_shift],eax
 
	ZALLOC ebx, [edi+deflate_state.w_size], 2 ;2*sizeof(Byte)
	mov [edi+deflate_state.window],eax
	ZALLOC ebx, [edi+deflate_state.w_size], 4 ;sizeof(Pos)
	mov [edi+deflate_state.prev],eax
	ZALLOC ebx, [edi+deflate_state.hash_size], 4 ;sizeof(Pos)
	mov [edi+deflate_state.head],eax
 
	mov dword[edi+deflate_state.high_water],0 ;nothing written to s->window yet
 
	mov ecx,[memLevel]
	add ecx,6
	xor eax,eax
	inc eax
	shl eax,cl
	mov [edi+deflate_state.lit_bufsize],eax ;16K elements by default
 
	ZALLOC ebx, eax, 4 ;sizeof(uint_16)+2
	mov [overlay],eax
	mov [edi+deflate_state.pending_buf],eax
	mov eax,[edi+deflate_state.lit_bufsize]
	imul eax,4 ;sizeof(uint_16)+2
	mov [edi+deflate_state.pending_buf_size],eax
 
	cmp dword[edi+deflate_state.window],Z_NULL
	je .end3
	cmp dword[edi+deflate_state.prev],Z_NULL
	je .end3
	cmp dword[edi+deflate_state.head],Z_NULL
	je .end3
	cmp dword[edi+deflate_state.pending_buf],Z_NULL
	je .end3
		jmp @f
	.end3: ;if (..==0 || ..==0 || ..==0 || ..==0)
		mov dword[edi+deflate_state.status],FINISH_STATE
		ERR_MSG Z_MEM_ERROR
		mov [ebx+z_stream.msg],eax
		stdcall deflateEnd, ebx
		mov eax,Z_MEM_ERROR
		jmp .end_f
	@@:
	mov eax,[edi+deflate_state.lit_bufsize]
	shr eax,1 ;/=sizeof(uint_16)
	add eax,[overlay]
	mov [edi+deflate_state.d_buf],eax
	mov eax,[edi+deflate_state.lit_bufsize]
	imul eax,3 ;1+sizeof(uint_16)
	add eax,[edi+deflate_state.pending_buf]
	mov [edi+deflate_state.l_buf],eax
 
	mov eax,[level]
	mov [edi+deflate_state.level],ax
	mov eax,[strategy]
	mov [edi+deflate_state.strategy],ax
	mov eax,[method]
	mov [edi+deflate_state.method],al
 
	stdcall deflateReset, ebx
.end_f:
zlib_debug 'deflateInit2_ strategy = %d',[strategy]
	ret
endp
 
; =========================================================================
;int (strm, dictionary, dictLength)
;    z_streamp strm
;    const Bytef *dictionary
;    uInt  dictLength
align 4
proc deflateSetDictionary uses ebx edi, strm:dword, dictionary:dword, dictLength:dword
locals
;    uInt str, n;
	wrap  dd ? ;int
	avail dd ? ;unsigned
	next  dd ? ;unsigned char*
endl
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state]
	cmp edi,Z_NULL
	je @f
	cmp dword[dictionary],Z_NULL
	je @f ;if (..==0 || ..==0 || ..==0)
		jmp .end0
	@@:
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	
	mov eax,[edi+deflate_state.wrap]
	mov [wrap],eax
	cmp dword[wrap],2
	je .end1
	cmp dword[edi+deflate_state.lookahead],0
	jne .end1
	cmp dword[wrap],1
	jne @f
	cmp dword[edi+deflate_state.status],INIT_STATE
	je @f
	.end1: ;if (..==.. || .. || (..==.. && ..!=..)) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:
 
	; when using zlib wrappers, compute Adler-32 for provided dictionary
	cmp dword[wrap],1
	jne @f ;if (..==..)
		stdcall adler32, [ebx+z_stream.adler], [dictionary], [dictLength]
		mov [ebx+z_stream.adler],eax
	@@:
	mov dword[edi+deflate_state.wrap],0 ;avoid computing Adler-32 in read_buf
 
	; if dictionary would fill window, just replace the history
	mov eax,[edi+deflate_state.w_size]
	cmp [dictLength],eax
	jl .end2 ;if (..>=..)
;        if (wrap == 0) {            /* already empty otherwise */
;            CLEAR_HASH(s);
;            s->strstart = 0;
;            s->block_start = 0L;
;            s->insert = 0;
;        }
;        dictionary += dictLength - s->w_size;  /* use the tail */
		mov eax,[edi+deflate_state.w_size]
		mov [dictLength],eax
	.end2:
 
	; insert dictionary into window and hash
;    avail = strm->avail_in;
;    next = strm->next_in;
;    strm->avail_in = dictLength;
;    strm->next_in = (z_const Bytef *)dictionary;
;    fill_window(s);
;    while (s->lookahead >= MIN_MATCH) {
;        str = s->strstart;
;        n = s->lookahead - (MIN_MATCH-1);
;        do {
;            UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
if FASTEST eq 0
;            s->prev[str & s->w_mask] = s->head[s->ins_h];
end if
;            s->head[s->ins_h] = (Pos)str;
;            str++;
;        } while (--n);
;        s->strstart = str;
;        s->lookahead = MIN_MATCH-1;
;        fill_window(s);
;    }
;    s->strstart += s->lookahead;
;    s->block_start = (long)s->strstart;
	mov eax,[edi+deflate_state.lookahead]
	mov [edi+deflate_state.insert],eax
	mov dword[edi+deflate_state.lookahead],0
	mov eax,MIN_MATCH-1
	mov [edi+deflate_state.prev_length],eax
	mov [edi+deflate_state.match_length],eax
	mov dword[edi+deflate_state.match_available],0
	mov eax,[next]
	mov [ebx+z_stream.next_in],eax
	mov eax,[avail]
	mov [ebx+z_stream.avail_in],eax
	mov eax,[wrap]
	mov [edi+deflate_state.wrap],eax
	mov eax,Z_OK
.end_f:
	ret
endp
 
; =========================================================================
;int (strm)
;    z_streamp strm
align 4
proc deflateResetKeep uses ebx edi, strm:dword
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state]
	cmp edi,Z_NULL
	je @f
	cmp dword[ebx+z_stream.zalloc],0
	je @f
	cmp dword[ebx+z_stream.zfree],0
	je @f ;if (..==0 || ..==0 || ..==0 || ..==0)
		jmp .end0
	@@:
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
 
	mov dword[ebx+z_stream.total_out],0
	mov dword[ebx+z_stream.total_in],0
	mov dword[ebx+z_stream.msg],Z_NULL ;use zfree if we ever allocate msg dynamically
	mov dword[ebx+z_stream.data_type],Z_UNKNOWN
 
	mov dword[edi+deflate_state.pending],0
	mov eax,[edi+deflate_state.pending_buf]
	mov [edi+deflate_state.pending_out],eax
 
	cmp dword[edi+deflate_state.wrap],0
	jge @f ;if (..<0)
		neg dword[edi+deflate_state.wrap]
		inc dword[edi+deflate_state.wrap] ;was made negative by deflate(..., Z_FINISH)
	@@:
	mov eax,BUSY_STATE
	cmp dword[edi+deflate_state.wrap],0
	je @f
		mov eax,INIT_STATE
	@@:
	mov dword[edi+deflate_state.status],eax
	stdcall adler32, 0, Z_NULL, 0
if GZIP eq 1
	cmp dword[edi+deflate_state.wrap],2
	jne @f
		xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
	@@:
end if
	mov dword[ebx+z_stream.adler],eax
	mov dword[edi+deflate_state.last_flush],Z_NO_FLUSH
	stdcall _tr_init, edi
 
	mov eax,Z_OK
.end_f:
	ret
endp
 
; =========================================================================
;int (strm)
;    z_streamp strm
align 4
proc deflateReset uses ebx, strm:dword
	mov ebx,[strm]
	zlib_debug 'deflateReset'
	stdcall deflateResetKeep, ebx
	cmp eax,Z_OK
	jne @f ;if (..==Z_OK)
		stdcall lm_init, [ebx+z_stream.state]
	@@:
	ret
endp
 
; =========================================================================
;int (strm, head)
;    z_streamp strm
;    gz_headerp head
align 4
proc deflateSetHeader uses ebx, strm:dword, head:dword
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov ebx,[ebx+z_stream.state]
	cmp ebx,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	cmp dword[ebx+deflate_state.wrap],2
	je @f ;if (..!=..) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:
	mov eax,[head]
	mov [ebx+deflate_state.gzhead],eax
	mov eax,Z_OK
.end_f:
	ret
endp
 
; =========================================================================
;int (strm, pending, bits)
;    unsigned *pending
;    int *bits
;    z_streamp strm
align 4
proc deflatePending uses ebx edi, strm:dword, pending:dword, bits:dword
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state]
	cmp edi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	cmp dword[pending],Z_NULL
	je @f ;if (..!=..)
		mov eax,[pending]
		mov ebx,[edi+deflate_state.pending]
		mov [eax],ebx
	@@:
	cmp dword[bits],Z_NULL
	je @f ;if (..!=..)
		mov eax,[bits]
		mov ebx,[edi+deflate_state.bi_valid]
		mov [eax],ebx
	@@:
	mov eax,Z_OK
.end_f:
	ret
endp
 
; =========================================================================
;int (strm, bits, value)
;    z_streamp strm
;    int bits
;    int value
align 4
proc deflatePrime uses ebx edi, strm:dword, bits:dword, value:dword
;    int put;
 
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state] ;s = strm.state
	cmp edi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
;    if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
;        return Z_BUF_ERROR;
;    do {
;        put = Buf_size - s->bi_valid;
;        if (put > bits)
;            put = bits;
;        s->bi_buf |= (uint_16)((value & ((1 << put) - 1)) << s->bi_valid);
;        s->bi_valid += put;
;        _tr_flush_bits(s);
;        value >>= put;
;        bits -= put;
;    } while (bits);
	mov eax,Z_OK
.end_f:
	ret
endp
 
; =========================================================================
;int (strm, level, strategy)
;    z_streamp strm
;    int level
;    int strategy
align 4
proc deflateParams uses ebx edi, strm:dword, level:dword, strategy:dword
locals
	co_func dd ?
	err dd Z_OK
endl
 
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state] ;s = strm.state
	cmp edi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
 
if FASTEST eq 1
	cmp dword[level],0
	je @f ;if (..!=0)
		mov dword[level],1
	@@:
else
	cmp dword[level],Z_DEFAULT_COMPRESSION
	jne @f ;if (..==0)
		mov dword[level],6
	@@:
end if
	cmp dword[level],0
	jl @f
	cmp dword[level],9
	jg @f
	cmp dword[strategy],0
	jl @f
	cmp dword[strategy],Z_FIXED
	jle .end1
	@@: ;if (..<0 || ..>9 || ..<0 || ..>..)
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end1:
	movzx eax,word[edi+deflate_state.level]
	imul eax,sizeof.config_s
	add eax,configuration_table+config_s.co_func
	mov [co_func],eax
 
;    if ((strategy != s->strategy || co_func != configuration_table[level].func) &&
;        strm->total_in != 0) {
		; Flush the last buffer:
;        err = deflate(strm, Z_BLOCK);
;        if (err == Z_BUF_ERROR && s->pending == 0)
;            err = Z_OK;
;    }
;    if (s->level != level) {
;        s->level = level;
;        s->max_lazy_match   = configuration_table[level].max_lazy;
;        s->good_match       = configuration_table[level].good_length;
;        s->nice_match       = configuration_table[level].nice_length;
;        s->max_chain_length = configuration_table[level].max_chain;
;    }
	mov eax,[strategy]
	mov [edi+deflate_state.strategy],ax
	mov eax,[err]
.end_f:
	ret
endp
 
; =========================================================================
;int (strm, good_length, max_lazy, nice_length, max_chain)
;    z_streamp strm
;    int good_length
;    int max_lazy
;    int nice_length
;    int max_chain
align 4
proc deflateTune uses ebx, strm:dword, good_length:dword, max_lazy:dword,\
			nice_length:dword, max_chain:dword
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	cmp dword[ebx+z_stream.state],Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	mov ebx,[ebx+z_stream.state] ;s = strm.state
	mov eax,[good_length]
	mov [ebx+deflate_state.good_match],eax
	mov eax,[max_lazy]
	mov [ebx+deflate_state.max_lazy_match],eax
	mov eax,[nice_length]
	mov [ebx+deflate_state.nice_match],eax
	mov eax,[max_chain]
	mov [ebx+deflate_state.max_chain_length],eax
	mov eax,Z_OK
.end_f:
	ret
endp
 
; =========================================================================
; 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 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 deflate
; can emit on compressed data for some combinations of the parameters.
 
; 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.
 
;uLong (strm, sourceLen)
;    z_streamp strm
;    uLong sourceLen
align 4
proc deflateBound, strm:dword, sourceLen:dword
;    deflate_state *s;
;    uLong complen, wraplen;
;    Bytef *str;
	zlib_debug 'deflateBound'
 
	; conservative upper bound for compressed data
;    complen = sourceLen +
;              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
 
	; if can't get parameters, return conservative bound plus zlib wrapper
;    if (strm == Z_NULL || strm->state == Z_NULL)
;        return complen + 6;
 
	; compute wrapper length
;    s = strm->state;
;    switch (s->wrap) {
;    case 0:                                 /* raw deflate */
;        wraplen = 0;
;        break;
;    case 1:                                 /* zlib wrapper */
;        wraplen = 6 + (s->strstart ? 4 : 0);
;        break;
;    case 2:                                 /* gzip wrapper */
;        wraplen = 18;
;        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
;            if (s->gzhead->extra != Z_NULL)
;                wraplen += 2 + s->gzhead->extra_len;
;            str = s->gzhead->name;
;            if (str != Z_NULL)
;                do {
;                    wraplen++;
;                } while (*str++);
;            str = s->gzhead->comment;
;            if (str != Z_NULL)
;                do {
;                    wraplen++;
;                } while (*str++);
;            if (s->gzhead->hcrc)
;                wraplen += 2;
;        }
;        break;
;    default:                                /* for compiler happiness */
;        wraplen = 6;
;    }
 
	; if not default parameters, return conservative bound
;    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
;        return complen + wraplen;
 
	; default settings: return tight bound for that case
;    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
;           (sourceLen >> 25) + 13 - 6 + wraplen;
.end_f:
	ret
endp
 
; =========================================================================
; Put a short in the pending buffer. The 16-bit value is put in MSB order.
; IN assertion: the stream state is correct and there is enough room in
; pending_buf.
 
;void (s, b)
;    deflate_state *s
;    uInt b
align 4
proc putShortMSB uses ebx ecx, s:dword, b:dword
	mov ebx,[s]
	mov ecx,[b]
	put_byte ebx, ch
	put_byte ebx, cl
	ret
endp
 
; =========================================================================
; Flush as much pending output as possible. All deflate() output goes
; through this function so some applications may wish to modify it
; to avoid allocating a large strm->next_out buffer and copying into it.
; (See also read_buf()).
 
;void (strm)
;    z_streamp strm
align 4
proc flush_pending uses eax ebx ecx edx, strm:dword
;ecx - len
;edx - deflate_state *s
;ebx - strm
	zlib_debug 'flush_pending'
	mov ebx,[strm]
	mov edx,[ebx+z_stream.state]
 
	stdcall _tr_flush_bits, edx
	mov ecx,[edx+deflate_state.pending]
	mov eax,[ebx+z_stream.avail_out]
	cmp ecx,eax
	jle @f ;if (..>..)
		mov ecx,eax
	@@:
	cmp ecx,0
	je @f
 
	stdcall zmemcpy, [ebx+z_stream.next_out], [edx+deflate_state.pending_out], ecx
	add [ebx+z_stream.next_out],ecx
	add [edx+deflate_state.pending_out],ecx
	add [ebx+z_stream.total_out],ecx
	sub [ebx+z_stream.avail_out],ecx
	sub [edx+deflate_state.pending],ecx
	cmp dword[edx+deflate_state.pending],0
	jne @f ;if (..==0)
		mov eax,[edx+deflate_state.pending_buf]
		mov [edx+deflate_state.pending_out],eax
	@@:
	ret
endp
 
; =========================================================================
;int (strm, flush)
;    z_streamp strm
;    int flush
align 4
proc deflate uses ebx ecx edx edi esi, strm:dword, flush:dword
locals
	old_flush dd ? ;int ;value of flush param for previous deflate call
	val dd ?
endl
	mov ebx,[strm]
zlib_debug 'deflate strm = %d',ebx
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state] ;s = strm.state
	cmp edi,Z_NULL
	je @f
	cmp dword[flush],Z_BLOCK
	jg @f
	cmp dword[flush],0
	jge .end10 ;if (..==0 || ..==0 || ..>.. || ..<0)
	@@:
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end10:
	cmp dword[ebx+z_stream.next_out],Z_NULL
	je .beg0
	cmp dword[ebx+z_stream.next_in],Z_NULL
	jne @f
	cmp dword[ebx+z_stream.avail_in],0
	jne .beg0
	@@:
	cmp dword[edi+deflate_state.status],FINISH_STATE
	jne .end0
	cmp dword[flush],Z_FINISH
	je .end0
	.beg0: ;if (..==0 || (..==0 && ..!=0) || (..==.. && ..!=..))
		ERR_RETURN ebx, Z_STREAM_ERROR
		jmp .end_f
	.end0:
	cmp dword[ebx+z_stream.avail_out],0
	jne @f ;if (..==0)
		ERR_RETURN ebx, Z_BUF_ERROR
		jmp .end_f
	@@:
 
	mov dword[edi+deflate_state.strm],ebx ;just in case
	mov eax,[edi+deflate_state.last_flush]
	mov [old_flush],eax
	mov eax,[flush]
	mov [edi+deflate_state.last_flush],eax
 
	; Write the header
	cmp dword[edi+deflate_state.status],INIT_STATE
	jne .end2 ;if (..==..)
if GZIP eq 1
		cmp dword[edi+deflate_state.wrap],2
		jne .end1 ;if (..==..)
			xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
			mov [ebx+z_stream.adler],eax
			put_byte edi, 31
			put_byte edi, 139
			put_byte edi, 8
			cmp dword[edi+deflate_state.gzhead],Z_NULL
			jne .end3 ;if (..==0)
				put_byte edi, 0
				put_dword edi, 0
				xor cl,cl
				cmp word[edi+deflate_state.level],2
				jge @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
				jl @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.level],9
				jne @f
					mov cl,2
				@@: ;..==.. ? 2 : (..>=.. || ..<.. ? 4 : 0)
				put_byte edi, cl
				put_byte edi, OS_CODE
				mov dword[edi+deflate_state.status],BUSY_STATE
				jmp .end2
			.end3: ;else
				mov edx,[edi+deflate_state.gzhead]
				xor cl,cl
				cmp [edx+gz_header.text],0
				je @f
					inc cl
				@@:
				cmp [edx+gz_header.hcrc],0
				je @f
					add cl,2
				@@:
				cmp [edx+gz_header.extra],Z_NULL
				je @f
					add cl,4
				@@:
				cmp [edx+gz_header.name],Z_NULL
				je @f
					add cl,8
				@@:
				cmp [edx+gz_header.comment],Z_NULL
				je @f
					add cl,16
				@@:
				put_byte edi, cl
				mov ecx,[edx+gz_header.time]
				put_dword edi, ecx
				xor cl,cl
				cmp word[edi+deflate_state.level],2
				jge @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
				jl @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.level],9
				jne @f
					mov cl,2
				@@: ;..==.. ? 2 : (..>=.. || ..<.. ? 4 : 0)
				put_byte edi, cl
				mov ecx,[edx+gz_header.os]
				put_byte edi, cl
				cmp dword[edx+gz_header.extra],Z_NULL
				je @f ;if (..!=0)
					mov ecx,[edx+gz_header.extra_len]
					put_byte edi, cl
					put_byte edi, ch
				@@:
				cmp dword[edx+gz_header.hcrc],0
				je @f ;if (..)
					stdcall calc_crc32, [ebx+z_stream.adler],\
						[edi+deflate_state.pending_buf], [edi+deflate_state.pending]
					mov [ebx+z_stream.adler],eax
				@@:
				mov dword[edi+deflate_state.gzindex],0
				mov dword[edi+deflate_state.status],EXTRA_STATE
			jmp .end2
		.end1: ;else
end if
			mov edx,[edi+deflate_state.w_bits]
			sub edx,8
			shl edx,4
			add edx,Z_DEFLATED
			shl edx,8 ;edx = header
			;esi = level_flags
 
			mov esi,3
			cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
			jge @f
			cmp word[edi+deflate_state.level],2
			jge .end30 ;if (..>=.. || ..<..)
			@@:
				xor esi,esi
				jmp .end4
			.end30:
			cmp word[edi+deflate_state.level],6
			jge @f ;else if (..<..)
				mov esi,1
				jmp .end4
			@@:
			;;cmp word[edi+deflate_state.level],6
			jne .end4 ;else if (..==..)
				mov esi,2
			.end4:
			shl esi,6
			or edx,esi
			cmp dword[edi+deflate_state.strstart],0
			je @f ;if (..!=0)
				or edx,PRESET_DICT
			@@:
			mov esi,edx
			mov eax,edx
			xor edx,edx
			mov ecx,31
			div ecx
			add esi,31
			sub esi,edx ;esi = header
 
			mov dword[edi+deflate_state.status],BUSY_STATE
			stdcall putShortMSB, edi, esi
 
			; Save the adler32 of the preset dictionary:
			cmp dword[edi+deflate_state.strstart],0
			je @f ;if (..!=0)
				mov ecx,[ebx+z_stream.adler]
				bswap ecx
				put_dword edi, ecx
			@@:
			xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
			mov [ebx+z_stream.adler],eax
	.end2:
if GZIP eq 1
	mov edx,[edi+deflate_state.gzhead]
	cmp dword[edi+deflate_state.status],EXTRA_STATE
	jne .end5 ;if (..==..)
		cmp dword[edx+gz_header.extra],Z_NULL
		je .end21 ;if (..!=..)
			mov esi,[edi+deflate_state.pending]
			;esi = beg ;start of bytes to update crc
 
			movzx ecx,word[edx+gz_header.extra_len]
			.cycle0: ;while (..<..)
			cmp dword[edi+deflate_state.gzindex],ecx
			jge .cycle0end
				mov eax,[edi+deflate_state.pending]
				cmp eax,[edi+deflate_state.pending_buf_size]
				jne .end24 ;if (..==..)
					mov dword[edx+gz_header.hcrc],0
					je @f
					cmp [edi+deflate_state.pending],esi
					jle @f ;if (.. && ..>..)
						mov ecx,[edi+deflate_state.pending]
						sub ecx,esi
						mov eax,[edi+deflate_state.pending_buf]
						add eax,esi
						stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
						mov [ebx+z_stream.adler],eax
					@@:
					stdcall flush_pending, ebx
					mov esi,[edi+deflate_state.pending]
					cmp esi,[edi+deflate_state.pending_buf_size]
					je .cycle0end ;if (..==..) break
				.end24:
				push ebx
					mov ebx,[edi+deflate_state.gzindex]
					add ebx,[edx+gz_header.extra]
					mov bl,[ebx]
					put_byte edi, bl
				pop ebx
				inc dword[edi+deflate_state.gzindex]
				jmp .cycle0
			.cycle0end:
			mov dword[edx+gz_header.hcrc],0
			je @f
			cmp [edi+deflate_state.pending],esi
			jle @f ;if (.. && ..>..)
				mov ecx,[edi+deflate_state.pending]
				sub ecx,esi
				mov eax,[edi+deflate_state.pending_buf]
				add eax,esi
				stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
				mov [ebx+z_stream.adler],eax
			@@:
			mov eax,[edx+gz_header.extra_len]
			cmp dword[edi+deflate_state.gzindex],eax
			jne .end5 ;if (..==..)
				mov dword[edi+deflate_state.gzindex],0
				mov dword[edi+deflate_state.status],NAME_STATE
			jmp .end5
		.end21: ;else
			mov dword[edi+deflate_state.status],NAME_STATE
	.end5:
	cmp dword[edi+deflate_state.status],NAME_STATE
	jne .end6 ;if (..==..)
		cmp dword[edx+gz_header.name],Z_NULL
		je .end22 ;if (..!=..)
			mov esi,[edi+deflate_state.pending]
			;esi = beg ;start of bytes to update crc
 
			.cycle1: ;do
				mov eax,[edi+deflate_state.pending]
				cmp eax,[edi+deflate_state.pending_buf_size]
				jne .end25 ;if (..==..)
					mov dword[edx+gz_header.hcrc],0
					je @f
					cmp [edi+deflate_state.pending],esi
					jle @f ;if (.. && ..>..)
						mov ecx,[edi+deflate_state.pending]
						sub ecx,esi
						mov eax,[edi+deflate_state.pending_buf]
						add eax,esi
						stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
						mov [ebx+z_stream.adler],eax
					@@:
					stdcall flush_pending, ebx
					mov esi,[edi+deflate_state.pending]
					cmp esi,[edi+deflate_state.pending_buf_size]
					jne .end25 ;if (..==..)
						mov dword[val],1
						jmp .cycle1end
				.end25:
				push ebx
					mov ebx,[edi+deflate_state.gzindex]
					add ebx,[edx+gz_header.name]
					movzx ebx,byte[ebx]
					mov [val],ebx
					inc dword[edi+deflate_state.gzindex]
					put_byte edi, bl
				pop ebx
				cmp dword[val],0
				jne .cycle1 ;while (val != 0)
			.cycle1end:
			mov dword[edx+gz_header.hcrc],0
			je @f
			cmp [edi+deflate_state.pending],esi
			jle @f ;if (.. && ..>..)
				mov ecx,[edi+deflate_state.pending]
				sub ecx,esi
				mov eax,[edi+deflate_state.pending_buf]
				add eax,esi
				stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
				mov [ebx+z_stream.adler],eax
			@@:
			cmp dword[val],0
			jne .end6 ;if (val == 0)
				mov dword[edi+deflate_state.gzindex],0
				mov dword[edi+deflate_state.status],COMMENT_STATE
			jmp .end6
		.end22: ;else
			mov dword[edi+deflate_state.status],COMMENT_STATE;
	.end6:
	cmp dword[edi+deflate_state.status],COMMENT_STATE
	jne .end7 ;if (..==..)
		cmp dword[edx+gz_header.comment],Z_NULL
		je .end23 ;if (..!=..)
			mov esi,[edi+deflate_state.pending]
			;esi = beg ;start of bytes to update crc
 
			.cycle2: ;do
				mov eax,[edi+deflate_state.pending]
				cmp eax,[edi+deflate_state.pending_buf_size]
				jne .end26 ;if (..==..)
					mov dword[edx+gz_header.hcrc],0
					je @f
					cmp [edi+deflate_state.pending],esi
					jle @f ;if (.. && ..>..)
						mov ecx,[edi+deflate_state.pending]
						sub ecx,esi
						mov eax,[edi+deflate_state.pending_buf]
						add eax,esi
						stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
						mov [ebx+z_stream.adler],eax
					@@:
					stdcall flush_pending, ebx
					mov esi,[edi+deflate_state.pending]
					cmp esi,[edi+deflate_state.pending_buf_size]
					jne .end26 ;if (..==..)
						mov dword[val],1
						jmp .cycle2end
				.end26:
				push ebx
					mov ebx,[edi+deflate_state.gzindex]
					add ebx,[edx+gz_header.comment]
					movzx ebx,byte[ebx]
					mov [val],ebx
					inc dword[edi+deflate_state.gzindex]
					put_byte edi, bl
				pop ebx
				cmp dword[val],0
				jne .cycle2 ;while (val != 0)
			.cycle2end:
			mov dword[edx+gz_header.hcrc],0
			je @f
			cmp [edi+deflate_state.pending],esi
			jle @f ;if (.. && ..>..)
				mov ecx,[edi+deflate_state.pending]
				sub ecx,esi
				mov eax,[edi+deflate_state.pending_buf]
				add eax,esi
				stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
				mov [ebx+z_stream.adler],eax
			@@:
			cmp dword[val],0
			jne .end7 ;if (val == 0)
				mov dword[edi+deflate_state.status],HCRC_STATE
			jmp .end7
		.end23: ;else
			mov dword[edi+deflate_state.status],HCRC_STATE
	.end7:
	cmp dword[edi+deflate_state.status],HCRC_STATE
	jne .end8 ;if (..==..)
		cmp dword[edx+gz_header.hcrc],0
		je .end9 ;if (..)
			mov ecx,[edi+deflate_state.pending]
			add ecx,2
			cmp ecx,[edi+deflate_state.pending_buf_size]
			jle @f ;if (..>..)
				stdcall flush_pending, ebx
			@@:
			mov ecx,[edi+deflate_state.pending]
			add ecx,2
			cmp ecx,[edi+deflate_state.pending_buf_size]
			jg @f ;if (..<=..)
				mov ecx,[ebx+z_stream.adler]
				put_byte edi, cl
				put_byte edi, ch
				xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
				mov [ebx+z_stream.adler],eax
				mov dword[edi+deflate_state.status],BUSY_STATE
			@@:
			jmp .end8
		.end9: ;else
			mov dword[edi+deflate_state.status],BUSY_STATE
	.end8:
end if
 
	; Flush as much pending output as possible
	cmp dword[edi+deflate_state.pending],0
	je .end13 ;if (..!=0)
		stdcall flush_pending, ebx
		cmp dword[ebx+z_stream.avail_out],0
		jne @f ;if (..==0)
			; Since avail_out is 0, deflate will be called again with
			; more output space, but possibly with both pending and
			; avail_in equal to zero. There won't be anything to do,
			; but this is not an error situation so make sure we
			; return OK instead of BUF_ERROR at next call of deflate:
 
			mov dword[edi+deflate_state.last_flush],-1
			mov eax,Z_OK
			jmp .end_f
		@@:
		; Make sure there is something to do and avoid duplicate consecutive
		; flushes. For repeated and useless calls with Z_FINISH, we keep
		; returning Z_STREAM_END instead of Z_BUF_ERROR.
		jmp @f
	.end13:
	cmp dword[ebx+z_stream.avail_in],0
	jne @f
	RANK dword[old_flush],esi
	RANK dword[flush],eax
	cmp eax,esi
	jg @f
	cmp dword[flush],Z_FINISH
	je @f ;else if (..==0 && ..<=.. && ..!=..)
		ERR_RETURN ebx, Z_BUF_ERROR
		jmp .end_f
	@@:
 
	; User must not provide more input after the first FINISH:
	cmp dword[edi+deflate_state.status],FINISH_STATE
	jne @f
	cmp dword[ebx+z_stream.avail_in],0
	je @f ;if (..==.. && ..!=0)
		ERR_RETURN ebx, Z_BUF_ERROR
		jmp .end_f
	@@:
 
	; Start a new block or continue the current one.
 
	cmp dword[ebx+z_stream.avail_in],0
	jne @f
	cmp dword[edi+deflate_state.lookahead],0
	jne @f
	cmp dword[flush],Z_NO_FLUSH
	je .end11
	cmp dword[edi+deflate_state.status],FINISH_STATE
	je .end11
	@@: ;if (..!=0 || ..!=0 || (..!=.. && ..!=..))
		;edx = bstate
		cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
		jne @f
			stdcall deflate_huff, edi, [flush]
			jmp .end20
		@@:
		cmp word[edi+deflate_state.strategy],Z_RLE
		jne @f
			stdcall deflate_rle, edi, [flush]
			jmp .end20
		@@:
		movzx eax,word[edi+deflate_state.level]
		imul eax,sizeof.config_s
		add eax,configuration_table+config_s.co_func
		stdcall dword[eax], edi, [flush]
		.end20:
		mov edx,eax
 
		cmp edx,finish_started
		je @f
		cmp edx,finish_done
		jne .end18
		@@: ;if (..==.. || ..==..)
			mov dword[edi+deflate_state.status],FINISH_STATE
		.end18:
		cmp edx,need_more
		je @f
		cmp edx,finish_started
		jne .end19
		@@: ;if (..==.. || ..==..)
			cmp dword[ebx+z_stream.avail_out],0
			jne @f ;if (..==0)
				mov dword[edi+deflate_state.last_flush],-1 ;avoid BUF_ERROR next call, see above
			@@:
			mov eax,Z_OK
			jmp .end_f
			; If flush != Z_NO_FLUSH && avail_out == 0, the next call
			; of deflate should use the same flush parameter to make sure
			; that the flush is complete. So we don't have to output an
			; empty block here, this will be done at next call. This also
			; ensures that for a very small output buffer, we emit at most
			; one empty block.
 
		.end19:
		cmp edx,block_done
		jne .end11 ;if (..==..)
			cmp dword[flush],Z_PARTIAL_FLUSH
			jne @f ;if (..==..)
				stdcall _tr_align, edi
				jmp .end16
			@@:
			cmp dword[flush],Z_BLOCK
			je .end16 ;else if (..!=..) ;FULL_FLUSH or SYNC_FLUSH
				stdcall _tr_stored_block, edi, 0, 0, 0
				; For a full flush, this empty block will be recognized
				; as a special marker by inflate_sync().
 
			cmp dword[flush],Z_FULL_FLUSH
			jne .end16 ;if (..==..)
				CLEAR_HASH edi ;forget history
				cmp dword[edi+deflate_state.lookahead],0
				jne .end16 ;if (..==0)
					mov dword[edi+deflate_state.strstart],0
					mov dword[edi+deflate_state.block_start],0
					mov dword[edi+deflate_state.insert],0
		.end16:
		stdcall flush_pending, ebx
		cmp dword[ebx+z_stream.avail_out],0
		jne .end11 ;if (..==0)
			mov dword[edi+deflate_state.last_flush],-1 ;avoid BUF_ERROR at next call, see above
			mov eax,Z_OK
			jmp .end_f
	.end11:
	cmp dword[ebx+z_stream.avail_out],0
	jg @f
		zlib_assert 'bug2' ;Assert(..>0)
	@@:
 
	cmp dword[flush],Z_FINISH
	je @f ;if (..!=0)
		mov eax,Z_OK
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.wrap],0
	jg @f ;if (..<=0)
		mov eax,Z_STREAM_END
		jmp .end_f
	@@:
 
	; Write the trailer
if GZIP eq 1
	cmp dword[edi+deflate_state.wrap],2
	jne @f ;if (..==..)
		mov ecx,[ebx+z_stream.adler]
		put_dword edi, ecx
		mov ecx,[ebx+z_stream.total_in]
		put_dword edi, ecx
		jmp .end17
	@@: ;else
end if
		mov ecx,[ebx+z_stream.adler]
		bswap ecx
		put_dword edi, ecx
	.end17:
	stdcall flush_pending, ebx
	; If avail_out is zero, the application will call deflate again
	; to flush the rest.
 
	cmp dword[edi+deflate_state.pending],0
	jle @f ;if (..>0) ;write the trailer only once!
		neg dword[edi+deflate_state.pending]
		inc dword[edi+deflate_state.pending]
	@@:
	mov eax,Z_OK
	cmp dword[edi+deflate_state.pending],0
	je .end_f
		mov eax,Z_STREAM_END
.end_f:
zlib_debug '  deflate.ret = %d',eax
	ret
endp
 
; =========================================================================
;int (strm)
;    z_streamp strm
align 4
proc deflateEnd uses ebx ecx edx, strm:dword
	mov ebx,[strm]
zlib_debug 'deflateEnd'
	cmp ebx,Z_NULL
	je @f
	mov edx,[ebx+z_stream.state]
	cmp edx,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
 
	mov ecx,[edx+deflate_state.status]
	cmp ecx,INIT_STATE
	je @f
	cmp ecx,EXTRA_STATE
	je @f
	cmp ecx,NAME_STATE
	je @f
	cmp ecx,COMMENT_STATE
	je @f
	cmp ecx,HCRC_STATE
	je @f
	cmp ecx,BUSY_STATE
	je @f
	cmp ecx,FINISH_STATE
	je @f ;if (..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=..)
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:
 
	; Deallocate in reverse order of allocations:
	TRY_FREE ebx, dword[edx+deflate_state.pending_buf]
	TRY_FREE ebx, dword[edx+deflate_state.head]
	TRY_FREE ebx, dword[edx+deflate_state.prev]
	TRY_FREE ebx, dword[edx+deflate_state.window]
 
	ZFREE ebx, dword[ebx+z_stream.state]
	mov dword[ebx+z_stream.state],Z_NULL
 
	mov eax,Z_DATA_ERROR
	cmp ecx,BUSY_STATE
	je .end_f
		mov eax,Z_OK
.end_f:
	ret
endp
 
; =========================================================================
; Copy the source state to the destination state.
; To simplify the source, this is not supported for 16-bit MSDOS (which
; doesn't have enough memory anyway to duplicate compression states).
 
;int (dest, source)
;    z_streamp dest
;    z_streamp source
align 4
proc deflateCopy uses ebx edx edi esi, dest:dword, source:dword
;ebx = overlay ;uint_16p
;edi = ds ;deflate_state*
;esi = ss ;deflate_state*
 
	mov esi,[source]
	cmp esi,Z_NULL
	je @f
	mov edx,[dest]
	cmp edx,Z_NULL
	je @f
	mov esi,[esi+z_stream.state]
	cmp esi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0 || ..==0)
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
 
	stdcall zmemcpy, edx, [source], sizeof.z_stream
 
	ZALLOC edx, 1, sizeof.deflate_state
	cmp eax,0
	jne @f ;if (..==0) return ..
		mov eax,Z_MEM_ERROR
		jmp .end_f
	@@:
	mov edi,eax
	mov [edx+z_stream.state],eax
	stdcall zmemcpy, edi, esi, sizeof.deflate_state
	mov dword[edi+deflate_state.strm],edx
 
	ZALLOC edx, [edi+deflate_state.w_size], 2 ;2*sizeof.db
	mov dword[edi+deflate_state.window],eax
	ZALLOC edx, [edi+deflate_state.w_size], 4 ;sizeof.dd
	mov dword[edi+deflate_state.prev],eax
	ZALLOC edx, [edi+deflate_state.hash_size], 4 ;sizeof.dd
	mov dword[edi+deflate_state.head],eax
	ZALLOC edx, [edi+deflate_state.lit_bufsize], 4 ;sizeof.dw+2
	mov ebx,eax
	mov dword[edi+deflate_state.pending_buf],eax
 
	cmp dword[edi+deflate_state.window],Z_NULL
	je @f
	cmp dword[edi+deflate_state.prev],Z_NULL
	je @f
	cmp dword[edi+deflate_state.head],Z_NULL
	je @f
	cmp dword[edi+deflate_state.pending_buf],Z_NULL
	jne .end1
	@@: ;if (..==0 || ..==0 || ..==0 || ..==0)
		stdcall deflateEnd, edx
		mov eax,Z_MEM_ERROR
		jmp .end_f
	.end1:
 
	; following zmemcpy do not work for 16-bit MSDOS
	mov eax,[edi+deflate_state.w_size]
	shl eax,1 ;*= 2*sizeof.db
	stdcall zmemcpy, [edi+deflate_state.window], [esi+deflate_state.window], eax
	mov eax,[edi+deflate_state.w_size]
	shl eax,2 ;*= sizeof.dd
	stdcall zmemcpy, [edi+deflate_state.prev], [esi+deflate_state.prev], eax
	mov eax,[edi+deflate_state.hash_size]
	shl eax,2 ;*= sizeof.dd
	stdcall zmemcpy, [edi+deflate_state.head], [esi+deflate_state.head], eax
	stdcall zmemcpy, [edi+deflate_state.pending_buf], [esi+deflate_state.pending_buf], [edi+deflate_state.pending_buf_size]
 
	mov eax,[edi+deflate_state.pending_buf]
	add eax,[esi+deflate_state.pending_out]
	sub eax,[esi+deflate_state.pending_buf]
	mov [edi+deflate_state.pending_out],eax
	mov eax,[edi+deflate_state.lit_bufsize]
	shr eax,1 ;/=sizeof.uint_16
	add eax,ebx
	mov [edi+deflate_state.d_buf],eax
	mov eax,[edi+deflate_state.lit_bufsize]
	imul eax,3 ;*=1+sizeof.uint_16
	add eax,[edi+deflate_state.pending_buf]
	mov [edi+deflate_state.l_buf],eax
 
	mov eax,edi
	add eax,deflate_state.dyn_ltree
	mov [edi+deflate_state.l_desc.dyn_tree],eax
	add eax,deflate_state.dyn_dtree-deflate_state.dyn_ltree
	mov [edi+deflate_state.d_desc.dyn_tree],eax
	add eax,deflate_state.bl_tree-deflate_state.dyn_dtree
	mov [edi+deflate_state.bl_desc.dyn_tree],eax
 
	mov eax,Z_OK
.end_f:
	ret
endp
 
; ===========================================================================
; Read a new buffer from the current input stream, update the adler32
; and total number of bytes read.  All deflate() input goes through
; this function so some applications may wish to modify it to avoid
; allocating a large strm->next_in buffer and copying from it.
; (See also flush_pending()).
 
;int (strm, buf, size)
;    z_streamp strm
;    Bytef *buf
;    unsigned size
align 4
proc read_buf uses ebx ecx, strm:dword, buf:dword, size:dword
	mov ebx,[strm]
	mov eax,[ebx+z_stream.avail_in]
 
	cmp eax,[size]
	jle @f ;if (..>..)
		mov eax,[size]
	@@:
	cmp eax,0
	jg @f
		xor eax,eax
		jmp .end_f ;if (..==0) return 0
	@@:
 
	sub [ebx+z_stream.avail_in],eax
 
	stdcall zmemcpy, [buf],[ebx+z_stream.next_in],eax
	mov ecx,[ebx+z_stream.state]
	cmp dword[ecx+deflate_state.wrap],1
	jne @f ;if (..==..)
		push eax
		stdcall adler32, [ebx+z_stream.adler], [buf], eax
		mov [ebx+z_stream.adler],eax
		pop eax
		jmp .end0
	@@:
if GZIP eq 1
	cmp dword[ecx+deflate_state.wrap],2
	jne .end0 ;else if (..==..)
		push eax
		stdcall calc_crc32, [ebx+z_stream.adler], [buf], eax
		mov [ebx+z_stream.adler],eax
		pop eax
end if
	.end0:
	add [ebx+z_stream.next_in],eax
	add [ebx+z_stream.total_in],eax
 
.end_f:
;zlib_debug '  read_buf.ret = %d',eax
	ret
endp
 
; ===========================================================================
; Initialize the "longest match" routines for a new zlib stream
 
;void (s)
;    deflate_state *s
align 4
proc lm_init uses eax ebx edi, s:dword
	mov edi,[s]
	mov eax,[edi+deflate_state.w_size]
	shl eax,1
	mov [edi+deflate_state.window_size],eax
 
	CLEAR_HASH edi
 
	; Set the default configuration parameters:
 
	movzx eax,word[edi+deflate_state.level]
	imul eax,sizeof.config_s
	add eax,configuration_table
	movzx ebx,word[eax+config_s.max_lazy]
	mov [edi+deflate_state.max_lazy_match],ebx
	movzx ebx,word[eax+config_s.good_length]
	mov [edi+deflate_state.good_match],ebx
	movzx ebx,word[eax+config_s.nice_length]
	mov [edi+deflate_state.nice_match],ebx
	movzx ebx,word[eax+config_s.max_chain]
	mov [edi+deflate_state.max_chain_length],ebx
 
	mov dword[edi+deflate_state.strstart],0
	mov dword[edi+deflate_state.block_start],0
	mov dword[edi+deflate_state.lookahead],0
	mov dword[edi+deflate_state.insert],0
	mov dword[edi+deflate_state.prev_length],MIN_MATCH-1
	mov dword[edi+deflate_state.match_length],MIN_MATCH-1
	mov dword[edi+deflate_state.match_available],0
	mov dword[edi+deflate_state.ins_h],0
if FASTEST eq 0
;if ASMV
;    call match_init ;initialize the asm code
;end if
end if
	ret
endp
 
;uInt (s, cur_match)
;    deflate_state *s
;    IPos cur_match ;current match
align 4
proc longest_match uses ebx ecx edx edi esi, s:dword, cur_match:dword
if FASTEST eq 0
; ===========================================================================
; Set match_start to the longest match starting at the given string and
; return its length. Matches shorter or equal to prev_length are discarded,
; in which case the result is equal to prev_length and match_start is
; garbage.
; IN assertions: cur_match is the head of the hash chain for the current
;   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.
locals
	chain_length dd ? ;unsigned ;max hash chain length
	len        dd ? ;int ;length of current match
	strend     dd ? ;Bytef *
	best_len   dd ? ;int ;best match length so far
	nice_match dd ? ;int ;stop if match long enough
	limit      dd NIL ;IPos
	prev       dd ? ;Posf *
	wmask      dd ? ;uInt
endl
	mov edx,[s]
	mov eax,[edx+deflate_state.max_chain_length]
	mov [chain_length],eax
	mov edi,[edx+deflate_state.window]
	add edi,[edx+deflate_state.strstart]
	;edi - Bytef *scan ;current string
	;esi - Bytef *match ;matched string
	mov eax,[edx+deflate_state.prev_length]
	mov [best_len],eax
	mov eax,[edx+deflate_state.nice_match]
	mov [nice_match],eax
 
	MAX_DIST edx
	cmp [edx+deflate_state.strstart],eax
	jle @f
		mov ecx,[edx+deflate_state.strstart]
		sub ecx,eax
		mov [limit],ecx
	@@:
	; Stop when cur_match becomes <= limit. To simplify the code,
	; we prevent matches with the string of window index 0.
	mov eax,[edx+deflate_state.prev]
	mov [prev],eax
	mov eax,[edx+deflate_state.w_mask]
	mov [wmask],eax
	mov eax,edi
	add eax,MAX_MATCH ;-1 ???
	mov [strend],eax
	mov eax,[best_len]
	dec eax
	mov bx,[edi+eax]
	;bl - Byte scan_end1
	;bh - Byte scan_end
 
	; The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
	; It is easy to get rid of this optimization if necessary.
 
if MAX_MATCH <> 258
	cmp dword[edx+deflate_state.hash_bits],8
	jge @f
		zlib_assert 'Code too clever' ;Assert(..>=.. && ..==..)
	@@:
end if
 
	; Do not waste too much time if we already have a good match:
	mov eax,[edx+deflate_state.good_match]
	cmp [edx+deflate_state.prev_length],eax
	jl @f ;if (..>=..)
		shr dword[chain_length],2
	@@:
	; Do not look for matches beyond the end of the input. This is necessary
	; to make deflate deterministic.
 
	mov eax,[edx+deflate_state.lookahead]
	cmp dword[nice_match],eax
	jle @f ;if (..>..)
		mov [nice_match],eax
	@@:
 
	mov eax,[edx+deflate_state.window_size]
	sub eax,MIN_LOOKAHEAD
	cmp [edx+deflate_state.strstart],eax
	jle .cycle0
		zlib_assert 'need lookahead' ;Assert(..<=..)
 
align 4
	.cycle0: ;do
		mov eax,[edx+deflate_state.strstart]
		cmp [cur_match],eax
		jl @f
			zlib_assert 'no future' ;Assert(..<..)
		@@:
		mov esi,[edx+deflate_state.window]
		add esi,[cur_match]
 
		; Skip to next match if the match length cannot increase
		; or if the match length is less than 2.  Note that the checks below
		; for insufficient lookahead only occur occasionally for performance
		; reasons.  Therefore uninitialized memory will be accessed, and
		; conditional jumps will be made that depend on those values.
		; However the length of the match is limited to the lookahead, so
		; the output of deflate is not affected by the uninitialized values.
 
		mov eax,[best_len]
		dec eax
		cmp word[esi+eax],bx
		jne .cycle0cont
		mov al,byte[esi]
		cmp al,byte[edi]
		jne .cycle0cont
		inc esi
		mov al,byte[esi]
		cmp al,[edi+1]
		jne .cycle0cont ;if (..!=.. || ..!=.. || ..!=.. || ..!=..) continue
 
		; 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
		; the hash keys are equal and that HASH_BITS >= 8.
 
		add edi,2
		inc esi
		mov al,byte[edi]
		cmp al,byte[esi]
		je @f
			zlib_assert 'match[2]?' ;Assert(..==..)
		@@:
 
		; We check for insufficient lookahead only every 8th comparison;
		; the 256th check will be made at strstart+258.
 
		inc edi
		inc esi
		mov ecx,[strend]
		sub ecx,edi
		jz @f
			repe cmpsb
			dec edi
			dec esi
		@@:
 
		mov eax,[edx+deflate_state.window_size]
		dec eax
		add eax,[edx+deflate_state.window]
		cmp edi,eax
		jle @f
			zlib_assert 'wild scan' ;Assert(..<=..)
		@@:
 
		mov eax,MAX_MATCH
		add eax,edi
		sub eax,[strend]
		mov [len],eax
		mov edi,[strend]
		sub edi,MAX_MATCH
 
		mov eax,[best_len]
		cmp [len],eax
		jle .cycle0cont ;if (..>..)
			mov eax,[cur_match]
			mov [edx+deflate_state.match_start],eax
			mov eax,[len]
			mov [best_len],eax
			mov eax,[nice_match]
			cmp [len],eax
			jge .cycle0end ;if (..>=..) break
			mov eax,[best_len]
			dec eax
			mov bx,[edi+eax]
 
		.cycle0cont:
		mov eax,[cur_match]
		and eax,[wmask]
		shl eax,2
		add eax,[prev]
		mov eax,[eax] ;eax = prev[cur_match & wmask]
		mov [cur_match],eax
		cmp eax,[limit]
		jle .cycle0end
		dec dword[chain_length]
		cmp dword[chain_length],0
		jne .cycle0
align 4
	.cycle0end: ;while (..>.. && ..!=0)
 
	mov eax,[edx+deflate_state.lookahead]
	cmp [best_len],eax
	jg @f ;if (..<=..)
		mov eax,[best_len]
	@@:	
;end if ;ASMV
 
else ;FASTEST
 
; ---------------------------------------------------------------------------
; Optimized version for FASTEST only
	mov edx,[s]
	zlib_debug 'longest_match'
 
	; The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
	; It is easy to get rid of this optimization if necessary.
 
if MAX_MATCH <> 258
	cmp dword[edx+deflate_state.hash_bits],8
	jge @f
		zlib_assert 'Code too clever' ;Assert(..>=.. && ..==..)
	@@:
end if
	mov eax,[edx+deflate_state.window_size]
	sub eax,MIN_LOOKAHEAD
	cmp [edx+deflate_state.strstart],eax
	jle @f
		zlib_assert 'need lookahead' ;Assert(..<=..)
	@@:
	mov eax,[edx+deflate_state.strstart]
	cmp [cur_match],eax
	jl @f
		zlib_assert 'no future' ;Assert(..<..)
	@@:
 
	mov esi,[edx+deflate_state.window]
	mov edi,esi
	add esi,[cur_match]
	add edi,[edx+deflate_state.strstart]
	;edi = scan
	;esi = match
 
	; Return failure if the match length is less than 2:
 
	lodsw
	cmp ax,word[edi]
	je @f ;if (word[edi] != word[esi]) return 
		mov eax,MIN_MATCH-1
		jmp .end_f
	@@:
 
	; 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
	; the hash keys are equal and that HASH_BITS >= 8.
 
	add edi,2
	mov al,byte[edi]
	cmp al,byte[esi]
	je @f
		zlib_assert 'match[2]?' ;Assert(..==..)
	@@:
 
	; We check for insufficient lookahead only every 8th comparison;
	; the 256th check will be made at strstart+258.
 
	mov ebx,edi
	mov ecx,MAX_MATCH
align 4
	@@:
		lodsb
		scasb
		loope @b
 
	mov eax,[edx+deflate_state.window_size]
	dec eax
	add eax,[edx+deflate_state.window]
	cmp edi,eax
	jle @f
		zlib_assert 'wild scan' ;Assert(..<=..)
	@@:
	sub edi,ebx
	;edi = len
 
	cmp edi,MIN_MATCH
	jge @f ;if (..<..) 
		mov eax,MIN_MATCH-1
		jmp .end_f
	@@:
	mov eax,[cur_match]
	mov [edx+deflate_state.match_start],eax
	mov eax,[edx+deflate_state.lookahead]
	cmp edi,eax
	jg @f ;if (len <= s.lookahead) ? len : s.lookahead
		mov eax,edi
	@@:
end if ;FASTEST
.end_f:
;zlib_debug '  longest_match.ret = %d',eax
	ret
endp
 
 
; ===========================================================================
; Check that the match at match_start is indeed a match.
 
;void (s, start, match, length)
;    deflate_state *s
;    IPos start, match
;    int length
align 4
proc check_match, s:dword, start:dword, p3match:dword, length:dword
if DEBUG eq 1
	; check that the match is indeed a match
;    if (zmemcmp(s->window + match,
;                s->window + start, length) != EQUAL) {
;        fprintf(stderr, " start %u, match %u, length %d\n",
;                start, match, length);
;        do {
;            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
;        } while (--length != 0);
;        z_error("invalid match");
;    }
;    if (z_verbose > 1) {
;        fprintf(stderr,"\\[%d,%d]", start-match, length);
;        do { putc(s->window[start++], stderr); } while (--length != 0);
;    }
end if ;DEBUG
	ret
endp
 
 
; ===========================================================================
; Fill the window when the lookahead becomes insufficient.
; Updates strstart and lookahead.
 
; IN assertion: lookahead < MIN_LOOKAHEAD
; OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
;    At least one byte has been read, or avail_in == 0; reads are
;    performed for at least two bytes (required for the zip translate_eol
;    option -- not supported here).
 
;void (s)
;    deflate_state *s
align 4
proc fill_window, s:dword
pushad
;esi = p, str, curr
;ebx = more ;Amount of free space at the end of the window.
	;Объем свободного пространства в конце окна.
;ecx = wsize ;uInt
;edx = s.strm
	zlib_debug 'fill_window'
	mov edi,[s]
	cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
	jl @f
		zlib_assert 'already enough lookahead' ;Assert(..<..)
	@@:
 
	mov ecx,[edi+deflate_state.w_size]
	mov edx,[edi+deflate_state.strm]
	.cycle0: ;do
	zlib_debug 'do'
		mov ebx,[edi+deflate_state.window_size]
		sub ebx,[edi+deflate_state.lookahead]
		sub ebx,[edi+deflate_state.strstart]
 
		; 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.
 
		MAX_DIST edi
		add eax,ecx
		cmp [edi+deflate_state.strstart],eax
		jl .end0 ;if (..>=..)
			push ecx
			mov eax,[edi+deflate_state.window]
			add eax,ecx
			stdcall zmemcpy, [edi+deflate_state.window], eax
			sub [edi+deflate_state.match_start],ecx
			sub [edi+deflate_state.strstart],ecx ;we now have strstart >= MAX_DIST
			sub [edi+deflate_state.block_start],ecx
 
			; Slide the hash table (could be avoided with 32 bit values
			; at the expense of memory usage). We slide even when level == 0
			; to keep the hash table consistent if we switch back to level > 0
			; later. (Using level 0 permanently is not an optimal usage of
			; zlib, so we don't care about this pathological case.)
 
			push ebx ecx
			;ebx = wsize
			;ecx = n
			mov ebx,ecx
			mov ecx,[edi+deflate_state.hash_size]
			mov esi,ecx
			shl esi,2
			add esi,[edi+deflate_state.head]
			.cycle1: ;do
				sub esi,4
				mov eax,[esi]
				mov dword[esi],NIL
				cmp eax,ebx
				jl @f
					sub eax,ebx
					mov dword[esi],eax
				@@:
			loop .cycle1 ;while (..)
 
if FASTEST eq 0
			mov ecx,ebx
			mov esi,ecx
			shl esi,2
			add esi,[edi+deflate_state.prev]
			.cycle2: ;do
				sub esi,4
				mov eax,[esi]
				mov dword[esi],NIL
				cmp eax,ebx
				jl @f
					sub eax,ebx
					mov dword[esi],eax
				@@:
				; If n is not on any hash chain, prev[n] is garbage but
				; its value will never be used.
 
			loop .cycle2 ;while (..)
end if
			pop ecx ebx
			add ebx,ecx
		.end0:
		cmp dword[edx+z_stream.avail_in],0
		je .cycle0end ;if (..==0) break
 
		; If there was no sliding:
		;    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
		;    more == window_size - lookahead - strstart
		; => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
		; => more >= window_size - 2*WSIZE + 2
		; In the BIG_MEM or MMAP case (not yet supported),
		;   window_size == input_size + MIN_LOOKAHEAD  &&
		;   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
		; Otherwise, window_size == 2*WSIZE so more >= 2.
		; If there was sliding, more >= WSIZE. So in all cases, more >= 2.
 
		cmp ebx,2
		jge @f
			zlib_assert 'more < 2' ;Assert(..>=..)
		@@:
		mov eax,[edi+deflate_state.window]
		add eax,[edi+deflate_state.strstart]
		add eax,[edi+deflate_state.lookahead]
		stdcall read_buf, edx, eax, ebx
		add [edi+deflate_state.lookahead],eax
 
		; Initialize the hash value now that we have some input:
		mov eax,[edi+deflate_state.lookahead]
		add eax,[edi+deflate_state.insert]
		cmp eax,MIN_MATCH
		jl .end1 ;if (..>=..)
			mov esi,[edi+deflate_state.strstart]
			sub esi,[edi+deflate_state.insert]
			;esi = str
			mov eax,[edi+deflate_state.window]
			add eax,esi
			mov [edi+deflate_state.ins_h],eax
			inc eax
			movzx eax,byte[eax]
            UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if MIN_MATCH <> 3
;            Call UPDATE_HASH() MIN_MATCH-3 more times
end if
			.cycle3: ;while (..)
			cmp dword[edi+deflate_state.insert],0
			je .end1
				mov eax,esi
				add eax,MIN_MATCH-1
				add eax,[edi+deflate_state.window]
				movzx eax,byte[eax]
				UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if FASTEST eq 0
				mov eax,[edi+deflate_state.ins_h]
				shl eax,2
				add eax,[edi+deflate_state.head]
				push ebx
				mov ebx,[edi+deflate_state.w_mask]
				and ebx,esi
				shl ebx,2
				add ebx,[edi+deflate_state.prev]
				mov eax,[eax]
				mov [ebx],eax
				pop ebx
end if
				mov eax,[edi+deflate_state.ins_h]
				shl eax,2
				add eax,[edi+deflate_state.head]
				mov [eax],esi
				inc esi
				dec dword[edi+deflate_state.insert]
				mov eax,[edi+deflate_state.lookahead]
				add eax,[edi+deflate_state.insert]
				cmp eax,MIN_MATCH
				jl .end1 ;if (..<..) break
			jmp .cycle3
		.end1:
		; If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
		; but this is not important since only literal bytes will be emitted.
 
		cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
		jge .cycle0end
		cmp dword[edx+z_stream.avail_in],0
		jne .cycle0
align 4
	.cycle0end: ;while (..<.. && ..!=..)
 
	; If the WIN_INIT bytes after the end of the current data have never been
	; written, then zero those bytes in order to avoid memory check reports of
	; the use of uninitialized (or uninitialised as Julian writes) bytes by
	; the longest match routines.  Update the high water mark for the next
	; time through here.  WIN_INIT is set to MAX_MATCH since the longest match
	; routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
 
	mov eax,[edi+deflate_state.window_size]
	cmp [edi+deflate_state.high_water],eax
	jge .end2 ;if (..<..)
		mov esi,[edi+deflate_state.lookahead]
		add esi,[edi+deflate_state.strstart]
		;esi = curr
 
		cmp [edi+deflate_state.high_water],esi
		jge .end3 ;if (..<..)
			; Previous high water mark below current data -- zero WIN_INIT
			; bytes or up to end of window, whichever is less.
 
			mov eax,[edi+deflate_state.window_size]
			sub eax,esi
			cmp eax,WIN_INIT
			jle @f ;if (..>..)
				mov eax,WIN_INIT
			@@:
			mov edx,[edi+deflate_state.window]
			add edx,esi
			stdcall zmemzero, edx, eax
			add eax,esi
			mov [edi+deflate_state.high_water],eax
			jmp .end2
		.end3: ;else if (..<..)
		mov eax,esi
		add eax,WIN_INIT
		cmp [edi+deflate_state.high_water],eax
		jge .end2
			; High water mark at or above current data, but below current data
			; plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
			; to end of window, whichever is less.
 
			;eax = esi+WIN_INIT
			sub eax,[edi+deflate_state.high_water]
			mov edx,[edi+deflate_state.window_size]
			sub edx,[edi+deflate_state.high_water]
			cmp eax,edx ;if (..>..)
			jle @f
				mov eax,edx
			@@:
			mov edx,[edi+deflate_state.window]
			add edx,[edi+deflate_state.high_water]
			stdcall zmemzero, edx, eax
			add [edi+deflate_state.high_water],eax
	.end2:
 
	mov eax,[edi+deflate_state.window_size]
	sub eax,MIN_LOOKAHEAD
	cmp [edi+deflate_state.strstart],eax
	jle @f
		zlib_assert 'not enough room for search' ;Assert(..<=..)
	@@:
popad
	ret
endp
 
; ===========================================================================
; Flush the current block, with given end-of-file flag.
; IN assertion: strstart is set to the end of the current match.
 
macro FLUSH_BLOCK_ONLY s, last
{
local .end0
	push dword last
	mov eax,[s+deflate_state.strstart]
	sub eax,[s+deflate_state.block_start]
	push eax
	xor eax,eax
	cmp dword[s+deflate_state.block_start],0
	jl .end0
		mov eax,[s+deflate_state.block_start]
		add eax,[s+deflate_state.window]
	.end0:
	stdcall _tr_flush_block, s, eax
	mov eax,[s+deflate_state.strstart]
	mov [s+deflate_state.block_start],eax
	stdcall flush_pending, [s+deflate_state.strm]
;   Tracev((stderr,"[FLUSH]"));
}
 
; Same but force premature exit if necessary.
macro FLUSH_BLOCK s, last
{
local .end0
	FLUSH_BLOCK_ONLY s, last
	mov eax,[s+deflate_state.strm]
	cmp dword[eax+z_stream.avail_out],0
	jne .end0 ;if (..==0)
if last eq 1
		mov eax,finish_started
else
		mov eax,need_more
end if
		jmp .end_f
	.end0:
}
 
; ===========================================================================
; Copy without compression as much as possible from the input stream, return
; the current block state.
; This function does not insert new strings in the dictionary since
; uncompressible data is probably not useful. This function is used
; only for the level=0 compression option.
; NOTE: this function should be optimized to avoid extra copying from
; window to pending_buf.
 
;block_state (s, flush)
;    deflate_state *s
;    int flush
align 4
proc deflate_stored uses ebx ecx edi, s:dword, flush:dword
; Stored blocks are limited to 0xffff bytes, pending_buf is limited
; to pending_buf_size, and each stored block has a 5 byte header:
	mov edi,[s]
	zlib_debug 'deflate_stored'
 
	mov ecx,0xffff
	mov eax,[edi+deflate_state.pending_buf_size]
	sub eax,5
	cmp ecx,eax
	jle .cycle0 ;if (..>..)
		mov ecx,eax
	;ecx = max_block_size
 
	; Copy as much as possible from input to output:
align 4
	.cycle0: ;for (;;) {
		; Fill the window as much as possible:
		cmp dword[edi+deflate_state.lookahead],1
		jg .end0 ;if (..<=..)
;            Assert(s->strstart < s->w_size+MAX_DIST(s) ||
;                   s->block_start >= (long)s->w_size, "slide too late");
 
			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],0
			jne @f
			cmp dword[flush],Z_NO_FLUSH
			jne @f ;if (..==0 && ..==..)
				mov eax,need_more
				jmp .end_f
			@@:
			cmp dword[edi+deflate_state.lookahead],0
			je .cycle0end ;if (..==0) break ;flush the current block
		.end0:
		cmp dword[edi+deflate_state.block_start],0
		jge @f
			zlib_assert 'block gone' ;Assert(..>=0)
		@@:
 
		mov eax,[edi+deflate_state.lookahead]
		add [edi+deflate_state.strstart],eax
		mov dword[edi+deflate_state.lookahead],0
 
		; Emit a stored block if pending_buf will be full:
		mov ebx,[edi+deflate_state.block_start]
		add ebx,ecx
		cmp dword[edi+deflate_state.strstart],0
		je @f
		cmp [edi+deflate_state.strstart],ebx
		jl .end1
		@@: ;if (..==0 || ..>=..)
			; strstart == 0 is possible when wraparound on 16-bit machine
			mov eax,[edi+deflate_state.strstart]
			sub eax,ebx
			mov [edi+deflate_state.lookahead],eax
			mov [edi+deflate_state.strstart],ebx
			FLUSH_BLOCK edi, 0
		.end1:
		; Flush if we may have to slide, otherwise block_start may become
		; negative and the data will be gone:
 
		MAX_DIST edi
		mov ebx,[edi+deflate_state.strstart]
		sub ebx,[edi+deflate_state.block_start]
		cmp ebx,eax
		jl .cycle0 ;if (..>=..)
			FLUSH_BLOCK edi, 0
		jmp .cycle0
align 4
	.cycle0end:
	mov dword[edi+deflate_state.insert],0
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	mov eax,[edi+deflate_state.block_start]
	cmp [edi+deflate_state.strstart],eax
	jle @f ;if (..>..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp
 
; ===========================================================================
; Compress as much as possible from the input stream, return the current
; block state.
; This function does not perform lazy evaluation of matches and inserts
; new strings in the dictionary only for unmatched strings or for short
; matches. It is used only for the fast compression options.
 
;block_state (s, flush)
;    deflate_state *s
;    int flush
align 4
proc deflate_fast uses ebx ecx edi, s:dword, flush:dword
locals
	bflush dd ? ;int  ;set if current block must be flushed
endl
;ecx = hash_head ;IPos ;head of the hash chain
	mov edi,[s]
	zlib_debug 'deflate_fast'
 
	.cycle0: ;for (..)
	; Make sure that we always have enough lookahead, except
	; at the end of the input file. We need MAX_MATCH bytes
	; for the next match, plus MIN_MATCH bytes to insert the
	; string following the next match.
 
		cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
		jge .end0 ;if (..<..)
			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
			jge @f ;if (..<.. && ..==..)
			cmp dword[flush],Z_NO_FLUSH
			jne @f
				mov eax,need_more
				jmp .end_f
align 4
			@@:
			cmp dword[edi+deflate_state.lookahead],0
			je .cycle0end ;if (..==0) break ;flush the current block
align 4
		.end0:
 
		; Insert the string window[strstart .. strstart+2] in the
		; dictionary, and set hash_head to the head of the hash chain:
 
		mov ecx,NIL
		cmp dword[edi+deflate_state.lookahead],MIN_MATCH
		jl @f ;if (..>=..)
			INSERT_STRING edi, [edi+deflate_state.strstart], ecx
		@@:
 
		; Find the longest match, discarding those <= prev_length.
		; At this point we have always match_length < MIN_MATCH
 
		cmp ecx,NIL
		je @f
		MAX_DIST edi
		mov ebx,[edi+deflate_state.strstart]
		sub ebx,ecx
		cmp ebx,eax
		jg @f ;if (..!=0 && ..<=..)
			; To simplify the code, we prevent matches with the string
			; of window index 0 (in particular we have to avoid a match
			; of the string with itself at the start of the input file).
 
			stdcall longest_match, edi, ecx
			mov [edi+deflate_state.match_length],eax
			; longest_match() sets match_start
		@@:
		cmp dword[edi+deflate_state.match_length],MIN_MATCH
		jl .end1 ;if (..>=..)
			stdcall check_match, edi, [edi+deflate_state.strstart], [edi+deflate_state.match_start], [edi+deflate_state.match_length]
 
			mov eax,[edi+deflate_state.strstart]
			sub eax,[edi+deflate_state.match_start]
			mov ebx,[edi+deflate_state.match_length]
			sub ebx,MIN_MATCH
			_tr_tally_dist edi, eax, ebx, [bflush]
 
			mov eax,[edi+deflate_state.match_length]
			sub [edi+deflate_state.lookahead],eax
 
			; Insert new strings in the hash table only if the match length
			; is not too large. This saves time but degrades compression.
 
if FASTEST eq 0
			;;mov eax,[edi+deflate_state.match_length]
			cmp eax,[edi+deflate_state.max_insert_length]
			jg .end3
			cmp dword[edi+deflate_state.lookahead],MIN_MATCH
			jl .end3 ;if (..<=.. && ..>=..)
				dec dword[edi+deflate_state.match_length] ;string at strstart already in table
				.cycle1: ;do {
					inc dword[edi+deflate_state.strstart]
					INSERT_STRING edi, [edi+deflate_state.strstart], ecx
					; strstart never exceeds WSIZE-MAX_MATCH, so there are
					; always MIN_MATCH bytes ahead.
 
					dec dword[edi+deflate_state.match_length]
					cmp dword[edi+deflate_state.match_length],0
					jne .cycle1 ;while (..!=0)
				inc dword[edi+deflate_state.strstart]
				jmp .end2
			.end3: ;else
end if
 
				mov eax,[edi+deflate_state.match_length]
				add [edi+deflate_state.strstart],eax
				mov dword[edi+deflate_state.match_length],0
				mov eax,[edi+deflate_state.window]
				add eax,[edi+deflate_state.strstart]
				mov [edi+deflate_state.ins_h],eax
				inc eax
				movzx eax,byte[eax]
				UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if MIN_MATCH <> 3
;                Call UPDATE_HASH() MIN_MATCH-3 more times
end if
				; If lookahead < MIN_MATCH, ins_h is garbage, but it does not
				; matter since it will be recomputed at next deflate call.
			jmp .end2
		.end1: ;else
			; No match, output a literal byte
			mov eax,[edi+deflate_state.window]
			add eax,[edi+deflate_state.strstart]
			movzx eax,byte[eax]
			Tracevv eax,
			_tr_tally_lit edi, eax, [bflush]
			dec dword[edi+deflate_state.lookahead]
			inc dword[edi+deflate_state.strstart]
		.end2:
		cmp dword[bflush],0
		je .cycle0 ;if (..)
			FLUSH_BLOCK edi, 0
		jmp .cycle0
align 4
	.cycle0end:
	mov eax,[edi+deflate_state.strstart]
	cmp eax,MIN_MATCH-1
	jl @f
		mov eax,MIN_MATCH-1
	@@:
	mov [edi+deflate_state.insert],eax
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp
 
; ===========================================================================
; Same as above, but achieves better compression. We use a lazy
; evaluation for matches: a match is finally adopted only if there is
; no better match at the next window position.
 
;block_state (s, flush)
;    deflate_state *s
;    int flush
align 4
proc deflate_slow uses ebx ecx edx edi, s:dword, flush:dword
locals
	bflush dd ? ;int  ;set if current block must be flushed
endl
;ecx = hash_head ;IPos ;head of the hash chain
	mov edi,[s]
	zlib_debug 'deflate_slow'
 
	; Process the input block.
	.cycle0: ;for (;;)
	; Make sure that we always have enough lookahead, except
	; at the end of the input file. We need MAX_MATCH bytes
	; for the next match, plus MIN_MATCH bytes to insert the
	; string following the next match.
 
		cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
		jge .end0 ;if (..<..)
			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
			jge @f ;if (..<.. && ..==..)
			cmp dword[flush],Z_NO_FLUSH
			jne @f
				mov eax,need_more
				jmp .end_f
align 4
			@@:
			cmp dword[edi+deflate_state.lookahead],0
			je .cycle0end ;if (..==0) break ;flush the current block
align 4
		.end0:
 
		; Insert the string window[strstart .. strstart+2] in the
		; dictionary, and set hash_head to the head of the hash chain:
 
		mov ecx,NIL
		cmp dword[edi+deflate_state.lookahead],MIN_MATCH
		jl @f ;if (..>=..)
			INSERT_STRING edi, [edi+deflate_state.strstart], ecx
		@@:
 
		; Find the longest match, discarding those <= prev_length.
 
		mov eax,[edi+deflate_state.match_length]
		mov [edi+deflate_state.prev_length],eax
		mov eax,[edi+deflate_state.match_start]
		mov [edi+deflate_state.prev_match],eax
		mov dword[edi+deflate_state.match_length],MIN_MATCH-1
 
		cmp ecx,NIL
		je .end1
		mov eax,[edi+deflate_state.prev_length]
		cmp eax,[edi+deflate_state.max_lazy_match]
		jge .end1
		MAX_DIST edi
		mov ebx,[edi+deflate_state.strstart]
		sub ebx,ecx
		cmp ebx,eax
		jg .end1 ;if (..!=0 && ..<.. && ..<=..)
			; To simplify the code, we prevent matches with the string
			; of window index 0 (in particular we have to avoid a match
			; of the string with itself at the start of the input file).
 
			stdcall longest_match, edi, ecx
			mov [edi+deflate_state.match_length],eax
			; longest_match() sets match_start
 
			cmp dword[edi+deflate_state.match_length],5
			jg .end1
			cmp word[edi+deflate_state.strategy],Z_FILTERED
if TOO_FAR <= 32767
			je @f
				cmp dword[edi+deflate_state.match_length],MIN_MATCH
				jne .end1
				mov eax,[edi+deflate_state.strstart]
				sub eax,[edi+deflate_state.match_start]
				cmp eax,TOO_FAR
				jle .end1 ;if (..<=.. && (..==.. || (..==.. && ..>..)))
			@@:
else
			jne .end1 ;if (..<=.. && ..==..)
end if
				; If prev_match is also MIN_MATCH, match_start is garbage
				; but we will ignore the current match anyway.
 
				mov dword[edi+deflate_state.match_length],MIN_MATCH-1
		.end1:
		; If there was a match at the previous step and the current
		; match is not better, output the previous match:
 
 
		mov eax,[edi+deflate_state.prev_length]
		cmp eax,MIN_MATCH
		jl .end2
		cmp [edi+deflate_state.match_length],eax
		jg .end2 ;if (..>=.. && ..<=..)
			mov edx,[edi+deflate_state.strstart]
			add edx,[edi+deflate_state.lookahead]
			sub edx,MIN_MATCH
			;edx = max_insert
			; Do not insert strings in hash table beyond this.
 
			mov eax,[edi+deflate_state.strstart]
			dec eax
			stdcall check_match, edi, eax, [edi+deflate_state.prev_match], [edi+deflate_state.prev_length]
 
			mov eax,[edi+deflate_state.strstart]
			dec eax
			sub eax,[edi+deflate_state.prev_match]
			mov ebx,[edi+deflate_state.prev_length]
			sub ebx,MIN_MATCH
			_tr_tally_dist edi, eax, ebx, [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
			; enough lookahead, the last two strings are not inserted in
			; the hash table.
 
			mov eax,[edi+deflate_state.prev_length]
			dec eax
			sub [edi+deflate_state.lookahead],eax
			sub dword[edi+deflate_state.prev_length],2
			.cycle1: ;do
				inc dword[edi+deflate_state.strstart]
				cmp [edi+deflate_state.strstart],edx
				jg @f ;if (..<=..)
					INSERT_STRING edi, [edi+deflate_state.strstart], ecx
				@@:
				dec dword[edi+deflate_state.prev_length]
				cmp dword[edi+deflate_state.prev_length],0
				jne .cycle1 ;while (..!=0)
			mov dword[edi+deflate_state.match_available],0
			mov dword[edi+deflate_state.match_length],MIN_MATCH-1
			inc dword[edi+deflate_state.strstart]
 
			cmp dword[bflush],0
			je .cycle0 ;if (..)
				FLUSH_BLOCK edi, 0
			jmp .cycle0
		.end2: ;else if (..)
		cmp dword[edi+deflate_state.match_available],0
		je .end3
			; If there was no match at the previous position, output a
			; single literal. If there was a match but the current match
			; is longer, truncate the previous match to a single literal.
 
			mov eax,[edi+deflate_state.strstart]
			dec eax
			add eax,[edi+deflate_state.window]
			movzx eax,byte[eax]
			Tracevv eax,
			_tr_tally_lit edi, eax, [bflush]
			cmp dword[bflush],0
			je @f ;if (..)
				FLUSH_BLOCK_ONLY edi, 0
			@@:
			inc dword[edi+deflate_state.strstart]
			dec dword[edi+deflate_state.lookahead]
			mov eax,[edi+deflate_state.strm]
			cmp dword[eax+z_stream.avail_out],0
			jne .cycle0 ;if (..==0) return ..
				mov eax,need_more
				jmp .end_f
			jmp .cycle0 ;.end4
		.end3: ;else
			; There is no previous match to compare with, wait for
			; the next step to decide.
 
			mov dword[edi+deflate_state.match_available],1
			inc dword[edi+deflate_state.strstart]
			dec dword[edi+deflate_state.lookahead]
		;.end4:
		jmp .cycle0
align 4
	.cycle0end:
	cmp dword[flush],Z_NO_FLUSH
	jne @f
		zlib_assert 'no flush?' ;Assert (..!=..)
	@@:
	cmp dword[edi+deflate_state.match_available],0
	je @f ;if (..)
		mov eax,[edi+deflate_state.strstart]
		dec eax
		add eax,[edi+deflate_state.window]
		movzx eax,byte[eax]
		Tracevv eax,
		_tr_tally_lit edi, eax, [bflush]
		mov dword[edi+deflate_state.match_available],0
	@@:
	mov eax,[edi+deflate_state.strstart]
	cmp eax,MIN_MATCH-1
	jl @f
		mov eax,MIN_MATCH-1
	@@:
	mov [edi+deflate_state.insert],eax
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp
 
; ===========================================================================
; For Z_RLE, simply look for runs of bytes, generate matches only of distance
; one.  Do not maintain a hash table.  (It will be regenerated if this run of
; deflate switches away from Z_RLE.)
 
;block_state (s, flush)
;    deflate_state *s
;    int flush
align 4
proc deflate_rle uses ecx edx edi esi, s:dword, flush:dword
locals
	bflush dd ? ;int ;set if current block must be flushed
endl
	mov edx,[s]
	zlib_debug 'deflate_rle'
align 4
	.cycle0: ;for (;;)
		; Make sure that we always have enough lookahead, except
		; at the end of the input file. We need MAX_MATCH bytes
		; for the longest run, plus one for the unrolled loop.
		cmp dword[edx+deflate_state.lookahead],MAX_MATCH
		jg .end0 ;if (..<=..)
			stdcall fill_window, edx
			cmp dword[edx+deflate_state.lookahead],MAX_MATCH
			jg @f
			cmp dword[flush],Z_NO_FLUSH
			jne @f ;if (..<=.. && ..==..)
				mov eax,need_more
				jmp .end_f
align 4
			@@:
			cmp dword[edx+deflate_state.lookahead],0
			je .cycle0end ;flush the current block
align 4
		.end0:
 
		; See how many times the previous byte repeats
		mov dword[edx+deflate_state.match_length],0
		cmp dword[edx+deflate_state.lookahead],MIN_MATCH
		jl .end1
		cmp dword[edx+deflate_state.strstart],0
		jle .end1 ;if (..>=.. && ..>..)
			mov esi,[edx+deflate_state.window]
			add esi,[edx+deflate_state.strstart]
			dec esi
			lodsb ;prev = *scan; ++scan
			mov edi,esi
			scasb
			jnz .end2
			scasb
			jnz .end2
			scasb
			jnz .end2 ;if (..==.. && ..==.. && ..==..)
				;edi = scan ;scan goes up to strend for length of run
				; al = prev ;byte at distance one to match
				;ecx = strend-scan
				mov ecx,MAX_MATCH-2
				repz scasb
				dec edi
				sub edi,[edx+deflate_state.window]
				sub edi,[edx+deflate_state.strstart]
				mov [edx+deflate_state.match_length],edi
				mov eax,[edx+deflate_state.lookahead]
				cmp [edx+deflate_state.match_length],eax
				jle .end2
					mov [edx+deflate_state.match_length],eax
			.end2:
			mov eax,[edx+deflate_state.window_size]
			dec eax
			add eax,[edx+deflate_state.window]
			cmp edi,eax
			jle .end1
				zlib_assert 'wild scan' ;Assert(..<=..)
		.end1:
 
		; Emit match if have run of MIN_MATCH or longer, else emit literal
		cmp dword[edx+deflate_state.match_length],MIN_MATCH
		jl @f ;if (..>=..)
			push dword[edx+deflate_state.match_length]
			mov eax,[edx+deflate_state.strstart]
			dec eax
			stdcall check_match, edx, [edx+deflate_state.strstart], eax
 
			mov eax,[edx+deflate_state.match_length]
			sub eax,MIN_MATCH
			_tr_tally_dist edx, 1, eax, [bflush]
 
			mov eax,[edx+deflate_state.match_length]
			sub [edx+deflate_state.lookahead],eax
			add [edx+deflate_state.strstart],eax
			mov dword[edx+deflate_state.match_length],0
			jmp .end3
		@@: ;else
			; No match, output a literal byte
			mov eax,[edx+deflate_state.strstart]
			add eax,[edx+deflate_state.window]
			movzx eax,byte[eax]
			Tracevv eax,
			_tr_tally_lit edx, eax, [bflush]
			dec dword[edx+deflate_state.lookahead]
			inc dword[edx+deflate_state.strstart]
		.end3:
		cmp dword[bflush],0
		je .cycle0 ;if (..)
			FLUSH_BLOCK edx, 0
		jmp .cycle0
align 4
	.cycle0end:
	mov dword[edx+deflate_state.insert],0
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edx, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edx+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edx, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp
 
; ===========================================================================
; For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
; (It will be regenerated if this run of deflate switches away from Huffman.)
 
;block_state (s, flush)
;    deflate_state *s
;    int flush
align 4
proc deflate_huff uses ebx edi, s:dword, flush:dword
locals
	bflush dd ? ;int ;set if current block must be flushed
endl
	mov edi,[s]
	zlib_debug 'deflate_huff'
align 4
	.cycle0: ;for (;;)
		; Make sure that we have a literal to write.
		cmp dword[edi+deflate_state.lookahead],0
		jne .end0 ;if (..==0)
			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],0
			jne .end0 ;if (..==0)
				cmp dword[flush],Z_NO_FLUSH
				jne .cycle0end ;if (..==..)
					mov eax,need_more
					jmp .end_f
				;flush the current block
align 4
		.end0:
 
		; Output a literal byte
		mov dword[edi+deflate_state.match_length],0
		mov eax,[edi+deflate_state.strstart]
		add eax,[edi+deflate_state.window]
		movzx eax,byte[eax]
		Tracevv eax,
		_tr_tally_lit edi, eax, [bflush]
		dec dword[edi+deflate_state.lookahead]
		inc dword[edi+deflate_state.strstart]
		cmp dword[bflush],0
		je @f ;if (..)
			FLUSH_BLOCK edi, 0
		@@:
		jmp .cycle0
align 4
	.cycle0end:
	mov dword[edi+deflate_state.insert],0
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp
>
>
>
>
>
>
>
>
;>
>
>
>
>
>
>
>
>
>
>
>
 
align>
>
>
>
>
>
>
>

Rev 6799	Rev 6801
1	; deflate.asm -- compress data using the deflation algorithm	1	; deflate.asm -- compress data using the deflation algorithm
2	; Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler	2	; Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
3	; For conditions of distribution and use, see copyright notice in zlib.inc	3	; For conditions of distribution and use, see copyright notice in zlib.inc
4		4
5	; ALGORITHM	5	; ALGORITHM
6		6
7	; The "deflation" process depends on being able to identify portions	7	; The "deflation" process depends on being able to identify portions
8	; of the input text which are identical to earlier input (within a	8	; of the input text which are identical to earlier input (within a
9	; sliding window trailing behind the input currently being processed).	9	; sliding window trailing behind the input currently being processed).
10		10
11	; The most straightforward technique turns out to be the fastest for	11	; The most straightforward technique turns out to be the fastest for
12	; most input files: try all possible matches and select the longest.	12	; most input files: try all possible matches and select the longest.
13	; The key feature of this algorithm is that insertions into the string	13	; The key feature of this algorithm is that insertions into the string
14	; dictionary are very simple and thus fast, and deletions are avoided	14	; dictionary are very simple and thus fast, and deletions are avoided
15	; completely. Insertions are performed at each input character, whereas	15	; completely. Insertions are performed at each input character, whereas
16	; string matches are performed only when the previous match ends. So it	16	; string matches are performed only when the previous match ends. So it
17	; is preferable to spend more time in matches to allow very fast string	17	; is preferable to spend more time in matches to allow very fast string
18	; insertions and avoid deletions. The matching algorithm for small	18	; insertions and avoid deletions. The matching algorithm for small
19	; strings is inspired from that of Rabin & Karp. A brute force approach	19	; strings is inspired from that of Rabin & Karp. A brute force approach
20	; is used to find longer strings when a small match has been found.	20	; is used to find longer strings when a small match has been found.
21	; A similar algorithm is used in comic (by Jan-Mark Wams) and freeze	21	; A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
22	; (by Leonid Broukhis).	22	; (by Leonid Broukhis).
23	; A previous version of this file used a more sophisticated algorithm	23	; A previous version of this file used a more sophisticated algorithm
24	; (by Fiala and Greene) which is guaranteed to run in linear amortized	24	; (by Fiala and Greene) which is guaranteed to run in linear amortized
25	; time, but has a larger average cost, uses more memory and is patented.	25	; time, but has a larger average cost, uses more memory and is patented.
26	; However the F&G algorithm may be faster for some highly redundant	26	; However the F&G algorithm may be faster for some highly redundant
27	; files if the parameter max_chain_length (described below) is too large.	27	; files if the parameter max_chain_length (described below) is too large.
28		28
29	; ACKNOWLEDGEMENTS	29	; ACKNOWLEDGEMENTS
30		30
31	; The idea of lazy evaluation of matches is due to Jan-Mark Wams, and	31	; The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
32	; I found it in 'freeze' written by Leonid Broukhis.	32	; I found it in 'freeze' written by Leonid Broukhis.
33	; Thanks to many people for bug reports and testing.	33	; Thanks to many people for bug reports and testing.
34		34
35	; REFERENCES	35	; REFERENCES
36		36
37	; Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".	37	; Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
38	; Available in http://tools.ietf.org/html/rfc1951	38	; Available in http://tools.ietf.org/html/rfc1951
39		39
40	; A description of the Rabin and Karp algorithm is given in the book	40	; A description of the Rabin and Karp algorithm is given in the book
41	; "Algorithms" by R. Sedgewick, Addison-Wesley, p252.	41	; "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
42		42
43	; Fiala,E.R., and Greene,D.H.	43	; Fiala,E.R., and Greene,D.H.
44	; Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595	44	; Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
45		45
46		46
47	deflate_copyright db ' deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ',0	47	deflate_copyright db ' deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ',0
48		48
49	; If you use the zlib library in a product, an acknowledgment is welcome	49	; If you use the zlib library in a product, an acknowledgment is welcome
50	; in the documentation of your product. If for some reason you cannot	50	; in the documentation of your product. If for some reason you cannot
51	; include such an acknowledgment, I would appreciate that you keep this	51	; include such an acknowledgment, I would appreciate that you keep this
52	; copyright string in the executable of your product.	52	; copyright string in the executable of your product.
53		53
54	; ===========================================================================	54	; ===========================================================================
55	; Function prototypes.	55	; Function prototypes.
56		56
57	;enum block_state	57	;enum block_state
58	need_more equ 1 ;block not completed, need more input or more output	58	need_more equ 1 ;block not completed, need more input or more output
59	block_done equ 2 ;block flush performed	59	block_done equ 2 ;block flush performed
60	finish_started equ 3 ;finish started, need only more output at next deflate	60	finish_started equ 3 ;finish started, need only more output at next deflate
61	finish_done equ 4 ;finish done, accept no more input or output	61	finish_done equ 4 ;finish done, accept no more input or output
62		62
63	; ===========================================================================	63	; ===========================================================================
64	; Local data	64	; Local data
65		65
66	NIL equ 0	66	NIL equ 0
67	; Tail of hash chains	67	; Tail of hash chains
68		68
69	TOO_FAR equ 4096	69	TOO_FAR equ 4096
70	; Matches of length 3 are discarded if their distance exceeds TOO_FAR	70	; Matches of length 3 are discarded if their distance exceeds TOO_FAR
71		71
72	; Values for max_lazy_match, good_match and max_chain_length, depending on	72	; Values for max_lazy_match, good_match and max_chain_length, depending on
73	; the desired pack level (0..9). The values given below have been tuned to	73	; the desired pack level (0..9). The values given below have been tuned to
74	; exclude worst case performance for pathological files. Better values may be	74	; exclude worst case performance for pathological files. Better values may be
75	; found for specific files.	75	; found for specific files.
76		76
77	struct config_s ;config	77	struct config_s ;config
78	good_length dw ? ;uint_16 ;reduce lazy search above this match length	78	good_length dw ? ;uint_16 ;reduce lazy search above this match length
79	max_lazy dw ? ;uint_16 ;do not perform lazy search above this match length	79	max_lazy dw ? ;uint_16 ;do not perform lazy search above this match length
80	nice_length dw ? ;uint_16 ;quit search above this match length	80	nice_length dw ? ;uint_16 ;quit search above this match length
81	max_chain dw ? ;uint_16	81	max_chain dw ? ;uint_16
82	co_func dd ? ;compress_func	82	co_func dd ? ;compress_func
83	ends	83	ends
84		84
85	align 16	85	align 16
86	configuration_table:	86	configuration_table:
87	config_s 0, 0, 0, 0, deflate_stored ;store only	87	config_s 0, 0, 0, 0, deflate_stored ;store only
88	config_s 4, 4, 8, 4, deflate_fast ;max speed, no lazy matches	88	config_s 4, 4, 8, 4, deflate_fast ;max speed, no lazy matches
89	if FASTEST eq 0	89	if FASTEST eq 0
90	config_s 4, 5, 16, 8, deflate_fast	90	config_s 4, 5, 16, 8, deflate_fast
91	config_s 4, 6, 32, 32, deflate_fast	91	config_s 4, 6, 32, 32, deflate_fast
92	config_s 4, 4, 16, 16, deflate_slow ;lazy matches	92	config_s 4, 4, 16, 16, deflate_slow ;lazy matches
93	config_s 8, 16, 32, 32, deflate_slow	93	config_s 8, 16, 32, 32, deflate_slow
94	config_s 8, 16, 128, 128, deflate_slow	94	config_s 8, 16, 128, 128, deflate_slow
95	config_s 8, 32, 128, 256, deflate_slow	95	config_s 8, 32, 128, 256, deflate_slow
96	config_s 32, 128, 258, 1024, deflate_slow	96	config_s 32, 128, 258, 1024, deflate_slow
97	config_s 32, 258, 258, 4096, deflate_slow ;max compression	97	config_s 32, 258, 258, 4096, deflate_slow ;max compression
98	end if	98	end if
99		99
100	; Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4	100	; Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
101	; For deflate_fast() (levels <= 3) good is ignored and lazy has a different	101	; For deflate_fast() (levels <= 3) good is ignored and lazy has a different
102	; meaning.	102	; meaning.
103		103
104		104
105	EQUAL equ 0	105	EQUAL equ 0
106	; result of memcmp for equal strings	106	; result of memcmp for equal strings
107		107
108	; rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH	108	; rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH
109	macro RANK f, reg	109	macro RANK f, reg
110	{	110	{
111	local .end0	111	local .end0
112	xor reg,reg	112	xor reg,reg
113	cmp f,4	113	cmp f,4
114	jle .end0	114	jle .end0
115	sub reg,9	115	sub reg,9
116	.end0:	116	.end0:
117	add reg,f	117	add reg,f
118	add reg,f	118	add reg,f
119	}	119	}
120		120
121	; ===========================================================================	121	; ===========================================================================
122	; Update a hash value with the given input byte	122	; Update a hash value with the given input byte
123	; IN assertion: all calls to to UPDATE_HASH are made with consecutive	123	; IN assertion: all calls to to UPDATE_HASH are made with consecutive
124	; input characters, so that a running hash key can be computed from the	124	; input characters, so that a running hash key can be computed from the
125	; previous key instead of complete recalculation each time.	125	; previous key instead of complete recalculation each time.
126		126
127	macro UPDATE_HASH s,h,c	127	macro UPDATE_HASH s,h,c
128	{	128	{
129	push ebx ecx	129	push ebx ecx
130	mov ebx,h	130	mov ebx,h
131	mov ecx,[s+deflate_state.hash_shift]	131	mov ecx,[s+deflate_state.hash_shift]
132	shl ebx,cl	132	shl ebx,cl
133	xor ebx,c	133	xor ebx,c
134	and ebx,[s+deflate_state.hash_mask]	134	and ebx,[s+deflate_state.hash_mask]
135	mov h,ebx	135	mov h,ebx
136	pop ecx ebx	136	pop ecx ebx
137	}	137	}
138		138
139	; ===========================================================================	139	; ===========================================================================
140	; Insert string str in the dictionary and set match_head to the previous head	140	; Insert string str in the dictionary and set match_head to the previous head
141	; of the hash chain (the most recent string with same hash key). Return	141	; of the hash chain (the most recent string with same hash key). Return
142	; the previous length of the hash chain.	142	; the previous length of the hash chain.
143	; If this file is compiled with -DFASTEST, the compression level is forced	143	; If this file is compiled with -DFASTEST, the compression level is forced
144	; to 1, and no hash chains are maintained.	144	; to 1, and no hash chains are maintained.
145	; IN assertion: all calls to to INSERT_STRING are made with consecutive	145	; IN assertion: all calls to to INSERT_STRING are made with consecutive
146	; input characters and the first MIN_MATCH bytes of str are valid	146	; input characters and the first MIN_MATCH bytes of str are valid
147	; (except for the last MIN_MATCH-1 bytes of the input file).	147	; (except for the last MIN_MATCH-1 bytes of the input file).
148		148
149	macro INSERT_STRING s, str, match_head	149	macro INSERT_STRING s, str, match_head
150	{	150	{
151	mov eax,[s+deflate_state.window]	151	mov eax,[s+deflate_state.window]
152	add eax,str	152	add eax,str
153	add eax,MIN_MATCH-1	153	add eax,MIN_MATCH-1
154	movzx eax,byte[eax]	154	movzx eax,byte[eax]
155	UPDATE_HASH s, [s+deflate_state.ins_h], eax	155	UPDATE_HASH s, [s+deflate_state.ins_h], eax
156	mov eax,[s+deflate_state.ins_h]	156	mov eax,[s+deflate_state.ins_h]
157	shl eax,2	157	shl eax,2
158	add eax,[s+deflate_state.head]	158	add eax,[s+deflate_state.head]
159	mov eax,[eax]	159	mov eax,[eax]
160	mov match_head,eax	160	mov match_head,eax
161	if FASTEST eq 0	161	if FASTEST eq 0
162	push ebx	162	push ebx
163	mov ebx,[s+deflate_state.w_mask]	163	mov ebx,[s+deflate_state.w_mask]
164	and ebx,str	164	and ebx,str
165	shl ebx,2	165	shl ebx,2
166	add ebx,[s+deflate_state.prev]	166	add ebx,[s+deflate_state.prev]
167	mov [ebx],eax	167	mov [ebx],eax
168	pop ebx	168	pop ebx
169	end if	169	end if
170	mov eax,[s+deflate_state.ins_h]	170	mov eax,[s+deflate_state.ins_h]
171	shl eax,2	171	shl eax,2
172	add eax,[s+deflate_state.head]	172	add eax,[s+deflate_state.head]
173	push str	173	push str
174	pop dword[eax]	174	pop dword[eax]
175	}	175	}
176		176
177	; ===========================================================================	177	; ===========================================================================
178	; Initialize the hash table (avoiding 64K overflow for 16 bit systems).	178	; Initialize the hash table (avoiding 64K overflow for 16 bit systems).
179	; prev[] will be initialized on the fly.	179	; prev[] will be initialized on the fly.
180		180
181	macro CLEAR_HASH s	181	macro CLEAR_HASH s
182	{	182	{
183	;mov eax,[s+deflate_state.hash_size]	183	;mov eax,[s+deflate_state.hash_size]
184	;dec eax	184	;dec eax
185	;shl eax,2	185	;shl eax,2
186	;add eax,[s+deflate_state.head]	186	;add eax,[s+deflate_state.head]
187	;mov dword[eax],NIL	187	;mov dword[eax],NIL
188	mov eax,[s+deflate_state.hash_size]	188	mov eax,[s+deflate_state.hash_size]
189	;dec eax	189	;dec eax
190	shl eax,2 ;sizeof(*s.head)	190	shl eax,2 ;sizeof(*s.head)
191	stdcall zmemzero, [s+deflate_state.head], eax	191	stdcall zmemzero, [s+deflate_state.head], eax
192	}	192	}
193		193
194	align 4	194	align 4
195	proc deflateInit, strm:dword, level:dword	195	proc deflateInit, strm:dword, level:dword
196	stdcall deflateInit_, [strm], [level], ZLIB_VERSION, sizeof.z_stream	196	stdcall deflateInit_, [strm], [level], ZLIB_VERSION, sizeof.z_stream
197	ret	197	ret
198	endp	198	endp
199		199
200	; =========================================================================	200	; =========================================================================
201	;int (strm, level, version, stream_size)	201	;int (strm, level, version, stream_size)
202	; z_streamp strm	202	; z_streamp strm
203	; int level	203	; int level
204	; const char *version	204	; const char *version
205	; int stream_size	205	; int stream_size
206	align 4	206	align 4
207	proc deflateInit_, strm:dword, level:dword, version:dword, stream_size:dword	207	proc deflateInit_, strm:dword, level:dword, version:dword, stream_size:dword
208	stdcall deflateInit2_, [strm], [level], Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,\	208	stdcall deflateInit2_, [strm], [level], Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,\
209	Z_DEFAULT_STRATEGY, [version], [stream_size]	209	Z_DEFAULT_STRATEGY, [version], [stream_size]
210	; To do: ignore strm->next_in if we use it as window	210	; To do: ignore strm->next_in if we use it as window
211	ret	211	ret
212	endp	212	endp
213		213
214	align 4	214	align 4
215	proc deflateInit2, strm:dword, level:dword, method:dword, windowBits:dword, memLevel:dword, strategy:dword	215	proc deflateInit2, strm:dword, level:dword, method:dword, windowBits:dword, memLevel:dword, strategy:dword
216	stdcall deflateInit2_, [strm],[level],[method],[windowBits],[memLevel],\	216	stdcall deflateInit2_, [strm],[level],[method],[windowBits],[memLevel],\
217	[strategy], ZLIB_VERSION, sizeof.z_stream	217	[strategy], ZLIB_VERSION, sizeof.z_stream
218	ret	218	ret
219	endp	219	endp
220		220
221	; =========================================================================	221	; =========================================================================
222	;int (strm, level, method, windowBits, memLevel, strategy,	222	;int (strm, level, method, windowBits, memLevel, strategy,
223	; version, stream_size)	223	; version, stream_size)
224	; z_streamp strm	224	; z_streamp strm
225	; int level	225	; int level
226	; int method	226	; int method
227	; int windowBits	227	; int windowBits
228	; int memLevel	228	; int memLevel
229	; int strategy	229	; int strategy
230	; const char *version	230	; const char *version
231	; int stream_size	231	; int stream_size
232	align 4	232	align 4
233	proc deflateInit2_ uses ebx ecx edx edi, strm:dword, level:dword, method:dword,\	233	proc deflateInit2_ uses ebx ecx edx edi, strm:dword, level:dword, method:dword,\
234	windowBits:dword, memLevel:dword, strategy:dword, version:dword, stream_size:dword	234	windowBits:dword, memLevel:dword, strategy:dword, version:dword, stream_size:dword
235	locals	235	locals
236	wrap dd 1 ;int	236	wrap dd 1 ;int
237	overlay dd ? ;uint_16p	237	overlay dd ? ;uint_16p
238	endl	238	endl
239	; We overlay pending_buf and d_buf+l_buf. This works since the average	239	; We overlay pending_buf and d_buf+l_buf. This works since the average
240	; output size for (length,distance) codes is <= 24 bits.	240	; output size for (length,distance) codes is <= 24 bits.
241		241
242	mov eax,[version]	242	mov eax,[version]
243	cmp eax,Z_NULL	243	cmp eax,Z_NULL
244	je @f	244	je @f
245	mov ebx,dword[ZLIB_VERSION]	245	mov ebx,dword[ZLIB_VERSION]
246	cmp dword[eax],ebx	246	cmp dword[eax],ebx
247	jne @f	247	jne @f
248	cmp dword[stream_size],sizeof.z_stream	248	cmp dword[stream_size],sizeof.z_stream
249	je .end0	249	je .end0
250	@@: ;if (..==0 \|\| ..[0]!=..[0] \|\| ..!=..)	250	@@: ;if (..==0 \|\| ..[0]!=..[0] \|\| ..!=..)
251	mov eax,Z_VERSION_ERROR	251	mov eax,Z_VERSION_ERROR
252	jmp .end_f	252	jmp .end_f
253	.end0:	253	.end0:
254	mov ebx,[strm]	254	mov ebx,[strm]
255	cmp ebx,Z_NULL	255	cmp ebx,Z_NULL
256	jne @f ;if (..==0) return ..	256	jne @f ;if (..==0) return ..
257	mov eax,Z_STREAM_ERROR	257	mov eax,Z_STREAM_ERROR
258	jmp .end_f	258	jmp .end_f
259	@@:	259	@@:
260		260
261	mov dword[ebx+z_stream.msg],Z_NULL	261	mov dword[ebx+z_stream.msg],Z_NULL
262	cmp dword[ebx+z_stream.zalloc],0	262	cmp dword[ebx+z_stream.zalloc],0
263	jne @f ;if (..==0)	263	jne @f ;if (..==0)
264	if Z_SOLO eq 1	264	if Z_SOLO eq 1
265	mov eax,Z_STREAM_ERROR	265	mov eax,Z_STREAM_ERROR
266	jmp .end_f	266	jmp .end_f
267	else	267	else
268	mov dword[ebx+z_stream.zalloc],zcalloc	268	mov dword[ebx+z_stream.zalloc],zcalloc
269	mov dword[ebx+z_stream.opaque],0	269	mov dword[ebx+z_stream.opaque],0
270	end if	270	end if
271	@@:	271	@@:
272	cmp dword[ebx+z_stream.zfree],0	272	cmp dword[ebx+z_stream.zfree],0
273	jne @f ;if (..==0)	273	jne @f ;if (..==0)
274	if Z_SOLO eq 1	274	if Z_SOLO eq 1
275	mov eax,Z_STREAM_ERROR	275	mov eax,Z_STREAM_ERROR
276	jmp .end_f	276	jmp .end_f
277	else	277	else
278	mov dword[ebx+z_stream.zfree],zcfree	278	mov dword[ebx+z_stream.zfree],zcfree
279	end if	279	end if
280	@@:	280	@@:
281		281
282	if FASTEST eq 1	282	if FASTEST eq 1
283	cmp dword[level],0	283	cmp dword[level],0
284	je @f ;if (..!=0)	284	je @f ;if (..!=0)
285	mov dword[level],1	285	mov dword[level],1
286	@@:	286	@@:
287	else	287	else
288	cmp dword[level],Z_DEFAULT_COMPRESSION	288	cmp dword[level],Z_DEFAULT_COMPRESSION
289	jne @f ;if (..==0)	289	jne @f ;if (..==0)
290	mov dword[level],6	290	mov dword[level],6
291	@@:	291	@@:
292	end if	292	end if
293		293
294	cmp dword[windowBits],0	294	cmp dword[windowBits],0
295	jge @f ;if (..<0) ;suppress zlib wrapper	295	jge @f ;if (..<0) ;suppress zlib wrapper
296	mov dword[wrap],0	296	mov dword[wrap],0
297	neg dword[windowBits]	297	neg dword[windowBits]
298	inc dword[windowBits]	298	inc dword[windowBits]
299	jmp .end1	299	jmp .end1
300	@@:	300	@@:
301	if GZIP eq 1	301	if GZIP eq 1
302	cmp dword[windowBits],15	302	cmp dword[windowBits],15
303	jle .end1 ;else if (..>15)	303	jle .end1 ;else if (..>15)
304	mov dword[wrap],2 ;write gzip wrapper instead	304	mov dword[wrap],2 ;write gzip wrapper instead
305	sub dword[windowBits],16	305	sub dword[windowBits],16
306	end if	306	end if
307	.end1:	307	.end1:
308	cmp dword[memLevel],1	308	cmp dword[memLevel],1
309	jl .end2	309	jl .end2
310	cmp dword[memLevel],MAX_MEM_LEVEL	310	cmp dword[memLevel],MAX_MEM_LEVEL
311	jg .end2	311	jg .end2
312	cmp dword[method],Z_DEFLATED	312	cmp dword[method],Z_DEFLATED
313	jne .end2	313	jne .end2
314	cmp dword[windowBits],8	314	cmp dword[windowBits],8
315	jl .end2	315	jl .end2
316	cmp dword[windowBits],15	316	cmp dword[windowBits],15
317	jg .end2	317	jg .end2
318	cmp dword[level],0	318	cmp dword[level],0
319	jl .end2	319	jl .end2
320	cmp dword[level],9	320	cmp dword[level],9
321	jg .end2	321	jg .end2
322	cmp dword[strategy],0	322	cmp dword[strategy],0
323	jl .end2	323	jl .end2
324	cmp dword[strategy],Z_FIXED	324	cmp dword[strategy],Z_FIXED
325	jle @f	325	jle @f
326	.end2: ;if (..<.. \|\| ..>.. \|\| ..!=.. \|\| ..<.. \|\| ..>.. \|\| ..<0 \|\| ..>.. \|\| ..<0 \|\| ..>..)	326	.end2: ;if (..<.. \|\| ..>.. \|\| ..!=.. \|\| ..<.. \|\| ..>.. \|\| ..<0 \|\| ..>.. \|\| ..<0 \|\| ..>..)
327	mov eax,Z_STREAM_ERROR	327	mov eax,Z_STREAM_ERROR
328	jmp .end_f	328	jmp .end_f
329	@@:	329	@@:
330	cmp dword[windowBits],8	330	cmp dword[windowBits],8
331	jne @f ;if (..==..)	331	jne @f ;if (..==..)
332	inc dword[windowBits] ;until 256-byte window bug fixed	332	inc dword[windowBits] ;until 256-byte window bug fixed
333	@@:	333	@@:
334	ZALLOC ebx, 1, sizeof.deflate_state	334	ZALLOC ebx, 1, sizeof.deflate_state
335	;eax = s	335	;eax = s
336	cmp eax,Z_NULL	336	cmp eax,Z_NULL
337	jne @f ;if (..==0)	337	jne @f ;if (..==0)
338	mov eax,Z_MEM_ERROR	338	mov eax,Z_MEM_ERROR
339	jmp .end_f	339	jmp .end_f
340	@@:	340	@@:
341	mov edi,eax ;edi = s	341	mov edi,eax ;edi = s
342	mov [ebx+z_stream.state],edi	342	mov [ebx+z_stream.state],edi
343	mov [edi+deflate_state.strm],ebx	343	mov [edi+deflate_state.strm],ebx
344		344
345	mov eax,[wrap]	345	mov eax,[wrap]
346	mov [edi+deflate_state.wrap],eax	346	mov [edi+deflate_state.wrap],eax
347	mov [edi+deflate_state.gzhead],Z_NULL	347	mov [edi+deflate_state.gzhead],Z_NULL
348	mov ecx,[windowBits]	348	mov ecx,[windowBits]
349	mov [edi+deflate_state.w_bits],ecx	349	mov [edi+deflate_state.w_bits],ecx
350	xor eax,eax	350	xor eax,eax
351	inc eax	351	inc eax
352	shl eax,cl	352	shl eax,cl
353	mov [edi+deflate_state.w_size],eax	353	mov [edi+deflate_state.w_size],eax
354	dec eax	354	dec eax
355	mov [edi+deflate_state.w_mask],eax	355	mov [edi+deflate_state.w_mask],eax
356		356
357	mov ecx,[memLevel]	357	mov ecx,[memLevel]
358	add ecx,7	358	add ecx,7
359	mov [edi+deflate_state.hash_bits],ecx	359	mov [edi+deflate_state.hash_bits],ecx
360	xor eax,eax	360	xor eax,eax
361	inc eax	361	inc eax
362	shl eax,cl	362	shl eax,cl
363	mov [edi+deflate_state.hash_size],eax	363	mov [edi+deflate_state.hash_size],eax
364	dec eax	364	dec eax
365	mov [edi+deflate_state.hash_mask],eax	365	mov [edi+deflate_state.hash_mask],eax
366	add ecx,MIN_MATCH-1	366	add ecx,MIN_MATCH-1
367	xor edx,edx	367	xor edx,edx
368	mov eax,ecx	368	mov eax,ecx
369	mov ecx,MIN_MATCH	369	mov ecx,MIN_MATCH
370	div ecx	370	div ecx
371	mov [edi+deflate_state.hash_shift],eax	371	mov [edi+deflate_state.hash_shift],eax
372		372
373	ZALLOC ebx, [edi+deflate_state.w_size], 2 ;2*sizeof(Byte)	373	ZALLOC ebx, [edi+deflate_state.w_size], 2 ;2*sizeof(Byte)
374	mov [edi+deflate_state.window],eax	374	mov [edi+deflate_state.window],eax
375	ZALLOC ebx, [edi+deflate_state.w_size], 4 ;sizeof(Pos)	375	ZALLOC ebx, [edi+deflate_state.w_size], 4 ;sizeof(Pos)
376	mov [edi+deflate_state.prev],eax	376	mov [edi+deflate_state.prev],eax
377	ZALLOC ebx, [edi+deflate_state.hash_size], 4 ;sizeof(Pos)	377	ZALLOC ebx, [edi+deflate_state.hash_size], 4 ;sizeof(Pos)
378	mov [edi+deflate_state.head],eax	378	mov [edi+deflate_state.head],eax
379		379
380	mov dword[edi+deflate_state.high_water],0 ;nothing written to s->window yet	380	mov dword[edi+deflate_state.high_water],0 ;nothing written to s->window yet
381		381
382	mov ecx,[memLevel]	382	mov ecx,[memLevel]
383	add ecx,6	383	add ecx,6
384	xor eax,eax	384	xor eax,eax
385	inc eax	385	inc eax
386	shl eax,cl	386	shl eax,cl
387	mov [edi+deflate_state.lit_bufsize],eax ;16K elements by default	387	mov [edi+deflate_state.lit_bufsize],eax ;16K elements by default
388		388
389	ZALLOC ebx, eax, 4 ;sizeof(uint_16)+2	389	ZALLOC ebx, eax, 4 ;sizeof(uint_16)+2
390	mov [overlay],eax	390	mov [overlay],eax
391	mov [edi+deflate_state.pending_buf],eax	391	mov [edi+deflate_state.pending_buf],eax
392	mov eax,[edi+deflate_state.lit_bufsize]	392	mov eax,[edi+deflate_state.lit_bufsize]
393	imul eax,4 ;sizeof(uint_16)+2	393	imul eax,4 ;sizeof(uint_16)+2
394	mov [edi+deflate_state.pending_buf_size],eax	394	mov [edi+deflate_state.pending_buf_size],eax
395		395
396	cmp dword[edi+deflate_state.window],Z_NULL	396	cmp dword[edi+deflate_state.window],Z_NULL
397	je .end3	397	je .end3
398	cmp dword[edi+deflate_state.prev],Z_NULL	398	cmp dword[edi+deflate_state.prev],Z_NULL
399	je .end3	399	je .end3
400	cmp dword[edi+deflate_state.head],Z_NULL	400	cmp dword[edi+deflate_state.head],Z_NULL
401	je .end3	401	je .end3
402	cmp dword[edi+deflate_state.pending_buf],Z_NULL	402	cmp dword[edi+deflate_state.pending_buf],Z_NULL
403	je .end3	403	je .end3
404	jmp @f	404	jmp @f
405	.end3: ;if (..==0 \|\| ..==0 \|\| ..==0 \|\| ..==0)	405	.end3: ;if (..==0 \|\| ..==0 \|\| ..==0 \|\| ..==0)
406	mov dword[edi+deflate_state.status],FINISH_STATE	406	mov dword[edi+deflate_state.status],FINISH_STATE
407	ERR_MSG Z_MEM_ERROR	407	ERR_MSG Z_MEM_ERROR
408	mov [ebx+z_stream.msg],eax	408	mov [ebx+z_stream.msg],eax
409	stdcall deflateEnd, ebx	409	stdcall deflateEnd, ebx
410	mov eax,Z_MEM_ERROR	410	mov eax,Z_MEM_ERROR
411	jmp .end_f	411	jmp .end_f
412	@@:	412	@@:
413	mov eax,[edi+deflate_state.lit_bufsize]	413	mov eax,[edi+deflate_state.lit_bufsize]
414	shr eax,1 ;/=sizeof(uint_16)	414	shr eax,1 ;/=sizeof(uint_16)
415	add eax,[overlay]	415	add eax,[overlay]
416	mov [edi+deflate_state.d_buf],eax	416	mov [edi+deflate_state.d_buf],eax
417	mov eax,[edi+deflate_state.lit_bufsize]	417	mov eax,[edi+deflate_state.lit_bufsize]
418	imul eax,3 ;1+sizeof(uint_16)	418	imul eax,3 ;1+sizeof(uint_16)
419	add eax,[edi+deflate_state.pending_buf]	419	add eax,[edi+deflate_state.pending_buf]
420	mov [edi+deflate_state.l_buf],eax	420	mov [edi+deflate_state.l_buf],eax
421		421
422	mov eax,[level]	422	mov eax,[level]
423	mov [edi+deflate_state.level],ax	423	mov [edi+deflate_state.level],ax
424	mov eax,[strategy]	424	mov eax,[strategy]
425	mov [edi+deflate_state.strategy],ax	425	mov [edi+deflate_state.strategy],ax
426	mov eax,[method]	426	mov eax,[method]
427	mov [edi+deflate_state.method],al	427	mov [edi+deflate_state.method],al
428		428
429	stdcall deflateReset, ebx	429	stdcall deflateReset, ebx
430	.end_f:	430	.end_f:
431	zlib_debug 'deflateInit2_ strategy = %d',[strategy]	431	zlib_debug 'deflateInit2_ strategy = %d',[strategy]
432	ret	432	ret
433	endp	433	endp
434		434
435	; =========================================================================	435	; =========================================================================
436	;int (strm, dictionary, dictLength)	436	;int (strm, dictionary, dictLength)
437	; z_streamp strm	437	; z_streamp strm
438	; const Bytef *dictionary	438	; const Bytef *dictionary
439	; uInt dictLength	439	; uInt dictLength
440	align 4	440	align 4
441	proc deflateSetDictionary uses ebx edi, strm:dword, dictionary:dword, dictLength:dword	441	proc deflateSetDictionary uses ebx edi, strm:dword, dictionary:dword, dictLength:dword
442	locals	442	locals
443	; uInt str, n;	443	; uInt str, n;
444	wrap dd ? ;int	444	wrap dd ? ;int
445	avail dd ? ;unsigned	445	avail dd ? ;unsigned
446	next dd ? ;unsigned char*	446	next dd ? ;unsigned char*
447	endl	447	endl
448	mov ebx,[strm]	448	mov ebx,[strm]
449	cmp ebx,Z_NULL	449	cmp ebx,Z_NULL
450	je @f	450	je @f
451	mov edi,[ebx+z_stream.state]	451	mov edi,[ebx+z_stream.state]
452	cmp edi,Z_NULL	452	cmp edi,Z_NULL
453	je @f	453	je @f
454	cmp dword[dictionary],Z_NULL	454	cmp dword[dictionary],Z_NULL
455	je @f ;if (..==0 \|\| ..==0 \|\| ..==0)	455	je @f ;if (..==0 \|\| ..==0 \|\| ..==0)
456	jmp .end0	456	jmp .end0
457	@@:	457	@@:
458	mov eax,Z_STREAM_ERROR	458	mov eax,Z_STREAM_ERROR
459	jmp .end_f	459	jmp .end_f
460	.end0:	460	.end0:
461		461
462	mov eax,[edi+deflate_state.wrap]	462	mov eax,[edi+deflate_state.wrap]
463	mov [wrap],eax	463	mov [wrap],eax
464	cmp dword[wrap],2	464	cmp dword[wrap],2
465	je .end1	465	je .end1
466	cmp dword[edi+deflate_state.lookahead],0	466	cmp dword[edi+deflate_state.lookahead],0
467	jne .end1	467	jne .end1
468	cmp dword[wrap],1	468	cmp dword[wrap],1
469	jne @f	469	jne @f
470	cmp dword[edi+deflate_state.status],INIT_STATE	470	cmp dword[edi+deflate_state.status],INIT_STATE
471	je @f	471	je @f
472	.end1: ;if (..==.. \|\| .. \|\| (..==.. && ..!=..)) return ..	472	.end1: ;if (..==.. \|\| .. \|\| (..==.. && ..!=..)) return ..
473	mov eax,Z_STREAM_ERROR	473	mov eax,Z_STREAM_ERROR
474	jmp .end_f	474	jmp .end_f
475	@@:	475	@@:
476		476
477	; when using zlib wrappers, compute Adler-32 for provided dictionary	477	; when using zlib wrappers, compute Adler-32 for provided dictionary
478	cmp dword[wrap],1	478	cmp dword[wrap],1
479	jne @f ;if (..==..)	479	jne @f ;if (..==..)
480	stdcall adler32, [ebx+z_stream.adler], [dictionary], [dictLength]	480	stdcall adler32, [ebx+z_stream.adler], [dictionary], [dictLength]
481	mov [ebx+z_stream.adler],eax	481	mov [ebx+z_stream.adler],eax
482	@@:	482	@@:
483	mov dword[edi+deflate_state.wrap],0 ;avoid computing Adler-32 in read_buf	483	mov dword[edi+deflate_state.wrap],0 ;avoid computing Adler-32 in read_buf
484		484
485	; if dictionary would fill window, just replace the history	485	; if dictionary would fill window, just replace the history
486	mov eax,[edi+deflate_state.w_size]	486	mov eax,[edi+deflate_state.w_size]
487	cmp [dictLength],eax	487	cmp [dictLength],eax
488	jl .end2 ;if (..>=..)	488	jl .end2 ;if (..>=..)
489	; if (wrap == 0) { /* already empty otherwise */	489	; if (wrap == 0) { /* already empty otherwise */
490	; CLEAR_HASH(s);	490	; CLEAR_HASH(s);
491	; s->strstart = 0;	491	; s->strstart = 0;
492	; s->block_start = 0L;	492	; s->block_start = 0L;
493	; s->insert = 0;	493	; s->insert = 0;
494	; }	494	; }
495	; dictionary += dictLength - s->w_size; /* use the tail */	495	; dictionary += dictLength - s->w_size; /* use the tail */
496	mov eax,[edi+deflate_state.w_size]	496	mov eax,[edi+deflate_state.w_size]
497	mov [dictLength],eax	497	mov [dictLength],eax
498	.end2:	498	.end2:
499		499
500	; insert dictionary into window and hash	500	; insert dictionary into window and hash

Subversion Repositories Kolibri OS

(root)/programs/fs/kfar/trunk/zlib/deflate.asm – Rev 6799 → 6801