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

 	ret
 endp
 ; =========================================================================
 ;int (strm, level, version, stream_size)
-;    z_streamp strm;
+;    z_streamp strm
-;    int level;
+;    int level
-;    const char *version;
+;    const char *version
-;    int stream_size;
+;    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]
 endp
 ; =========================================================================
 ;int (strm, level, method, windowBits, memLevel, strategy,
 ;                  version, stream_size)
-;    z_streamp strm;
+;    z_streamp strm
-;    int  level;
+;    int  level
-;    int  method;
+;    int  method
-;    int  windowBits;
+;    int  windowBits
-;    int  memLevel;
+;    int  memLevel
-;    int  strategy;
+;    int  strategy
-;    const char *version;
+;    const char *version
-;    int stream_size;
+;    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
 	ret
 endp
 ; =========================================================================
 ;int (strm, dictionary, dictLength)
-;    z_streamp strm;
+;    z_streamp strm
-;    const Bytef *dictionary;
+;    const Bytef *dictionary
-;    uInt  dictLength;
+;    uInt  dictLength
 align 4
 proc deflateSetDictionary uses ebx edi, strm:dword, dictionary:dword, dictLength:dword
 locals
 ;    deflate_state *s;
 	ret
 endp
 ; =========================================================================
 ;int (strm)
-;    z_streamp strm;
+;    z_streamp strm
 align 4
 proc deflateResetKeep uses ebx edi, strm:dword
 ;    deflate_state *s;
 	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
-		stdcall calc_crc32, 0, Z_NULL, 0
+		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
 	ret
 endp
 ; =========================================================================
 ;int (strm)
-;    z_streamp strm;
+;    z_streamp strm
 align 4
 proc deflateReset uses ebx, strm:dword
 	mov ebx,[strm]
-;zlib_debug 'deflateReset'
+	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;
+;    z_streamp strm
-;    gz_headerp head;
+;    gz_headerp head
 align 4
 proc deflateSetHeader uses ebx, strm:dword, head:dword
 	mov ebx,[strm]
 	ret
 endp
 ; =========================================================================
 ;int (strm, pending, bits)
-;    unsigned *pending;
+;    unsigned *pending
-;    int *bits;
+;    int *bits
-;    z_streamp strm;
+;    z_streamp strm
 align 4
 proc deflatePending uses ebx edi, strm:dword, pending:dword, bits:dword
 	mov ebx,[strm]
 	cmp ebx,Z_NULL
 	ret
 endp
 ; =========================================================================
 ;int (strm, bits, value)
-;    z_streamp strm;
+;    z_streamp strm
-;    int bits;
+;    int bits
-;    int value;
+;    int value
 align 4
 proc deflatePrime uses ebx edi, strm:dword, bits:dword, value:dword
 ;    int put;
 	ret
 endp
 ; =========================================================================
 ;int (strm, level, strategy)
-;    z_streamp strm;
+;    z_streamp strm
-;    int level;
+;    int level
-;    int strategy;
+;    int strategy
 align 4
 proc deflateParams uses ebx edi, strm:dword, level:dword, strategy:dword
 ;    compress_func func;
 	ret
 endp
 ; =========================================================================
 ;int (strm, good_length, max_lazy, nice_length, max_chain)
-;    z_streamp strm;
+;    z_streamp strm
-;    int good_length;
+;    int good_length
-;    int max_lazy;
+;    int max_lazy
-;    int nice_length;
+;    int nice_length
-;    int max_chain;
+;    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]
 ; 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;
+;    z_streamp strm
-;    uLong sourceLen;
+;    uLong sourceLen
 align 4
 proc deflateBound, strm:dword, sourceLen:dword
 ;    deflate_state *s;
 ;    uLong complen, wraplen;
 ;    Bytef *str;
-;zlib_debug 'deflateBound'
+	zlib_debug 'deflateBound'
 	; conservative upper bound for compressed data
 ; 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;
+;    deflate_state *s
-;    uInt b;
+;    uInt b
 align 4
 proc putShortMSB uses ebx ecx, s:dword, b:dword
 	mov ebx,[s]
 	mov ecx,[b]
 ; 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;
+;    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'
+	zlib_debug 'flush_pending'
 	mov ebx,[strm]
 	mov edx,[ebx+z_stream.state]
 	ret
 endp
 ; =========================================================================
 ;int (strm, flush)
-;    z_streamp strm;
+;    z_streamp strm
-;    int flush;
+;    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
 	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 (..==..)
-			stdcall calc_crc32, 0, Z_NULL, 0
+			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
 			je @f ;if (..!=0)
 				mov ecx,[ebx+z_stream.adler]
 				bswap ecx
 				put_dword edi, ecx
 			@@:
-			stdcall calc_crc32, 0, Z_NULL, 0
+			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
 			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
-				stdcall calc_crc32, 0, Z_NULL, 0
+				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 eax,Z_OK
 			jmp .end_f
 	.end11:
 	cmp word[ebx+z_stream.avail_out],0
 	jg @f
-		zlib_debug 'bug2' ;Assert(..>0)
+		zlib_assert 'bug2' ;Assert(..>0)
 	@@:
 	cmp dword[flush],Z_FINISH
 	je @f ;if (..!=0)
 	ret
 endp
 ; =========================================================================
 ;int (strm)
-;    z_streamp strm;
+;    z_streamp strm
 align 4
 proc deflateEnd uses ebx ecx edx, strm:dword
 	mov ebx,[strm]
 zlib_debug 'deflateEnd'
 ; 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 dest
-;    z_streamp source;
+;    z_streamp source
 align 4
-proc deflateCopy uses edx edi esi, dest:dword, source:dword
-locals
+proc deflateCopy uses ebx edx edi esi, dest:dword, source:dword
-	overlay dd ? ;uint_16p
-endl
+;ebx = overlay ;uint_16p
-;edi = ds; deflate_state*
+;edi = ds ;deflate_state*
-;esi = ss; deflate_state*
+;esi = ss ;deflate_state*
 	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 [overlay],eax
+	mov ebx,eax
 	mov dword[edi+deflate_state.pending_buf],eax
 	cmp dword[edi+deflate_state.window],Z_NULL
 	je @f
 	; 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]
-	stdcall zmemcpy, [edi+deflate_state.window], [esi+deflate_state.window], eax
+	shl eax,2 ;*= sizeof.dd
+	stdcall zmemcpy, [edi+deflate_state.prev], [esi+deflate_state.prev], eax
+	mov eax,[edi+deflate_state.hash_size]
-;    zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
+	shl eax,2 ;*= sizeof.dd
-;    zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
+	stdcall zmemcpy, [edi+deflate_state.head], [esi+deflate_state.head], eax
-;    zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+	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]
-;    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->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
-;    ds->d_buf = overlay + ds->lit_bufsize/sizeof(uint_16);
+	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]
-;    ds->l_buf = ds->pending_buf + (1+sizeof(uint_16))*ds->lit_bufsize;
+	mov [edi+deflate_state.l_buf],eax
 	mov eax,edi
 	add eax,deflate_state.dyn_ltree
 ; 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;
+;    z_streamp strm
-;    Bytef *buf;
+;    Bytef *buf
-;    unsigned size;
+;    unsigned size
 align 4
 proc read_buf uses ebx ecx, strm:dword, buf:dword, size:dword
 	mov ebx,[strm]
 end if
 	ret
 endp
 ;uInt (s, cur_match)
-;    deflate_state *s;
+;    deflate_state *s
-;    IPos cur_match;                             /* current match */
+;    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
 ; ===========================================================================
 	; we prevent matches with the string of window index 0.
 ;    Posf *prev = s->prev;
-;    uInt wmask = s->w_mask;
-if UNALIGNED_OK eq 1
-	; Compare two bytes at a time. Note: this is not always beneficial.
-	; Try with and without -DUNALIGNED_OK to check.
-;    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
-;    register uint_16 scan_start = *(uint_16p*)scan;
-;    register uint_16 scan_end   = *(uint_16p*)(scan+best_len-1);
+;    uInt wmask = s->w_mask;
 else
 ;    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
-;    register Byte scan_end1  = scan[best_len-1];
-;    register Byte scan_end   = scan[best_len];
+;    register Byte scan_end1  = scan[best_len-1];
-end if
+;    register Byte scan_end   = scan[best_len];
 	; 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.
-if ((UNALIGNED_OK eq 1) & MAX_MATCH == 258)
-	; This code assumes sizeof(unsigned short) == 2. Do not use
-	; UNALIGNED_OK if your compiler uses a different size.
-;        if (*(uint_16p*)(match+best_len-1) != scan_end ||
-;            *(uint_16p*)match != scan_start) continue;
-	; It is not necessary to compare scan[2] and match[2] since they are
-	; always equal when the other bytes match, given that the hash keys
-	; are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
-	; strstart+3, +5, ... up to strstart+257. We check for insufficient
-	; lookahead only every 4th comparison; the 128th check will be made
-	; at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
-	; necessary to put more guard bytes at the end of the window, or
-	; to check more often for insufficient lookahead.
-;        Assert(scan[2] == match[2], "scan[2]?");
-;        scan++, match++;
-;        do {
-;        } while (*(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
-;                 *(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
-;                 *(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
-;                 *(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
-;                 scan < strend);
-	; The funny "do {}" generates better code on most compilers
-	; Here, scan <= window+strstart+257
-;        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-;        if (*scan == *match) scan++;
-;        len = (MAX_MATCH - 1) - (int)(strend-scan);
-;        scan = strend - (MAX_MATCH-1);
-else ;UNALIGNED_OK
 ;        if (match[best_len]   != scan_end  ||
 ;            match[best_len-1] != scan_end1 ||
 ;            *match            != *scan     ||
 ;        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
 ;        len = MAX_MATCH - (int)(strend - scan);
-;        scan = strend - MAX_MATCH;
-end if ;UNALIGNED_OK
+;        scan = strend - MAX_MATCH;
 ;        if (len > best_len) {
 ;            s->match_start = cur_match;
-;            best_len = len;
-;            if (len >= nice_match) break;
-if UNALIGNED_OK eq 1
-;            scan_end = *(uint_16p*)(scan+best_len-1);
+;            best_len = len;
-else
+;            if (len >= nice_match) break;
-;            scan_end1  = scan[best_len-1];
-;            scan_end   = scan[best_len];
+;            scan_end1  = scan[best_len-1];
-end if
+;            scan_end   = scan[best_len];
 ;        }
 ;    } while ((cur_match = prev[cur_match & wmask]) > limit
 else ;FASTEST
 ; ---------------------------------------------------------------------------
 ; Optimized version for FASTEST only
 	mov edx,[s]
-;zlib_debug 'longest_match'
+	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_debug 'Code too clever' ;Assert(..>=.. && ..==..)
+		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_debug 'need lookahead' ;Assert(..<=..)
+		zlib_assert 'need lookahead' ;Assert(..<=..)
 	@@:
 	mov eax,[edx+deflate_state.strstart]
 	cmp [cur_match],eax
 	jl @f
-		zlib_debug 'no future' ;Assert(..<..)
+		zlib_assert 'no future' ;Assert(..<..)
 	@@:
 	add edi,2
 	mov al,byte[edi]
 	cmp al,byte[esi]
 	je @f
-		zlib_debug 'match[2]?' ;Assert(..==..)
+		zlib_assert 'match[2]?' ;Assert(..==..)
 	@@:
 	mov eax,[edx+deflate_state.window_size]
 	dec eax
 	add eax,[edx+deflate_state.window]
 	cmp edi,eax
 	jle @f
-		zlib_debug 'wild scan' ;Assert(..<=..)
+		zlib_assert 'wild scan' ;Assert(..<=..)
 	@@:
 	sub edi,ebx
 	;edi = len
 ; ===========================================================================
 ; Check that the match at match_start is indeed a match.
 ;void (s, start, match, length)
-;    deflate_state *s;
+;    deflate_state *s
-;    IPos start, match;
+;    IPos start, match
-;    int length;
+;    int length
 align 4
 proc check_match, s:dword, start:dword, p3match:dword, length:dword
 if DEBUG eq 1
 ;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'
+	zlib_debug 'fill_window'
 	mov edi,[s]
 	cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
 	jl @f
-		zlib_debug 'already enough lookahead' ;Assert(..<..)
+		zlib_assert 'already enough lookahead' ;Assert(..<..)
 	@@:
 	mov ecx,[edi+deflate_state.w_size]
 	mov edx,[edi+deflate_state.strm]
 	.cycle0: ;do
-;zlib_debug 'do'
+	zlib_debug 'do'
 		mov ebx,[edi+deflate_state.window_size]
 		sub ebx,[edi+deflate_state.lookahead]
 		sub ebx,[edi+deflate_state.strstart]
 		; 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_debug 'more < 2' ;Assert(..>=..)
+			zlib_assert 'more < 2' ;Assert(..>=..)
 		@@:
 		mov eax,[edi+deflate_state.window]
 		add eax,[edi+deflate_state.strstart]
 		add eax,[edi+deflate_state.lookahead]
 	mov eax,[edi+deflate_state.window_size]
 	sub eax,MIN_LOOKAHEAD
 	cmp [edi+deflate_state.strstart],eax
 	jle @f
-		zlib_debug 'not enough room for search' ;Assert(..<=..)
+		zlib_assert 'not enough room for search' ;Assert(..<=..)
 	@@:
 popad
 	ret
 ; 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;
+;    deflate_state *s
-;    int flush;
+;    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:
 		;.end4:
 		jmp .cycle0
 	.cycle0end:
 	cmp dword[flush],Z_NO_FLUSH
 	jne @f
-		zlib_debug 'no flush?' ;Assert (..!=..)
+		zlib_assert 'no flush?' ;Assert (..!=..)
 	@@:
 	cmp dword[edi+deflate_state.match_available],0
 	je @f ;if (..)
 		mov eax,[edi+deflate_state.strstart]
 		dec eax
 ; 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;
+;    deflate_state *s
-;    int flush;
+;    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
 			mov eax,[edx+deflate_state.window_size]
 			dec eax
 			add eax,[edx+deflate_state.window]
 			cmp edi,eax
 			jle .end1
-				zlib_debug 'wild scan' ;Assert(..<=..)
+				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
 ; ===========================================================================
 ; 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;
+;    deflate_state *s
-;    int flush;
+;    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

Subversion Repositories Kolibri OS

(root)/programs/fs/kfar/trunk/zlib/deflate.asm – Rev 6617 → 6639