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

 	je @f ;if (..!=0)
 		mov dword[level],1
 	@@:
 else
 	cmp dword[level],Z_DEFAULT_COMPRESSION
-	jne @f ;if (..==0)
+	jne @f ;if (..==..)
 		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]
+		neg dword[windowBits]
 		jmp .end1
 	@@:
 if GZIP eq 1
 	cmp dword[windowBits],15
 		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 eax,[method]
 	mov [edi+deflate_state.method],al
 	stdcall deflateReset, ebx
-.end_f:
-zlib_debug 'deflateInit2_ strategy = %d',[strategy]
+.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]
 	@@:
 	je @f ;if (..!=0)
 		mov dword[level],1
 	@@:
 else
 	cmp dword[level],Z_DEFAULT_COMPRESSION
-	jne @f ;if (..==0)
+	jne @f ;if (..==..)
 		mov dword[level],6
 	@@:
 end if
 	cmp dword[level],0
 	jl @f
 ; 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
+;uLong (z_streamp strm, uLong sourceLen)
 align 4
-proc deflateBound, strm:dword, sourceLen:dword
+proc deflateBound uses ebx edi, strm:dword, sourceLen:dword
-;    deflate_state *s;
+locals
-;    uLong complen, wraplen;
+	complen dd ?
+	wraplen dd ?
-;    Bytef *str;
+endl
-	zlib_debug 'deflateBound'
+;edi = s
+	; conservative upper bound for compressed data
+	mov ebx,[sourceLen]
+	mov eax,ebx
+	add eax,7
+	shr eax,3
+	add eax,ebx
-	; conservative upper bound for compressed data
+	add ebx,63
+	shr ebx,6
-;    complen = sourceLen +
+	lea eax,[eax+ebx+5]
+	mov [complen],eax
+	; if can't get parameters, return conservative bound plus zlib wrapper
-;              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
+	mov eax,[strm]
+	cmp eax,Z_NULL
+	je .end0
+	mov edi,[eax+z_stream.state] ;s = strm.state
+	cmp edi,Z_NULL
+	jne @f
+	.end0: ;if (..==0 || ..==0)
+		mov eax,[complen]
-	; if can't get parameters, return conservative bound plus zlib wrapper
+		add eax,6
-;    if (strm == Z_NULL || strm->state == Z_NULL)
+		jmp .end_f
-;        return complen + 6;
+	@@:
+	; compute wrapper length
+	mov ebx,[edi+deflate_state.wrap]
+	cmp ebx,0
+	je .end1
+	cmp ebx,1
+	je .end2
-	; compute wrapper length
+	cmp ebx,2
-;    s = strm->state;
+	je .end3
-;    switch (s->wrap) {
+	jmp .end4
-;    case 0:                                 /* raw deflate */
+	.end1: ;raw deflate
+		mov dword[wraplen],0
-;        wraplen = 0;
+		jmp .end5
+	.end2: ;zlib wrapper
+		mov eax,[edi+deflate_state.strstart]
+		neg eax
+		sbb eax,eax
-;        break;
+		and eax,4
-;    case 1:                                 /* zlib wrapper */
+		add eax,6
-;        wraplen = 6 + (s->strstart ? 4 : 0);
+		mov [wraplen],eax
+		jmp .end5
-;        break;
+	.end3: ;gzip wrapper
-;    case 2:                                 /* gzip wrapper */
+		mov dword[wraplen],18
+		cmp dword[edi+deflate_state.gzhead],Z_NULL ;user-supplied gzip header
-;        wraplen = 18;
+		je .end5
-;        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
+		mov eax,[edi+deflate_state.gzhead]
-;            if (s->gzhead->extra != Z_NULL)
+		cmp dword[eax+gz_header.extra],0
-;                wraplen += 2 + s->gzhead->extra_len;
+		je @f
+			mov eax,[edi+deflate_state.gzhead]
-;            str = s->gzhead->name;
+			mov eax,[eax+gz_header.extra_len]
-;            if (str != Z_NULL)
+			add dword[wraplen],eax
+			add dword[wraplen],2
+		@@:
+		mov eax,[edi+deflate_state.gzhead]
+		mov eax,[eax+gz_header.name]
+		cmp eax,0
+		je @f
+		.cycle0: ;do
+			inc dword[wraplen]
+			movzx ebx,byte[eax]
-;                do {
+			inc eax
+			test ebx,ebx
+			jne .cycle0
+		@@:
-;                    wraplen++;
+		mov eax,[edi+deflate_state.gzhead]
-;                } while (*str++);
+		mov eax,[eax+gz_header.comment]
-;            str = s->gzhead->comment;
+		cmp eax,0
+		je @f
+		.cycle1: ;do
+			inc dword[wraplen]
+			movzx ebx,byte[eax]
-;            if (str != Z_NULL)
+			inc eax
-;                do {
+			test ebx,ebx
-;                    wraplen++;
+			jne .cycle1
+		@@:
-;                } while (*str++);
+		mov eax,[edi+deflate_state.gzhead]
-;            if (s->gzhead->hcrc)
+		cmp dword[eax+gz_header.hcrc],0
-;                wraplen += 2;
+		je .end5
-;        }
+			add dword[wraplen],2
-;        break;
+		jmp .end5
+	.end4: ;for compiler happiness
+		mov dword[wraplen],6
+	.end5:
-;    default:                                /* for compiler happiness */
+	; if not default parameters, return conservative bound
+	cmp dword[edi+deflate_state.w_bits],15
-;        wraplen = 6;
+	jne .end6
+	cmp dword[edi+deflate_state.hash_bits],8+7
+	je @f
-;    }
+	.end6: ;if (s->w_bits !=.. || s->hash_bits !=..)
+		mov eax,[complen]
+		add eax,[wraplen]
+		jmp .end_f
+	@@:
+	; default settings: return tight bound for that case
+	mov eax,[sourceLen]
+	mov ebx,eax
-	; if not default parameters, return conservative bound
+	shr ebx,12
+	add ebx,eax
-;    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
+	mov edi,eax
-;        return complen + wraplen;
+	shr edi,14
 	add ebx,edi
-	; default settings: return tight bound for that case
+	shr eax,25
-;    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+	add ebx,[wraplen]
-;           (sourceLen >> 25) + 13 - 6 + wraplen;
+	lea eax,[eax+ebx+7]
 .end_f:
-	ret
-endp
+	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.
+; 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
-;void (s, b)
+; pending_buf.
 ;    deflate_state *s
 else ;FASTEST
 ; ---------------------------------------------------------------------------
 ; Optimized version for FASTEST only
-	mov edx,[s]
-	zlib_debug 'longest_match'
+	mov edx,[s]
 	; The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
 		; 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 (..>=..)
+		jb .end1 ;if (..>=..)
 			mov esi,[edi+deflate_state.strstart]
 			sub esi,[edi+deflate_state.insert]
 			;esi = str
 			mov eax,[edi+deflate_state.window]
 ; 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
+;block_state (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:

Subversion Repositories Kolibri OS

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