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