; Deflate and Deflate64 decoders for *.zip and *.7z archives.
; Written by diamond in 2007.
deflate_decoder:
virtual at 0
.outStream rb streamInfo.size
.inStream dd ?
.bDeflate64 db ?
.dl db ?
.bLast db ?
rb 1
.outEnd dd ?
.inLen dd ?
.inPtr dd ?
.continue dd ?
.blockLen dd ?
.lit_len rb 19
rb 1
.lengths rb 288+32
.huff_bl rd 18*2
.huff_dist rd 31*2
.huff_lit rd 287*2
.size = $
end virtual
.fillBuf:
mov ebp, eax
jecxz .nodata
add ecx, edi
mov [ebp+.outEnd], ecx
mov esi, [ebp+.inPtr]
mov dl, [ebp+.dl]
jmp [ebp+.continue]
.nodata:
popad
ret
.block_loop_done:
mov [ebp+.inPtr], esi
mov [ebp+.dl], dl
mov [ebp+.continue], .block_loop
popad
ret
.start:
xor edx, edx
mov [ebp+.inLen], edx
mov [ebp+.bLast], dl
.block_loop:
cmp edi, [ebp+.outEnd]
jae .block_loop_done
cmp [ebp+.bLast], 0
jnz return.err
call .get_bit
setc [ebp+.bLast]
call .get_bit
jc .test_block_fh
call .get_bit
jc .block_dh
.block_stored: ; Stored
xor edx, edx
xor eax, eax
call .get_word
mov ecx, eax
call .get_word
not ax
cmp eax, ecx
jnz return.err
mov [ebp+.blockLen], ecx
.continue_stored:
mov ecx, [ebp+.blockLen]
mov eax, [ebp+.outEnd]
sub eax, edi
cmp eax, ecx
jae @f
mov ecx, eax
@@:
sub [ebp+.blockLen], ecx
.bs_loop:
mov eax, [ebp+.inLen]
test eax, eax
jnz @f
call .refill
mov eax, [ebp+.inLen]
inc eax
mov [ebp+.inLen], eax
@@:
push ecx
sub ecx, eax
sbb eax, eax
and ecx, eax
add ecx, [ebp+.inLen]
sub [ebp+.inLen], ecx
sub [esp], ecx
rep movsb
pop ecx
jnz .bs_loop
cmp [ebp+.blockLen], ecx
jz .block_loop
mov [ebp+.inPtr], esi
mov [ebp+.dl], dl
mov [ebp+.continue], .continue_stored
popad
ret
.test_block_fh:
call .get_bit
jc return.err
.block_fh: ; Fixed Huffman
push edi
lea edi, [ebp+.huff_dist]
lea eax, [edi+8]
xor ecx, ecx
mov cl, 30
@@:
stosd
add eax, 8
loop @b
xor eax, eax
mov cl, 32
@@:
stosd
inc eax
loop @b
lea eax, [edi+8]
mov cl, 126
@@:
stosd
add eax, 8
loop @b
push eax
mov eax, 256
mov cl, 24
@@:
stosd
inc eax
loop @b
pop eax
mov cl, 104
@@:
stosd
add eax, 8
loop @b
push eax
xor eax, eax
mov cl, 144
@@:
stosd
inc eax
loop @b
mov eax, 280
mov cl, 8
@@:
stosd
inc eax
loop @b
pop eax
mov cl, 56
@@:
stosd
add eax, 8
loop @b
mov eax, 144
mov cl, 112
@@:
stosd
inc eax
loop @b
jmp .block_h_start
.block_dh: ; Dynamic Huffman
xor ecx, ecx
mov cl, 5
push edi
lea edi, [ebp+.lit_len]
push edi
xor eax, eax
rep stosd
pop edi
mov cl, 5
call .get_bits
push eax
mov cl, 5
call .get_bits
push eax
mov cl, 4
call .get_bits
lea ecx, [eax+4]
mov ebx, deflate.CodeLengthOrder
iglobal
deflate.CodeLengthOrder:
db 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15
endg
@@:
push ecx
mov cl, 3
call .get_bits
mov cl, [ebx]
inc ebx
mov [edi+ecx], al
pop ecx
loop @b
lea ebx, [ebp+.huff_bl]
mov cl, 19
push 18*8
call .construct_huffman_tree
mov ecx, [esp]
add ecx, [esp+4]
add ecx, 258
lea edi, [ebp+.lengths]
.dhl:
lea ebx, [ebp+.huff_bl]
call .get_huffman_code
cmp eax, 16
jae .dh_special
stosb
loop .dhl
jmp .dhd
.dh_special:
push ecx
sub eax, 16
jnz .dh_norep
push 2
pop ecx
call .get_bits
pop ecx
add eax, 3
sub ecx, eax
jb return.err
@@:
mov bl, [edi-1]
mov [edi], bl
inc edi
dec eax
jnz @b
test ecx, ecx
jnz .dhl
jmp .dhd
.dh_norep:
dec eax
jz .dh_0
dec eax
jnz return.err
push 7
pop ecx
call .get_bits
add eax, 11
jmp @f
.dh_0:
push 3
pop ecx
call .get_bits
add eax, 3
@@:
pop ecx
sub ecx, eax
jb return.err
push ecx
mov ecx, eax
xor eax, eax
rep stosb
pop ecx
test ecx, ecx
jnz .dhl
.dhd:
pop ecx
inc ecx
lea ebx, [ebp+.huff_dist]
pop edi
push edi
lea edi, [edi+ebp+.lengths+257]
push 31*8
call .construct_huffman_tree
pop ecx
add ecx, 257
lea ebx, [ebp+.huff_lit]
lea edi, [ebp+.lengths]
push 287*8
call .construct_huffman_tree
.block_h_start: ; Huffman
pop edi
.block_h:
lea ebx, [ebp+.huff_lit]
call .get_huffman_code
sub eax, 256
jnc .not_char
stosb
.bhc:
cmp edi, [ebp+.outEnd]
jb .block_h
mov [ebp+.inPtr], esi
mov [ebp+.dl], dl
mov [ebp+.continue], .block_h
popad
ret
.not_char:
jz .block_loop
cmp eax, 285-256
ja return.err
jz .h_max
iglobal
deflate.LengthCodesStart:
db 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59
db 67,83,99,115,131,163,195,227
deflate.LengthCodesExtra:
db 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5
endg
movzx ebx, byte [deflate.LengthCodesStart+eax-1]
movzx ecx, byte [deflate.LengthCodesExtra+eax-1]
call .get_bits
add ebx, eax
.length_known:
push ebx
lea ebx, [ebp+.huff_dist]
call .get_huffman_code
cmp eax, 32
jae return.err
iglobal
align 4
deflate.DistCodesStart:
dd 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537
dd 2049,3073,4097,6145,8193,12289,16385,24577,32769,49153
deflate.DistCodesExtra:
db 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14
endg
mov ebx, [deflate.DistCodesStart+eax*4]
movzx ecx, byte [deflate.DistCodesExtra+eax]
call .get_bits
add ebx, eax
pop ecx
; ecx=length, ebx=distance
.repmovsbz:
push esi
.repmovsbr:
mov esi, edi
sub esi, ebx
mov eax, [ebp+streamInfo.bufPtr]
sub eax, esi
ja .repmovsb0
mov eax, [ebp+.outEnd]
sub eax, edi
push ecx
cmp ecx, eax
jb @f
mov ecx, eax
@@:
sub [esp], ecx
rep movsb
pop ecx
jz .repmovsb1
.repmovsbc:
pop [ebp+.inPtr]
mov [ebp+.blockLen], ecx
mov dword [ebp+.lit_len], ebx
mov [ebp+.dl], dl
mov [ebp+.continue], .restart_repmovsb
popad
ret
.repmovsb0:
add esi, 0x10000
push ecx
cmp ecx, eax
jb @f
mov ecx, eax
@@:
mov eax, [ebp+.outEnd]
sub eax, edi
cmp ecx, eax
jb @f
mov ecx, eax
@@:
sub [esp], ecx
rep movsb
pop ecx
jz .repmovsb1
cmp edi, [ebp+.outEnd]
jb .repmovsbr
jmp .repmovsbc
.repmovsb1:
pop esi
jmp .bhc
.restart_repmovsb:
mov ecx, [ebp+.blockLen]
mov ebx, dword [ebp+.lit_len]
jmp .repmovsbz
.h_max:
mov ebx, 258
xor ecx, ecx
cmp [ebp+.bDeflate64], cl
jz .length_known
mov cl, 16
call .get_bits
lea ebx, [eax+3]
jmp .length_known
align 16
.get_bit:
shr dl, 1
jnz .ret
sub [ebp+.inLen], 1
js .gb_refill
@@:
mov dl, [esi]
sub esi, -1
rcr dl, 1
.ret:
ret
.gb_refill:
call .refill
jmp @b
.refill:
push eax
mov eax, [ebp+.inStream]
call fillBuf
mov esi, [eax+streamInfo.bufPtr]
mov eax, [eax+streamInfo.bufDataLen]
dec eax
js return.err
mov [ebp+.inLen], eax
pop eax
ret
.get_bits:
push ebx
mov ebx, ecx
xor eax, eax
jecxz .gbr
@@:
call .get_bit
rcr eax, 1
loop @b
mov cl, 32
sub cl, bl
shr eax, cl
.gbr:
pop ebx
ret
.get_word:
sub [ebp+.inLen], 1
jns @f
call .refill
@@:
lodsb
sub [ebp+.inLen], 1
jns @f
call .refill
@@:
mov ah, [esi]
inc esi
ret
.construct_huffman_tree:
; edi->bit lengths array, ecx=number of items, ebx->tree root, [esp+4]=size of tree
add [esp+4], ebx
push edx esi
xor eax, eax
xor edx, edx
mov dword [ebx], eax
mov dword [ebx+4], eax
.cht1:
cmp al, [edi+edx]
ja @f
mov al, [edi+edx]
@@:
inc edx
cmp edx, ecx
jb .cht1
test eax, eax
jz .chtd
push ecx ; remember number of items
push eax ; remember maximum length
lea eax, [ebx+8]
xor edx, edx
inc edx
push 2
pop ecx
.cht2:
push eax
xor eax, eax
.cht3:
cmp dl, [edi+eax]
jnz @f
dec ecx
js return.err
cmp ebx, [esp+24]
jae return.err
mov [ebx], eax
add ebx, 4
@@:
inc eax
cmp eax, [esp+8]
jnz .cht3
pop eax
jecxz .cht4
push ecx
.cht5:
cmp eax, [esp+24]
jb @f
or eax, -1
@@:
cmp ebx, [esp+24]
jae return.err
mov [ebx], eax
add ebx, 4
cmp eax, -1
jz @f
add eax, 8
@@:
loop .cht5
pop ecx
add ecx, ecx
.cht4:
inc edx
cmp edx, [esp]
jbe .cht2
pop eax
pop eax
jecxz .chtd
or eax, -1
@@:
cmp ebx, [esp+12]
jae .chtd
mov [ebx], eax
add ebx, 4
loop @b
.chtd:
pop esi edx
ret 4
.get_huffman_code:
; ebx->tree root
xor eax, eax
cmp dword [ebx+4], eax
jz .ghcret
@@:
call .get_bit
setc al
mov ebx, [ebx+4*eax]
cmp ebx, -1
jz @f
cmp ebx, 0x1000
jae @b
@@:
mov eax, ebx
.ghcret:
ret
deflate_get_buf_size:
mov eax, deflate_decoder.size
mov edx, 0x10000
ret
deflate_init_decoder:
mov [ebp+deflate_decoder.bDeflate64], 0
jmp @f
deflate64_init_decoder:
mov [ebp+deflate_decoder.bDeflate64], 1
@@:
mov [ebp+streamInfo.fillBuf], deflate_decoder.fillBuf
mov [ebp+deflate_decoder.continue], deflate_decoder.start
ret