Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6819 → Rev 6847

/programs/fs/kfar/trunk/zlib/deflate.asm
55,10 → 55,10
; 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
need_more equ 0 ;block not completed, need more input or more output
block_done equ 1 ;block flush performed
finish_started equ 2 ;finish started, need only more output at next deflate
finish_done equ 3 ;finish done, accept no more input or output
 
; ===========================================================================
; Local data
154,24 → 154,25
movzx eax,byte[eax]
UPDATE_HASH s, [s+deflate_state.ins_h], eax
mov eax,[s+deflate_state.ins_h]
shl eax,2
shl eax,1
add eax,[s+deflate_state.head]
mov eax,[eax]
movzx eax,word[eax]
mov match_head,eax
push ebx
if FASTEST eq 0
push ebx
mov ebx,[s+deflate_state.w_mask]
and ebx,str
shl ebx,2
shl ebx,1
add ebx,[s+deflate_state.prev]
mov [ebx],eax
pop ebx
mov [ebx],ax
 
end if
mov eax,[s+deflate_state.ins_h]
shl eax,2
shl eax,1
add eax,[s+deflate_state.head]
push str
pop dword[eax]
mov ebx,str
mov [eax],bx
pop ebx
}
 
; ===========================================================================
182,12 → 183,12
{
;mov eax,[s+deflate_state.hash_size]
;dec eax
;shl eax,2
;shl eax,1
;add eax,[s+deflate_state.head]
;mov dword[eax],NIL
;mov word[eax],NIL
mov eax,[s+deflate_state.hash_size]
;dec eax
shl eax,2 ;sizeof(*s.head)
shl eax,1 ;sizeof(*s.head)
stdcall zmemzero, [s+deflate_state.head], eax
}
 
372,9 → 373,9
 
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)
ZALLOC ebx, [edi+deflate_state.w_size], 2 ;sizeof(Pos)
mov [edi+deflate_state.prev],eax
ZALLOC ebx, [edi+deflate_state.hash_size], 4 ;sizeof(Pos)
ZALLOC ebx, [edi+deflate_state.hash_size], 2 ;sizeof(Pos)
mov [edi+deflate_state.head],eax
 
mov dword[edi+deflate_state.high_water],0 ;nothing written to s->window yet
522,19 → 523,19
UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if FASTEST eq 0
mov edx,[edi+deflate_state.ins_h]
shl edx,2
shl edx,1
add edx,[edi+deflate_state.head]
mov edx,[edx] ;edx = s.head[s.ins_h]
movzx edx,word[edx] ;edx = s.head[s.ins_h]
mov eax,esi
and eax,[edi+deflate_state.w_mask]
shl eax,2
shl eax,1
add eax,[edi+deflate_state.prev]
mov [eax],edx
mov [eax],dx
end if
mov edx,[edi+deflate_state.ins_h]
shl edx,2
shl edx,1
add edx,[edi+deflate_state.head]
mov [edx],esi ;s.head[s.ins_h] = str
mov [edx],si ;s.head[s.ins_h] = str
inc esi
dec ecx
jnz .cycle1 ;while (--..)
940,14 → 941,12
; to avoid allocating a large strm->next_out buffer and copying into it.
; (See also read_buf()).
 
;void (strm)
; z_streamp strm
align 4
;void (z_streamp strm)
align 16
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]
 
958,8 → 957,8
jle @f ;if (..>..)
mov ecx,eax
@@:
cmp ecx,0
je @f
test ecx,ecx
jz @f
 
stdcall zmemcpy, [ebx+z_stream.next_out], [edx+deflate_state.pending_out], ecx
add [ebx+z_stream.next_out],ecx
979,7 → 978,7
;int (strm, flush)
; z_streamp strm
; int flush
align 4
align 16
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
986,7 → 985,6
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
1180,6 → 1178,7
;esi = beg ;start of bytes to update crc
 
movzx ecx,word[edx+gz_header.extra_len]
align 4
.cycle0: ;while (..<..)
cmp dword[edi+deflate_state.gzindex],ecx
jge .cycle0end
1288,7 → 1287,7
mov dword[edi+deflate_state.status],COMMENT_STATE
jmp .end6
.end22: ;else
mov dword[edi+deflate_state.status],COMMENT_STATE;
mov dword[edi+deflate_state.status],COMMENT_STATE
.end6:
cmp dword[edi+deflate_state.status],COMMENT_STATE
jne .end7 ;if (..==..)
1361,7 → 1360,7
mov ecx,[edi+deflate_state.pending]
add ecx,2
cmp ecx,[edi+deflate_state.pending_buf_size]
jg @f ;if (..<=..)
jg .end8 ;if (..<=..)
mov ecx,[ebx+z_stream.adler]
put_byte edi, cl
put_byte edi, ch
1368,7 → 1367,6
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
1390,11 → 1388,10
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
align 4
.end13:
cmp dword[ebx+z_stream.avail_in],0
jne @f
1554,7 → 1551,6
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]
1644,9 → 1640,9
 
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
ZALLOC edx, [edi+deflate_state.w_size], 2 ;sizeof.dw
mov dword[edi+deflate_state.prev],eax
ZALLOC edx, [edi+deflate_state.hash_size], 4 ;sizeof.dd
ZALLOC edx, [edi+deflate_state.hash_size], 2 ;sizeof.dw
mov dword[edi+deflate_state.head],eax
ZALLOC edx, [edi+deflate_state.lit_bufsize], 4 ;sizeof.dw+2
mov ebx,eax
1671,10 → 1667,10
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
shl eax,1 ;*= sizeof.dw
stdcall zmemcpy, [edi+deflate_state.prev], [esi+deflate_state.prev], eax
mov eax,[edi+deflate_state.hash_size]
shl eax,2 ;*= sizeof.dd
shl eax,1 ;*= sizeof.dw
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]
 
1715,7 → 1711,7
; z_streamp strm
; Bytef *buf
; unsigned size
align 4
align 16
proc read_buf uses ebx ecx, strm:dword, buf:dword, size:dword
mov ebx,[strm]
mov eax,[ebx+z_stream.avail_in]
1740,7 → 1736,9
stdcall adler32, [ebx+z_stream.adler], [buf], eax
mov [ebx+z_stream.adler],eax
pop eax
if GZIP eq 1
jmp .end0
end if
@@:
if GZIP eq 1
cmp dword[ecx+deflate_state.wrap],2
1749,8 → 1747,8
stdcall calc_crc32, [ebx+z_stream.adler], [buf], eax
mov [ebx+z_stream.adler],eax
pop eax
.end0:
end if
.end0:
add [ebx+z_stream.next_in],eax
add [ebx+z_stream.total_in],eax
 
1761,9 → 1759,8
; ===========================================================================
; Initialize the "longest match" routines for a new zlib stream
 
;void (s)
; deflate_state *s
align 4
;void (deflate_state *s)
align 16
proc lm_init uses eax ebx edi, s:dword
mov edi,[s]
mov eax,[edi+deflate_state.w_size]
1805,7 → 1802,7
;uInt (s, cur_match)
; deflate_state *s
; IPos cur_match ;current match
align 4
align 16
proc longest_match uses ebx ecx edx edi esi, s:dword, cur_match:dword
if FASTEST eq 0
; ===========================================================================
1984,9 → 1981,9
.cycle0cont:
mov eax,[cur_match]
and eax,[wmask]
shl eax,2
shl eax,1
add eax,[prev]
mov eax,[eax] ;eax = prev[cur_match & wmask]
movzx eax,word[eax] ;eax = prev[cur_match & wmask]
mov [cur_match],eax
cmp eax,[limit]
jle .cycle0end
2094,11 → 2091,9
@@:
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.
 
2127,7 → 2122,6
ret
endp
 
 
; ===========================================================================
; Fill the window when the lookahead becomes insufficient.
; Updates strstart and lookahead.
2138,9 → 2132,8
; performed for at least two bytes (required for the zip translate_eol
; option -- not supported here).
 
;void (s)
; deflate_state *s
align 4
;void (deflate_state *s)
align 16
proc fill_window, s:dword
pushad
;esi = p, str, curr
2148,7 → 2141,6
;Объем свободного пространства в конце окна.
;ecx = wsize ;uInt
;edx = s.strm
zlib_debug 'fill_window'
mov edi,[s]
cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
jl @f
2158,7 → 2150,6
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]
2177,7 → 2168,6
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
2190,32 → 2180,31
mov ebx,ecx
mov ecx,[edi+deflate_state.hash_size]
mov esi,ecx
shl esi,2
shl esi,1
add esi,[edi+deflate_state.head]
.cycle1: ;do
sub esi,4
mov eax,[esi]
mov dword[esi],NIL
sub esi,2
movzx eax,word[esi]
mov word[esi],NIL
cmp eax,ebx
jl @f
sub eax,ebx
mov dword[esi],eax
mov [esi],ax
@@:
loop .cycle1 ;while (..)
 
if FASTEST eq 0
mov ecx,ebx
mov esi,ecx
shl esi,2
shl esi,1
add esi,[edi+deflate_state.prev]
.cycle2: ;do
sub esi,4
mov eax,[esi]
mov dword[esi],NIL
sub esi,2
movzx eax,word[esi]
mov word[esi],NIL
cmp eax,ebx
jl @f
sub eax,ebx
mov dword[esi],eax
mov [esi],ax
@@:
; If n is not on any hash chain, prev[n] is garbage but
; its value will never be used.
2276,21 → 2265,21
UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if FASTEST eq 0
mov eax,[edi+deflate_state.ins_h]
shl eax,2
shl eax,1
add eax,[edi+deflate_state.head]
push ebx
mov ebx,[edi+deflate_state.w_mask]
and ebx,esi
shl ebx,2
shl ebx,1
add ebx,[edi+deflate_state.prev]
mov eax,[eax]
mov [ebx],eax
mov ax,[eax]
mov [ebx],ax
pop ebx
end if
mov eax,[edi+deflate_state.ins_h]
shl eax,2
shl eax,1
add eax,[edi+deflate_state.head]
mov [eax],esi
mov [eax],si
inc esi
dec dword[edi+deflate_state.insert]
mov eax,[edi+deflate_state.lookahead]
2385,7 → 2374,7
sub eax,[s+deflate_state.block_start]
push eax
xor eax,eax
cmp dword[s+deflate_state.block_start],0
cmp [s+deflate_state.block_start],eax
jl .end0
mov eax,[s+deflate_state.block_start]
add eax,[s+deflate_state.window]
2431,7 → 2420,6
; 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]
2443,7 → 2431,7
 
; Copy as much as possible from input to output:
align 4
.cycle0: ;for (;;) {
.cycle0: ;for (;;)
; Fill the window as much as possible:
cmp dword[edi+deflate_state.lookahead],1
jg .end0 ;if (..<=..)
2531,7 → 2519,6
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
2686,7 → 2673,6
endl
;ecx = hash_head ;IPos ;head of the hash chain
mov edi,[s]
zlib_debug 'deflate_slow'
 
; Process the input block.
.cycle0: ;for (;;)
2903,7 → 2889,6
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
3026,7 → 3011,6
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.
/programs/fs/kfar/trunk/zlib/deflate.inc
146,7 → 146,9
; levels >= 4.
 
level dw ? ;int ;compression level (1..9)
rb 2 ;for align
strategy dw ? ;int ;favor or force Huffman coding
rb 2 ;for align
 
good_match dd ? ;uInt
; Use a faster search when the previous match is longer than this
166,7 → 168,7
bl_count rw MAX_BITS+1 ;uint_16[]
; number of codes at each bit length for an optimal tree
 
heap rw 2*L_CODES+1 ;int[] ;heap used to build the Huffman trees
heap rd 2*L_CODES+1 ;int[] ;heap used to build the Huffman trees
heap_len dd ? ;int ;number of elements in the heap
heap_max dd ? ;int ;element of largest frequency
; The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
209,11 → 211,12
insert dd ? ;uInt ;bytes at end of window left to insert
 
if DEBUG eq 1
compressed_len dd ? ;ulg ;total bit length of compressed file mod 2^32
bits_sent dd ? ;ulg ;bit length of compressed data sent mod 2^32
;compressed_len dd ? ;ulg ;total bit length of compressed file mod 2^32
;bits_sent dd ? ;ulg ;bit length of compressed data sent mod 2^32
end if
 
bi_buf dw ? ;uint_16
rb 2 ;for align
; Output buffer. bits are inserted starting at the bottom (least
; significant bits).
 
238,18 → 241,17
 
macro put_byte s, c
{
movzx eax,word[s+deflate_state.pending]
mov eax,[s+deflate_state.pending]
add eax,[s+deflate_state.pending_buf]
mov byte[eax],c
inc word[s+deflate_state.pending]
inc dword[s+deflate_state.pending]
}
macro put_dword s, d
{
zlib_debug '(%d)',d
movzx eax,word[s+deflate_state.pending]
mov eax,[s+deflate_state.pending]
add eax,[s+deflate_state.pending_buf]
mov dword[eax],d
add word[s+deflate_state.pending],4
add dword[s+deflate_state.pending],4
}
 
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
305,8 → 307,7
inc dword[s+deflate_state.last_lit]
and eax,0xff
imul eax,sizeof.ct_data
add eax,s
inc word[eax+deflate_state.dyn_ltree+Freq]
inc word[s+eax+deflate_state.dyn_ltree+Freq]
xor eax,eax
mov ecx,[s+deflate_state.lit_bufsize]
dec ecx
/programs/fs/kfar/trunk/zlib/trees.asm
172,7 → 172,6
align 4
proc send_bits uses eax ecx edi, s:dword, value:dword, length:dword
; Tracevv((stderr," l %2d v %4x ", length, value));
zlib_debug 'send_bits value = %d',[value]
;if DEBUG eq 1
mov eax,[length]
cmp eax,0
183,7 → 182,7
zlib_assert 'invalid length' ;Assert(..>0 && ..<=15)
.end1:
mov edi,[s]
add [edi+deflate_state.bits_sent],eax
;;add [edi+deflate_state.bits_sent],eax
 
; If not enough room in bi_buf, use (valid) bits from bi_buf and
; (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
385,12 → 384,10
; ===========================================================================
; Initialize the tree data structures for a new zlib stream.
 
;void (s)
; deflate_state* s
;void (deflate_state* s)
align 4
proc _tr_init uses eax edi, s:dword
mov edi,[s]
zlib_debug '_tr_init'
call tr_static_init
 
mov eax,edi
421,8 → 418,7
; ===========================================================================
; Initialize a new block.
 
;void (s)
; deflate_state* s
;void (deflate_state* s)
align 4
proc init_block uses eax ecx edi, s:dword
mov edi,[s]
469,12 → 465,12
macro pqremove s, tree, top
{
mov eax,s
add eax,deflate_state.heap+2*SMALLEST
add eax,deflate_state.heap+4*SMALLEST
movzx top,word[eax]
push ebx
mov ebx,[s+deflate_state.heap_len]
mov bx,[s+deflate_state.heap+2*ebx]
mov word[eax],bx
mov ebx,[s+deflate_state.heap+4*ebx]
mov [eax],ebx
dec dword[s+deflate_state.heap_len]
pop ebx
stdcall pqdownheap, s, tree, SMALLEST
488,11 → 484,11
{
;if (..<.. || (..==.. && depth[n] <= depth[m]))
local .end0
movzx eax,n
mov eax,n
imul eax,sizeof.ct_data
add eax,tree
mov ax,word[eax+Freq]
movzx ebx,m
mov ebx,m
imul ebx,sizeof.ct_data
add ebx,tree
mov bx,word[ebx+Freq]
499,9 → 495,9
cmp ax,bx
jl .end0
jne m_end
movzx eax,n
mov eax,n
mov al,byte[eax+depth]
movzx ebx,m
mov ebx,m
cmp al,byte[ebx+depth]
jg m_end
.end0:
523,8 → 519,7
;ecx - v dw
mov edi,[s]
mov esi,[k]
zlib_debug 'pqdownheap k = %d',esi
mov cx,[edi+deflate_state.heap+2*esi]
mov ecx,[edi+deflate_state.heap+4*esi]
shl esi,1
;esi = j ;left son of k
.cycle0: ;while (..<=..)
534,21 → 529,21
;;cmp esi,[edi+deflate_state.heap_len]
jge .end1 ;if (..<.. &&
mov edx,esi
shl edx,1
shl edx,2
add edx,edi
add edx,deflate_state.heap
smaller [tree], word[edx+2], word[edx], edi+deflate_state.depth, .end1
smaller [tree], dword[edx+4], dword[edx], edi+deflate_state.depth, .end1
inc esi
.end1:
; Exit if v is smaller than both sons
mov dx,[edi+deflate_state.heap+2*esi]
smaller [tree], cx, dx, edi+deflate_state.depth, .end2
mov edx,[edi+deflate_state.heap+4*esi]
smaller [tree], ecx, edx, edi+deflate_state.depth, .end2
jmp .cycle0end ;break
.end2:
; Exchange v with the smallest son
;;mov dx,[edi+deflate_state.heap+2*esi]
mov eax,[k]
mov [edi+deflate_state.heap+2*eax],dx
mov [edi+deflate_state.heap+4*eax],edx
mov [k],esi
; And continue down the tree, setting j to the left son of k
shl esi,1
556,7 → 551,7
align 4
.cycle0end:
mov eax,[k]
mov [edi+deflate_state.heap+2*eax],cx
mov [edi+deflate_state.heap+4*eax],ecx
popad
ret
endp
591,7 → 586,6
overflow dd 0 ;int ;number of elements with bit length too large
endl
pushad
zlib_debug 'gen_bitlen'
mov edi,[s]
mov edx,[desc]
mov eax,[edx+tree_desc.dyn_tree]
622,7 → 616,7
; overflow in the case of the bit length tree).
 
mov eax,[edi+deflate_state.heap_max]
movzx eax,word[edi+deflate_state.heap+2*eax]
mov eax,[edi+deflate_state.heap+4*eax]
imul eax,sizeof.ct_data
add eax,[tree]
mov word[eax+Len],0 ;root of the heap
634,7 → 628,7
cmp dword[h],HEAP_SIZE
jge .cycle1end ;for (..;..<..;..)
mov eax,[h]
movzx ecx,word[edi+deflate_state.heap+2*eax]
mov ecx,[edi+deflate_state.heap+4*eax]
;ecx = n
mov eax,sizeof.ct_data
imul eax,ecx
752,7 → 746,7
je .cycle4end
dec dword[h]
mov eax,[h]
movzx eax,word[edi+deflate_state.heap+2*eax]
mov eax,[edi+deflate_state.heap+4*eax]
mov [m],eax ;m = s.heap[--h]
cmp eax,[max_code]
jg .cycle4 ;if (..>..) continue
804,7 → 798,6
endl
; The distribution counts are first used to generate the code values
; without bit reversal.
zlib_debug 'gen_codes'
mov ebx,ebp
sub ebx,2*(MAX_BITS+1)
 
912,7 → 905,7
inc dword[edi+deflate_state.heap_len]
mov eax,[edi+deflate_state.heap_len]
mov [max_code],ecx
mov [edi+deflate_state.heap+2*eax],cx
mov dword[edi+deflate_state.heap+4*eax],ecx
mov byte[edi+deflate_state.depth+ecx],0
jmp .end0
align 4
941,7 → 934,7
mov eax,[max_code]
@@:
mov ecx,[edi+deflate_state.heap_len]
mov [edi+deflate_state.heap+2*ecx],ax
mov [edi+deflate_state.heap+4*ecx],eax
mov [node],eax
imul eax,sizeof.ct_data
add eax,[tree]
989,10 → 982,10
 
mov eax,[edi+deflate_state.heap_max]
dec eax
mov [edi+deflate_state.heap+2*eax],cx ;keep the nodes sorted by frequency
mov [edi+deflate_state.heap+4*eax],ecx ;keep the nodes sorted by frequency
dec eax
mov [edi+deflate_state.heap_max],eax
mov [edi+deflate_state.heap+2*eax],dx
mov [edi+deflate_state.heap+4*eax],edx
 
; Create a new node father of n and m
;;mov edx,[m]
1040,16 → 1033,16
;end if
; and insert the new node in the heap
mov ecx,[node]
mov [edi+deflate_state.heap+2*SMALLEST],cx
mov [edi+deflate_state.heap+4*SMALLEST],ecx
inc dword[node]
stdcall pqdownheap, edi, [tree], SMALLEST
cmp dword[edi+deflate_state.heap_len],2
jge .cycle3 ;while (..>=..)
 
mov cx,[edi+deflate_state.heap+2*SMALLEST]
mov ecx,[edi+deflate_state.heap+4*SMALLEST]
dec dword[edi+deflate_state.heap_max]
mov eax,[edi+deflate_state.heap_max]
mov [edi+deflate_state.heap+2*eax],cx
mov [edi+deflate_state.heap+4*eax],ecx
 
; At this point, the fields freq and dad are set. We can now
; generate the bit lengths.
1083,7 → 1076,6
min_count dd 4 ;int ;min repeat count
endl
mov edi,[s]
zlib_debug 'scan_tree'
mov eax,[tree]
movzx eax,word[eax+Len]
mov [nextlen],eax
1204,7 → 1196,6
min_count dd 4 ;int ;min repeat count
endl
mov edi,[s]
zlib_debug 'send_tree'
; *** tree[max_code+1].Len = -1 ;guard already set
mov eax,[tree]
movzx eax,word[eax+Len]
1214,7 → 1205,6
jnz .cycle0 ;if (..==0)
mov dword[max_count],138
mov dword[min_count],3
 
align 4
.cycle0: ;for (..;..<=..;..)
cmp ecx,[max_code]
1322,8 → 1312,7
; Construct the Huffman tree for the bit lengths and return the index in
; bl_order of the last bit length code to send.
 
;int (s)
; deflate_state* s
;int (deflate_state* s)
align 4
proc build_bl_tree uses edi, s:dword
locals
1385,7 → 1374,6
align 4
proc send_all_trees uses eax ebx ecx edi, s:dword, lcodes:dword, dcodes:dword, blcodes:dword
;ecx = index in bl_order
zlib_debug 'send_all_trees'
cmp dword[lcodes],257
jl @f
cmp dword[dcodes],1
1479,20 → 1467,20
; ===========================================================================
; Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
 
;void (s)
; deflate_state* s
align 4
proc _tr_flush_bits, s:dword
stdcall bi_flush, [s]
ret
endp
;void (deflate_state* s)
;align 4
;proc _tr_flush_bits, s:dword
; stdcall bi_flush, [s]
; ret
;endp
 
_tr_flush_bits equ bi_flush
 
; ===========================================================================
; Send one empty static block to give enough lookahead for inflate.
; This takes 10 bits, of which 7 may remain in the bit buffer.
 
;void (s)
; deflate_state* s
;void (deflate_state* s)
align 4
proc _tr_align uses edi, s:dword
mov edi,[s]
1523,7 → 1511,6
endl
; Build the Huffman trees unless a stored block is forced
mov edi,[s]
zlib_debug '_tr_flush_block'
cmp word[edi+deflate_state.level],0
jle .end0 ;if (..>0)
 
1728,10 → 1715,9
; Try to guess if it is profitable to stop the current block here
mov eax,[edi+deflate_state.last_lit]
and eax,0x1fff
cmp eax,0
jne .end1
jnz .end1
cmp word[edi+deflate_state.level],2
jle .end1 ;if (..==.. && ..>..)
jle .end1 ;if (..==0 && ..>..)
; Compute an upper bound for the compressed length
; ulg out_length = (ulg)s->last_lit*8L;
; ulg in_length = (ulg)((long)s->strstart - s->block_start);
1775,7 → 1761,6
lc dd ? ;int ;match length or unmatched char (if dist == 0)
lx dd 0 ;unsigned ;running index in l_buf
u_code dd ? ;unsigned ;the code to send
extra dd ? ;int ;number of extra bits to send
endl
mov edi,[s]
cmp dword[edi+deflate_state.last_lit],0
1805,18 → 1790,14
add eax,LITERALS+1
send_code edi, eax, [ltree] ;send the length code
mov eax,[u_code]
shl eax,2
add eax,extra_lbits
mov eax,[eax]
mov [extra],eax
cmp eax,0
je @f ;if (..!=0)
mov eax,[4*eax+extra_lbits]
test eax,eax
jz @f ;if (..!=0)
push eax ;extra
mov eax,[u_code]
shl eax,2
add eax,base_length
mov eax,[eax]
mov eax,[4*eax+base_length]
sub [lc],eax
stdcall send_bits, edi, [lc], [extra] ;send the extra length bits
stdcall send_bits, edi, [lc] ;, ... ;send the extra length bits
@@:
dec dword[dist] ;dist is now the match distance - 1
d_code [dist]
1827,18 → 1808,14
@@:
send_code edi, [u_code], [dtree] ;send the distance code
mov eax,[u_code]
shl eax,2
add eax,extra_dbits
mov eax,[eax]
mov [extra],eax
cmp eax,0
je .end1 ;if (..!=0)
mov eax,[4*eax+extra_dbits]
test eax,eax
jz .end1 ;if (..!=0)
push eax ;extra
mov eax,[u_code]
shl eax,2
add eax,base_dist
mov eax,[eax]
mov eax,[4*eax+base_dist]
sub [dist],eax
stdcall send_bits, edi, [dist], [extra] ;send the extra distance bits
stdcall send_bits, edi, [dist] ;, ... ;send the extra distance bits
.end1: ;literal or match pair ?
 
; Check that the overlay between pending_buf and d_buf+l_buf is ok:
1954,7 → 1931,6
; int len ;its bit length
align 4
proc bi_reverse uses ebx, p1code:dword, len:dword
zlib_debug 'bi_reverse'
xor eax,eax
@@: ;do
mov ebx,[p1code]
1998,8 → 1974,7
; ===========================================================================
; Flush the bit buffer and align the output on a byte boundary
 
;void (s)
; deflate_state* s
;void (deflate_state* s)
align 4
proc bi_windup uses eax ecx edi, s:dword
mov edi,[s]
/programs/fs/kfar/trunk/zlib/zlib.asm
26,6 → 26,7
{
local .end_t
local .m_fmt
pushf
jmp .end_t
.m_fmt db fmt,13,10,0
align 4
35,6 → 36,7
else
stdcall str_format_dbg, buf_param,.m_fmt,p1
end if
popf
}
 
include 'zlib.inc'
/programs/fs/kfar/trunk/zlib/zutil.asm
137,14 → 137,23
align 4
proc zmemcpy uses ecx edi esi, dest:dword, source:dword, len:dword
mov ecx,[len]
cmp ecx,0
jle @f
test ecx,ecx
jz .end0
mov edi,[dest]
mov esi,[source]
bt ecx,0 ;кратно 2 ?
jnc @f
rep movsb
jmp .end0
@@:
zlib_debug 'zmemcpy size = %d',ecx
bt ecx,1 ;кратно 4 ?
jnc @f
shr ecx,1
rep movsw
jmp .end0
@@:
shr ecx,2
rep movsd
.end0:
ret
endp