Subversion Repositories Kolibri OS

; 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

	add ebx,[s+deflate_state.prev]

	mov byte[ebx],al

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

;    deflate_state *s;

;    uInt str, n;

	wrap dd ? ;int

	avail dd ? ;unsigned

;    z_const unsigned char *next;

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

;    if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)

;        return Z_STREAM_ERROR;

	; when using zlib wrappers, compute Adler-32 for provided dictionary

;    if (wrap == 1)

;        strm->adler = adler32(strm->adler, dictionary, dictLength);

;    s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */

	; if dictionary would fill window, just replace the history

;    if (dictLength >= s->w_size) {

;        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 */

;        dictLength = s->w_size;

;    }

	; 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;

;    s->insert = s->lookahead;

;    s->lookahead = 0;

;    s->match_length = s->prev_length = MIN_MATCH-1;

;    s->match_available = 0;

;    strm->next_in = next;

;    strm->avail_in = avail;

;    s->wrap = wrap;

	mov eax,Z_OK

.end_f:

	ret

endp

; =========================================================================

;int (strm)

;    z_streamp strm

align 4

proc deflateResetKeep uses ebx edi, strm:dword

;    deflate_state *s;

	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 word[ebx+z_stream.data_type],Z_UNKNOWN

	mov word[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,0

	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]

		movzx ebx,word[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

;    compress_func func;

;    int err = Z_OK;

	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

;    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {

;        return Z_STREAM_ERROR;

;    }

;    func = configuration_table[s->level].func;

;    if ((strategy != s->strategy || 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;

;    }

;    s->strategy = strategy;

;    return 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

	movzx ecx,word[edx+deflate_state.pending]

	cmp cx,[ebx+z_stream.avail_out]

	jle @f ;if (..>..)

		movzx ecx,word[ebx+z_stream.avail_out]

	@@:

	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],cx

	sub [edx+deflate_state.pending],cx

	cmp word[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

	jl @f ;if (..==0 || ..==0 || ..>.. || ..<0)

		jmp .end10

	@@:

		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 word[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 word[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 (..)

					movzx eax,word[edi+deflate_state.pending]

					stdcall calc_crc32, [ebx+z_stream.adler],\

						[edi+deflate_state.pending_buf], eax

					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

			jl @f

			cmp word[edi+deflate_state.level],2

			jge @f ;if (..>=.. || ..<..)

				xor esi,esi

				jmp .end4

			@@:

			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 (..!=..)

			movzx esi,word[edi+deflate_state.pending]

			;esi = beg ;start of bytes to update crc

			movzx ecx,word[edx+gz_header.extra_len]

			.cycle0: ;while (..<..)