mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-11-25 18:29:36 +03:00
1486 lines
39 KiB
PHP
1486 lines
39 KiB
PHP
; PPMD decoder, ported from C++ sources of 7-Zip (c) Igor Pavlov
|
|
; C++ code is based on Dmitry Shkarin's PPMdH code
|
|
uglobal
|
|
ppmd_decoder.NS2Indx rb 256
|
|
ppmd_decoder.NS2BSIndx rb 256
|
|
ppmd_decoder.HB2Flag rb 256
|
|
ppmd_decoder.Indx2Units rb ppmd_decoder.N_INDEXES
|
|
ppmd_decoder.Units2Indx rb 128
|
|
endg
|
|
|
|
iglobal
|
|
label ppmd_decoder.InitBinEsc word
|
|
dw 0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x5ABC, 0x6632, 0x6051
|
|
ppmd_decoder.ExpEscape db 25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2
|
|
endg
|
|
|
|
init_ppmd:
|
|
; NS2Indx table
|
|
mov edi, ppmd_decoder.NS2Indx
|
|
xor eax, eax
|
|
stosb
|
|
inc eax
|
|
stosb
|
|
inc eax
|
|
stosb
|
|
mov edx, 3-256
|
|
@@:
|
|
lea ecx, [eax-1]
|
|
inc eax
|
|
add edx, ecx
|
|
jc @f
|
|
rep stosb
|
|
jmp @b
|
|
@@:
|
|
sub ecx, edx
|
|
rep stosb
|
|
; NS2BSIndx table
|
|
xor eax, eax
|
|
stosb
|
|
add al, 2
|
|
stosb
|
|
add al, 2
|
|
mov cl, 9
|
|
rep stosb
|
|
add al, 2
|
|
mov cl, 256-11
|
|
rep stosb
|
|
; HB2Flag table
|
|
mov cl, 0x40/4
|
|
xor eax, eax
|
|
rep stosd
|
|
mov al, 8
|
|
mov cl, 0x100-0x40
|
|
rep stosb
|
|
; Indx2Units table
|
|
mov eax, 0x04030201
|
|
stosd
|
|
mov eax, 0x0C0A0806
|
|
stosd
|
|
mov eax, 0x1815120F
|
|
stosd
|
|
mov al, 0x1C
|
|
@@:
|
|
stosb
|
|
add al, 4
|
|
cmp al, 0x80
|
|
jbe @b
|
|
; Units2Indx table
|
|
xor eax, eax
|
|
xor edx, edx
|
|
inc edx
|
|
xor ecx, ecx
|
|
@@:
|
|
cmp [ppmd_decoder.Indx2Units+eax], dl
|
|
adc al, 0
|
|
stosb
|
|
inc edx
|
|
cmp dl, 0x80
|
|
jbe @b
|
|
ret
|
|
|
|
ppmd_decoder:
|
|
virtual at 0
|
|
; base is standard structure
|
|
.outStream rb streamInfo.size
|
|
.inStream dd ?
|
|
|
|
; RangeDecoder data
|
|
.inLen dd ?
|
|
.inPtr dd ?
|
|
.code dd ?
|
|
.range dd ?
|
|
|
|
.outSize dd ? ; number of bytes rest for output
|
|
|
|
; PPMD data
|
|
.order db ?
|
|
.GlueCount db ?
|
|
.bInited db ?
|
|
rb 1
|
|
.usedMemorySize dd ?
|
|
|
|
; CSubAllocator constants
|
|
.N1 = 4
|
|
.N2 = 4
|
|
.N3 = 4
|
|
.N4 = (128+3-1*.N1-2*.N2-3*.N3)/4
|
|
.UNIT_SIZE = 12
|
|
.N_INDEXES = .N1+.N2+.N3+.N4
|
|
.kExtraSize = .UNIT_SIZE*3
|
|
.kMaxMemBlockSize = 0xFFFFFFFF - .kExtraSize
|
|
|
|
; CSubAllocator data
|
|
.HeapStart dd ?
|
|
.LoUnit dd ?
|
|
.HiUnit dd ?
|
|
.pText dd ?
|
|
.UnitsStart dd ?
|
|
.FreeList rd .N_INDEXES
|
|
|
|
; Context constants
|
|
.INT_BITS = 7
|
|
.PERIOD_BITS = 7
|
|
.TOT_BITS = .INT_BITS + .PERIOD_BITS
|
|
.INTERVAL = 1 shl .INT_BITS
|
|
.BIN_SCALE = 1 shl .TOT_BITS
|
|
.MAX_FREQ = 124
|
|
|
|
.kMaxOrderCompress = 32
|
|
.MAX_O = 255
|
|
|
|
; CDecodeInfo (inherits from CInfo) data
|
|
; SEE2_CONTEXT is 4 bytes long
|
|
.SEE2Cont rd 25*16
|
|
.DummySEE2Cont dd ?
|
|
.MinContext dd ?
|
|
.MaxContext dd ?
|
|
.FoundState dd ? ; found next state transition
|
|
.NumMasked dd ?
|
|
.InitEsc dd ?
|
|
.OrderFall dd ?
|
|
.RunLength dd ?
|
|
.InitRL dd ?
|
|
.CharMask rb 256
|
|
.EscCount db ?
|
|
.PrintCount db ?
|
|
.PrevSuccess db ?
|
|
.HiBitsFlag db ?
|
|
.BinSumm rw 128*64
|
|
|
|
.basesize = $
|
|
.Base:
|
|
; rb .kExtraSize + [.usedMemorySize]
|
|
end virtual
|
|
|
|
.init:
|
|
mov eax, [eax+.inStream]
|
|
call fillBuf
|
|
mov esi, [eax+streamInfo.bufPtr]
|
|
mov eax, [eax+streamInfo.bufDataLen]
|
|
sub eax, 5
|
|
jb return.err
|
|
mov [ebp+.inLen], eax
|
|
inc esi
|
|
lodsd
|
|
mov [ebp+.inPtr], esi
|
|
bswap eax
|
|
mov [ebp+.code], eax
|
|
or [ebp+.range], -1
|
|
mov [ebp+.bInited], 1
|
|
call .StartModelRare
|
|
mov eax, ebp
|
|
jmp .mainloop
|
|
|
|
.fillBuf:
|
|
mov ebp, eax
|
|
mov [eax+.outSize], ecx
|
|
cmp [eax+.bInited], 0
|
|
jz .init
|
|
.mainloop:
|
|
sub [ebp+.outSize], 1
|
|
js .mainloopdone
|
|
; cmp edi, 0xde070+0x18
|
|
; jnz @f
|
|
; int3
|
|
;@@:
|
|
call .DecodeSymbol
|
|
jmp .mainloop
|
|
.mainloopdone:
|
|
popad
|
|
ret
|
|
|
|
.GetBinSumm:
|
|
; CInfo::GetBinSumm(ebx=rs, ecx=numStates)
|
|
movzx eax, [ebp+.PrevSuccess]
|
|
movzx edx, [.NS2BSIndx+ecx-1]
|
|
add eax, edx
|
|
mov edx, [ebp+.FoundState]
|
|
movzx edx, byte [edx]
|
|
movzx edx, [.HB2Flag+edx]
|
|
mov [ebp+.HiBitsFlag], dl
|
|
add eax, edx
|
|
movzx edx, byte [ebx]
|
|
movzx edx, [.HB2Flag+edx]
|
|
lea eax, [eax+edx*2]
|
|
mov edx, [ebp+.RunLength]
|
|
shr edx, 26
|
|
and edx, 0x20
|
|
add eax, edx
|
|
movzx edx, byte [ebx+1]
|
|
shl edx, 6
|
|
add eax, edx
|
|
lea ecx, [ebp+.BinSumm+eax*2-2*64]
|
|
ret
|
|
|
|
.StartModelRare:
|
|
; CInfo::StartModelRare(.order)
|
|
mov [ebp+.EscCount], 1
|
|
mov [ebp+.PrintCount], 1
|
|
; N.B.
|
|
; 1. Original code has some handling of [.order]<2, but this handling is incorrect
|
|
; and causes exception (access violation).
|
|
; 2. 7-Zip never generates archives with [.order]<2 due to input preprocessing
|
|
; (for PPMd method in switch -mo=<n> archiver checks that 2 <= n <= 32).
|
|
; 3. If manually created archive says [.order]<2, the exception will be generated
|
|
; in StartModelRare, but it will be handled in Code() resulting in "data error".
|
|
cmp [ebp+.order], 2
|
|
jb return.err
|
|
mov byte [ebp+.DummySEE2Cont+2], .PERIOD_BITS
|
|
|
|
.RestartModelRare:
|
|
; CInfo::RestartModelRare(void)
|
|
push edi
|
|
lea edi, [ebp+.CharMask]
|
|
xor eax, eax
|
|
push 0x40
|
|
pop ecx
|
|
rep stosd
|
|
; CSubAllocator::InitSubAllocator start
|
|
mov [ebp+.GlueCount], al
|
|
lea edi, [ebp+.FreeList]
|
|
mov cl, .N_INDEXES
|
|
rep stosd
|
|
mov ebx, [ebp+.HeapStart]
|
|
mov [ebp+.pText], ebx
|
|
add ebx, [ebp+.usedMemorySize]
|
|
mov [ebp+.HiUnit], ebx
|
|
mov eax, [ebp+.usedMemorySize]
|
|
xor edx, edx
|
|
mov cl, 8*.UNIT_SIZE
|
|
div ecx
|
|
imul eax, 7*.UNIT_SIZE
|
|
sub ebx, eax
|
|
mov [ebp+.LoUnit], ebx
|
|
mov [ebp+.UnitsStart], ebx
|
|
; CSubAllocator::InitSubAllocator end
|
|
pop edi
|
|
movzx eax, [ebp+.order]
|
|
cmp al, 12
|
|
jb @f
|
|
mov al, 12
|
|
@@:
|
|
neg eax
|
|
dec eax
|
|
mov [ebp+.InitRL], eax
|
|
mov [ebp+.RunLength], eax
|
|
call .AllocContext
|
|
mov [ebp+.MinContext], eax
|
|
mov [ebp+.MaxContext], eax
|
|
and dword [eax+8], 0
|
|
mov esi, eax
|
|
movzx edx, [ebp+.order]
|
|
mov [ebp+.OrderFall], edx
|
|
mov dword [eax], 257*10000h+256
|
|
mov ecx, 256/2
|
|
call .AllocUnits
|
|
mov [ebp+.FoundState], eax
|
|
mov [esi+4], eax
|
|
push edi
|
|
mov edi, eax
|
|
xor eax, eax
|
|
mov [ebp+.PrevSuccess], al
|
|
@@:
|
|
stosb
|
|
mov byte [edi], 1
|
|
and dword [edi+1], 0
|
|
add edi, 5
|
|
inc al
|
|
jnz @b
|
|
lea edi, [ebp+.BinSumm]
|
|
push 2
|
|
pop ecx
|
|
.rmr1:
|
|
mov esi, .InitBinEsc
|
|
@@:
|
|
lodsw
|
|
xor edx, edx
|
|
div ecx
|
|
sub eax, .BIN_SCALE
|
|
neg eax
|
|
mov [edi+2*8], ax
|
|
mov [edi+2*16], ax
|
|
mov [edi+2*24], ax
|
|
mov [edi+2*32], ax
|
|
mov [edi+2*40], ax
|
|
mov [edi+2*48], ax
|
|
mov [edi+2*56], ax
|
|
stosw
|
|
cmp esi, .InitBinEsc+2*8
|
|
jb @b
|
|
add edi, 128-16
|
|
inc ecx
|
|
cmp ecx, 128+2
|
|
jb .rmr1
|
|
lea edi, [ebp+.SEE2Cont]
|
|
mov eax, (10 shl (.PERIOD_BITS-4)) + ((.PERIOD_BITS-4) shl 16) + (4 shl 24)
|
|
push 25
|
|
pop edx
|
|
@@:
|
|
push 16
|
|
pop ecx
|
|
rep stosd
|
|
add ax, 5 shl (.PERIOD_BITS-4)
|
|
dec edx
|
|
jnz @b
|
|
pop edi
|
|
ret
|
|
|
|
.CreateSuccessors:
|
|
; CInfo::CreateSuccessors(bool al=skip,STATE* esi=p1)
|
|
push ebx edi
|
|
mov ebx, [ebp+.MinContext] ; ebx=pc
|
|
mov ecx, [ebp+.FoundState]
|
|
mov ecx, [ecx+2] ; ecx=UpBranch
|
|
sub esp, .MAX_O*4 ; esp=ps
|
|
mov edi, esp ; edi=pps
|
|
test al, al
|
|
jnz @f
|
|
mov eax, [ebp+.FoundState]
|
|
stosd
|
|
cmp dword [ebx+8], 0
|
|
jz .csnoloop
|
|
@@:
|
|
test esi, esi
|
|
jz .csloopstart
|
|
mov edx, esi ; edx=p
|
|
mov ebx, [ebx+8]
|
|
jmp .csloopentry
|
|
.csloopstart:
|
|
mov ebx, [ebx+8]
|
|
lea edx, [ebx+2]
|
|
cmp word [ebx], 1
|
|
jz .csloopentry
|
|
mov edx, [ebx+4]
|
|
mov eax, [ebp+.FoundState]
|
|
sub edx, 6
|
|
mov al, [eax]
|
|
@@:
|
|
add edx, 6
|
|
cmp al, [edx]
|
|
jnz @b
|
|
.csloopentry:
|
|
cmp ecx, [edx+2]
|
|
jz @f
|
|
mov ebx, [edx+2]
|
|
jmp .csnoloop
|
|
@@:
|
|
mov [edi], edx
|
|
add edi, 4
|
|
cmp dword [ebx+8], 0
|
|
jnz .csloopstart
|
|
.csnoloop:
|
|
cmp edi, esp
|
|
jz .csr
|
|
push eax
|
|
push eax
|
|
mov al, [ecx]
|
|
mov [esp], al
|
|
add ecx, 1
|
|
mov [esp+2], ecx
|
|
mov ah, [ebx+3]
|
|
cmp word [ebx], 1
|
|
jz .cs2
|
|
mov edx, [ebx+4]
|
|
sub edx, 6
|
|
@@:
|
|
add edx, 6
|
|
cmp [edx], al
|
|
jnz @b
|
|
movzx edx, byte [edx+1]
|
|
sub edx, 1 ; edx=cf
|
|
movzx ecx, word [ebx+2]
|
|
movzx eax, word [ebx]
|
|
sub ecx, eax
|
|
sub ecx, edx ; ecx=s0
|
|
lea eax, [edx+edx]
|
|
cmp eax, ecx
|
|
ja .cs0
|
|
lea eax, [edx*5]
|
|
cmp eax, ecx
|
|
seta ah
|
|
jmp .cs1
|
|
.cs0:
|
|
lea eax, [eax+ecx*2]
|
|
lea eax, [eax+ecx-1]
|
|
add ecx, ecx
|
|
xor edx, edx
|
|
div ecx
|
|
mov ah, al
|
|
.cs1:
|
|
add ah, 1
|
|
.cs2:
|
|
mov [esp+1], ah
|
|
sub edi, 8
|
|
.cs3:
|
|
; PPM_CONTEXT::createChild(this=ebx,pStats=[edi+4],FirstState=esp) begin
|
|
call .AllocContext
|
|
test eax, eax
|
|
jz .csr0
|
|
mov word [eax], 1
|
|
mov dx, [esp]
|
|
mov [eax+2], dx
|
|
mov edx, [esp+2]
|
|
mov [eax+4], edx
|
|
mov [eax+8], ebx
|
|
mov edx, [edi+4]
|
|
mov [edx+2], eax
|
|
; PPM_CONTEXT::createChild end
|
|
mov ebx, eax
|
|
sub edi, 4
|
|
cmp edi, esp
|
|
jnz .cs3
|
|
pop eax eax
|
|
.csr:
|
|
mov eax, ebx
|
|
@@:
|
|
add esp, .MAX_O*4
|
|
pop edi ebx
|
|
ret
|
|
.csr0:
|
|
pop eax eax
|
|
xor eax, eax
|
|
jmp @b
|
|
|
|
; CInfo::UpdateModel(void)
|
|
.UpdateModel:
|
|
mov ebx, [ebp+.FoundState]
|
|
xor esi, esi ; esi=p
|
|
movzx eax, word [ebx]
|
|
mov ebx, [ebx+2] ; ebx=fs.Successor
|
|
push eax
|
|
cmp ah, .MAX_FREQ/4
|
|
jae .um2
|
|
mov eax, [ebp+.MinContext]
|
|
mov eax, [eax+8]
|
|
test eax, eax
|
|
jz .um2
|
|
cmp word [eax], 1
|
|
jz .um1
|
|
push eax
|
|
mov esi, [eax+4]
|
|
mov al, [esp+4]
|
|
cmp al, [esi]
|
|
jz .um0
|
|
@@:
|
|
add esi, 6
|
|
cmp al, [esi]
|
|
jnz @b
|
|
mov al, [esi+1]
|
|
cmp al, [esi-6+1]
|
|
jb @f
|
|
mov eax, [esi]
|
|
xchg [esi-6], eax
|
|
mov [esi], eax
|
|
mov ax, [esi+4]
|
|
xchg [esi-6+4], ax
|
|
mov [esi+4], ax
|
|
sub esi, 6
|
|
@@:
|
|
.um0:
|
|
pop eax
|
|
cmp byte [esi+1], .MAX_FREQ-9
|
|
jae @f
|
|
add byte [esi+1], 2
|
|
add word [eax+2], 2
|
|
@@:
|
|
jmp .um2
|
|
.um1:
|
|
lea esi, [eax+2]
|
|
cmp byte [esi+1], 32
|
|
adc byte [esi+1], 0
|
|
.um2:
|
|
cmp [ebp+.OrderFall], 0
|
|
jnz .um3
|
|
pop eax
|
|
mov al, 1
|
|
call .CreateSuccessors
|
|
mov [ebp+.MinContext], eax
|
|
mov [ebp+.MaxContext], eax
|
|
mov edx, [ebp+.FoundState]
|
|
mov [edx+2], eax
|
|
test eax, eax
|
|
jz .RestartModel
|
|
ret
|
|
.um3:
|
|
mov edx, [ebp+.pText]
|
|
mov al, [esp]
|
|
mov [edx], al
|
|
add edx, 1 ; edx=Successor
|
|
mov [ebp+.pText], edx
|
|
cmp edx, [ebp+.UnitsStart]
|
|
jae .RestartModelPop
|
|
test ebx, ebx
|
|
jz .um4
|
|
cmp ebx, [ebp+.pText]
|
|
ja @f
|
|
push edx
|
|
xor eax, eax
|
|
call .CreateSuccessors
|
|
pop edx
|
|
mov ebx, eax
|
|
test eax, eax
|
|
jz .RestartModelPop
|
|
@@:
|
|
sub [ebp+.OrderFall], 1
|
|
jnz @f
|
|
mov edx, ebx
|
|
xor ecx, ecx
|
|
mov eax, [ebp+.MinContext]
|
|
cmp eax, [ebp+.MaxContext]
|
|
setnz cl
|
|
sub [ebp+.pText], ecx
|
|
@@:
|
|
jmp .um5
|
|
.um4:
|
|
mov eax, [ebp+.FoundState]
|
|
mov [eax+2], edx
|
|
mov ebx, [ebp+.MinContext]
|
|
.um5:
|
|
mov eax, [ebp+.MinContext]
|
|
movzx ecx, word [eax] ; ecx=ns
|
|
movzx eax, word [eax+2]
|
|
sub eax, ecx
|
|
push eax
|
|
movzx eax, byte [esp+5]
|
|
sub eax, 1
|
|
sub [esp], eax ; [esp]=s0
|
|
mov esi, [ebp+.MaxContext] ; ebx=pc
|
|
cmp esi, [ebp+.MinContext]
|
|
jz .um12
|
|
.um6:
|
|
movzx eax, word [esi]
|
|
cmp eax, 1
|
|
jz .um8
|
|
push eax
|
|
shr eax, 1
|
|
jc .um7
|
|
push esi
|
|
mov esi, [esi+4]
|
|
call .ExpandUnits
|
|
pop esi
|
|
mov [esi+4], eax
|
|
test eax, eax
|
|
jz .RestartModelPop3
|
|
.um7:
|
|
pop eax
|
|
add eax, eax
|
|
cmp eax, ecx
|
|
adc word [esi+2], 0
|
|
add eax, eax
|
|
cmp eax, ecx
|
|
ja @f
|
|
lea eax, [eax+eax+1]
|
|
cmp word [esi+2], ax
|
|
ja @f
|
|
add word [esi+2], 2
|
|
@@:
|
|
push edx
|
|
jmp .um9
|
|
.um8:
|
|
push edx ecx
|
|
mov ecx, 1
|
|
call .AllocUnits
|
|
pop ecx
|
|
test eax, eax
|
|
jz .RestartModelPop3
|
|
mov dx, [esi+2]
|
|
mov [eax], dx
|
|
mov edx, [esi+4]
|
|
mov [eax+2], edx
|
|
mov [esi+4], eax
|
|
movzx edx, byte [eax+1]
|
|
add edx, edx
|
|
cmp edx, (.MAX_FREQ/4-1)*2
|
|
jb @f
|
|
mov edx, .MAX_FREQ-4
|
|
@@:
|
|
mov [eax+1], dl
|
|
add edx, [ebp+.InitEsc]
|
|
cmp ecx, 4
|
|
sbb edx, -1
|
|
mov [esi+2], dx
|
|
.um9:
|
|
movzx edx, word [esi+2]
|
|
mov eax, [esp+4]
|
|
push ecx
|
|
lea ecx, [eax+edx] ; ecx=sf
|
|
add edx, 6
|
|
movzx eax, byte [esp+13]
|
|
add eax, eax
|
|
imul eax, edx ; eax=cf
|
|
lea edx, [ecx*3]
|
|
add edx, edx
|
|
cmp eax, edx
|
|
jae .um10
|
|
mov edx, 1
|
|
cmp ecx, eax
|
|
adc edx, 0
|
|
shl ecx, 2
|
|
add eax, 1
|
|
cmp ecx, eax
|
|
adc edx, 0
|
|
add word [esi+2], 3
|
|
jmp .um11
|
|
.um10:
|
|
lea ecx, [ecx*3]
|
|
lea edx, [ecx*3]
|
|
add eax, 1
|
|
push 4
|
|
cmp edx, eax
|
|
adc dword [esp], 0
|
|
add edx, ecx
|
|
cmp edx, eax
|
|
adc dword [esp], 0
|
|
add edx, ecx
|
|
cmp edx, eax
|
|
adc dword [esp], 0
|
|
pop edx
|
|
add [esi+2], dx
|
|
.um11:
|
|
movzx eax, word [esi]
|
|
lea eax, [eax*3]
|
|
add eax, eax
|
|
add eax, [esi+4]
|
|
mov ecx, [esp+4]
|
|
mov [eax+2], ecx
|
|
mov cl, [esp+12]
|
|
mov [eax], cl
|
|
mov [eax+1], dl
|
|
add word [esi], 1
|
|
pop ecx edx
|
|
mov esi, [esi+8]
|
|
cmp esi, [ebp+.MinContext]
|
|
jnz .um6
|
|
.um12:
|
|
pop eax
|
|
pop eax
|
|
mov [ebp+.MinContext], ebx
|
|
mov [ebp+.MaxContext], ebx
|
|
ret
|
|
.RestartModelPop3:
|
|
pop eax
|
|
pop eax
|
|
.RestartModelPop:
|
|
pop eax
|
|
.RestartModel:
|
|
call .RestartModelRare
|
|
mov [ebp+.EscCount], 0
|
|
mov [ebp+.PrintCount], 0xFF
|
|
ret
|
|
|
|
.rescale:
|
|
mov esi, [ebp+.MinContext]
|
|
movzx ecx, word [esi]
|
|
push ecx ; [esp]=OldNS
|
|
sub ecx, 1
|
|
mov ebx, [ebp+.FoundState]
|
|
cmp ebx, [esi+4]
|
|
jz .r1
|
|
.r0:
|
|
mov ax, [ebx]
|
|
xchg [ebx-6], ax
|
|
mov [ebx], ax
|
|
mov eax, [ebx+2]
|
|
xchg [ebx-6+2], eax
|
|
mov [ebx+2], eax
|
|
sub ebx, 6
|
|
cmp ebx, [esi+4]
|
|
jnz .r0
|
|
.r1:
|
|
add byte [ebx+1], 4
|
|
add word [esi+2], 4
|
|
movzx eax, byte [ebx+1]
|
|
movzx edx, word [esi+2]
|
|
sub edx, eax ; edx=EscFreq
|
|
cmp [ebp+.OrderFall], 1
|
|
sbb eax, -1
|
|
shr eax, 1
|
|
mov [ebx+1], al
|
|
mov [esi+2], ax
|
|
.r2:
|
|
add ebx, 6
|
|
movzx eax, byte [ebx+1]
|
|
sub edx, eax
|
|
cmp [ebp+.OrderFall], 1
|
|
sbb eax, -1
|
|
shr eax, 1
|
|
mov [ebx+1], al
|
|
add [esi+2], ax
|
|
cmp al, [ebx-6+1]
|
|
jbe .r3
|
|
push ecx
|
|
push ebx
|
|
push dword [ebx]
|
|
push word [ebx+4]
|
|
@@:
|
|
mov ecx, [ebx-6]
|
|
mov [ebx], ecx
|
|
mov cx, [ebx-6+4]
|
|
mov [ebx+4], cx
|
|
sub ebx, 6
|
|
cmp ebx, [esi+4]
|
|
jz @f
|
|
cmp al, [ebx-6+1]
|
|
ja @b
|
|
@@:
|
|
pop word [ebx+4]
|
|
pop dword [ebx]
|
|
pop ebx
|
|
pop ecx
|
|
.r3:
|
|
sub ecx, 1
|
|
jnz .r2
|
|
cmp byte [ebx+1], 0
|
|
jnz .r4
|
|
@@:
|
|
add ecx, 1
|
|
sub ebx, 6
|
|
cmp byte [ebx+1], 0
|
|
jz @b
|
|
add edx, ecx
|
|
sub word [esi], cx
|
|
cmp word [esi], 1
|
|
jnz .r4
|
|
pop ebx
|
|
mov eax, [esi+4]
|
|
movzx ecx, word [eax+4]
|
|
push ecx
|
|
push dword [eax]
|
|
movzx eax, byte [eax+1]
|
|
@@:
|
|
add eax, 1
|
|
shr eax, 1
|
|
shr edx, 1
|
|
cmp edx, 1
|
|
ja @b
|
|
mov [esp+1], al
|
|
add ebx, 1
|
|
shr ebx, 1
|
|
mov eax, [esi+4]
|
|
call .FreeUnits
|
|
lea ebx, [esi+2]
|
|
mov [ebp+.FoundState], ebx
|
|
pop dword [ebx]
|
|
pop eax
|
|
mov [ebx+4], ax
|
|
ret
|
|
.r4:
|
|
add edx, 1
|
|
shr edx, 1
|
|
add [esi+2], dx
|
|
pop ebx
|
|
add ebx, 1
|
|
shr ebx, 1
|
|
movzx ecx, word [esi]
|
|
add ecx, 1
|
|
shr ecx, 1
|
|
cmp ebx, ecx
|
|
jz @f
|
|
mov eax, [esi+4]
|
|
call .ShrinkUnits
|
|
mov [esi+4], eax
|
|
@@:
|
|
mov eax, [esi+4]
|
|
mov [ebp+.FoundState], eax
|
|
ret
|
|
|
|
.DecodeSymbol:
|
|
; CDecodeInfo::DecodeSymbol
|
|
mov esi, [ebp+.MinContext]
|
|
cmp word [esi], 1
|
|
jz .binsymbol
|
|
; CDecodeInfo::DecodeSymbol1 start
|
|
mov ebx, [esi+4] ; state
|
|
movzx ecx, word [esi+2]
|
|
mov eax, [ebp+.range]
|
|
xor edx, edx
|
|
div ecx
|
|
mov [ebp+.range], eax
|
|
mov ecx, eax
|
|
mov eax, [ebp+.code]
|
|
xor edx, edx
|
|
div ecx
|
|
movzx edx, byte [ebx+1]
|
|
cmp eax, edx
|
|
jae .ds0
|
|
push edx
|
|
add edx, edx
|
|
cmp dx, [esi+2]
|
|
pop edx
|
|
seta [ebp+.PrevSuccess]
|
|
movzx eax, [ebp+.PrevSuccess]
|
|
add [ebp+.RunLength], eax
|
|
xor eax, eax
|
|
call .RangeDecoder.Decode
|
|
mov [ebp+.FoundState], ebx
|
|
add edx, 4
|
|
mov [ebx+1], dl
|
|
add word [esi+2], 4
|
|
cmp edx, .MAX_FREQ
|
|
jbe @f
|
|
call .rescale
|
|
@@:
|
|
jmp .dscmn
|
|
.ds0:
|
|
mov [ebp+.PrevSuccess], 0
|
|
movzx ecx, word [esi]
|
|
sub ecx, 1
|
|
push eax
|
|
.ds1:
|
|
add ebx, 6
|
|
movzx eax, byte [ebx+1]
|
|
add edx, eax
|
|
cmp edx, [esp]
|
|
ja .ds2
|
|
sub ecx, 1
|
|
jnz .ds1
|
|
pop eax
|
|
mov eax, [ebp+.FoundState]
|
|
movzx eax, byte [eax]
|
|
mov al, [.HB2Flag+eax]
|
|
mov [ebp+.HiBitsFlag], al
|
|
mov eax, edx
|
|
movzx edx, word [esi+2]
|
|
sub edx, eax
|
|
call .RangeDecoder.Decode
|
|
mov al, [ebp+.EscCount]
|
|
movzx edx, byte [ebx]
|
|
mov [ebp+.CharMask+edx], al
|
|
movzx ecx, word [esi]
|
|
mov [ebp+.NumMasked], ecx
|
|
sub ecx, 1
|
|
@@:
|
|
sub ebx, 6
|
|
movzx edx, byte [ebx]
|
|
mov [ebp+.CharMask+edx], al
|
|
sub ecx, 1
|
|
jnz @b
|
|
mov [ebp+.FoundState], ecx
|
|
jmp .dscmn
|
|
.ds2:
|
|
pop eax
|
|
mov eax, edx
|
|
movzx edx, byte [ebx+1]
|
|
sub eax, edx
|
|
call .RangeDecoder.Decode
|
|
.update1:
|
|
mov [ebp+.FoundState], ebx
|
|
add byte [ebx+1], 4
|
|
add word [esi+2], 4
|
|
mov al, [ebx+1]
|
|
cmp al, [ebx-6+1]
|
|
jbe @f
|
|
mov eax, [ebx]
|
|
xchg eax, [ebx-6]
|
|
mov [ebx], eax
|
|
mov ax, [ebx+4]
|
|
xchg ax, [ebx-6+4]
|
|
mov [ebx+4], ax
|
|
sub ebx, 6
|
|
mov [ebp+.FoundState], ebx
|
|
cmp byte [ebx+1], .MAX_FREQ
|
|
jbe @f
|
|
call .rescale
|
|
@@:
|
|
jmp .dscmn
|
|
; CDecodeInfo::DecodeSymbol1 end
|
|
.binsymbol:
|
|
; CDecodeInfo::DecodeBinSymbol start
|
|
lea ebx, [esi+2]
|
|
mov ecx, [esi+8]
|
|
movzx ecx, word [ecx]
|
|
call .GetBinSumm
|
|
movzx eax, word [ecx]
|
|
call .RangeDecoder.DecodeBit
|
|
jc .ds3
|
|
mov [ebp+.FoundState], ebx
|
|
cmp byte [ebx+1], 128
|
|
adc byte [ebx+1], 0
|
|
movzx eax, word [ecx]
|
|
add eax, 1 shl (.PERIOD_BITS-2)
|
|
shr eax, .PERIOD_BITS
|
|
sub eax, .INTERVAL
|
|
sub [ecx], ax
|
|
mov [ebp+.PrevSuccess], 1
|
|
add [ebp+.RunLength], 1
|
|
jmp .dscmn
|
|
.ds3:
|
|
movzx eax, word [ecx]
|
|
add eax, 1 shl (.PERIOD_BITS-2)
|
|
shr eax, .PERIOD_BITS
|
|
sub [ecx], ax
|
|
movzx eax, word [ecx]
|
|
shr eax, 10
|
|
movzx eax, [.ExpEscape+eax]
|
|
mov [ebp+.InitEsc], eax
|
|
mov [ebp+.NumMasked], 1
|
|
mov al, [ebp+.EscCount]
|
|
movzx edx, byte [ebx]
|
|
mov [ebp+.CharMask+edx], al
|
|
mov [ebp+.PrevSuccess], 0
|
|
and [ebp+.FoundState], 0
|
|
; CDecodeInfo::DecodeBinSymbol end
|
|
.dscmn:
|
|
cmp [ebp+.FoundState], 0
|
|
jnz .dsfnd
|
|
.ds4:
|
|
add [ebp+.OrderFall], 1
|
|
mov eax, [ebp+.MinContext]
|
|
mov eax, [eax+8]
|
|
test eax, eax
|
|
jz return.err ; no end-of-stream mark
|
|
mov [ebp+.MinContext], eax
|
|
movzx ecx, word [eax]
|
|
sub ecx, [ebp+.NumMasked]
|
|
jz .ds4
|
|
; CDecodeInfo::DecodeSymbol2 start
|
|
call .makeEscFreq2
|
|
push eax
|
|
mov ebx, [esi+4]
|
|
sub ebx, 6
|
|
sub esp, 256*4
|
|
mov esi, esp
|
|
xor eax, eax
|
|
push eax
|
|
@@:
|
|
add ebx, 6
|
|
mov al, [ebx]
|
|
mov al, [ebp+.CharMask+eax]
|
|
cmp al, [ebp+.EscCount]
|
|
jz @b
|
|
mov al, [ebx+1]
|
|
add [esp], eax
|
|
mov [esi], ebx
|
|
add esi, 4
|
|
sub ecx, 1
|
|
jnz @b
|
|
add edx, [esp]
|
|
mov ecx, edx
|
|
mov eax, [ebp+.range]
|
|
xor edx, edx
|
|
div ecx
|
|
mov [ebp+.range], eax
|
|
mov eax, [ebp+.code]
|
|
xor edx, edx
|
|
div [ebp+.range]
|
|
cmp eax, [esp]
|
|
jae .ds5
|
|
pop ecx
|
|
mov esi, esp
|
|
xor ecx, ecx
|
|
@@:
|
|
mov ebx, [esi]
|
|
add esi, 4
|
|
movzx edx, byte [ebx+1]
|
|
add ecx, edx
|
|
cmp eax, ecx
|
|
jae @b
|
|
mov eax, ecx
|
|
movzx edx, byte [ebx+1]
|
|
sub eax, edx
|
|
call .RangeDecoder.Decode
|
|
add esp, 256*4
|
|
pop eax
|
|
mov cl, [eax+2]
|
|
cmp cl, .PERIOD_BITS
|
|
jae @f
|
|
sub byte [eax+3], 1
|
|
jnz @f
|
|
shl word [eax], 1
|
|
mov dl, 3
|
|
shl dl, cl
|
|
mov [eax+3], dl
|
|
add byte [eax+2], 1
|
|
@@:
|
|
.update2:
|
|
mov [ebp+.FoundState], ebx
|
|
add byte [ebx+1], 4
|
|
mov esi, [ebp+.MinContext]
|
|
add word [esi+2], 4
|
|
cmp byte [ebx+1], .MAX_FREQ
|
|
jbe @f
|
|
call .rescale
|
|
@@:
|
|
add [ebp+.EscCount], 1
|
|
mov eax, [ebp+.InitRL]
|
|
mov [ebp+.RunLength], eax
|
|
jmp .dsfnd
|
|
.ds5:
|
|
pop eax
|
|
mov edx, ecx
|
|
sub edx, eax
|
|
call .RangeDecoder.Decode
|
|
mov eax, [ebp+.MinContext]
|
|
movzx eax, word [eax]
|
|
mov ebx, eax
|
|
sub ebx, [ebp+.NumMasked]
|
|
mov [ebp+.NumMasked], eax
|
|
mov esi, esp
|
|
mov al, [ebp+.EscCount]
|
|
@@:
|
|
mov edx, [esi]
|
|
add esi, 4
|
|
movzx edx, byte [edx]
|
|
mov [ebp+.CharMask+edx], al
|
|
sub ebx, 1
|
|
jnz @b
|
|
add esp, 256*4
|
|
pop eax
|
|
add word [eax], cx
|
|
; CDecodeInfo::DecodeSymbol2 end
|
|
cmp [ebp+.FoundState], 0
|
|
jz .ds4
|
|
.dsfnd:
|
|
mov eax, [ebp+.FoundState]
|
|
mov al, [eax]
|
|
stosb
|
|
|
|
.NextContext:
|
|
; CInfo::NextContext(void)
|
|
mov ebx, [ebp+.FoundState]
|
|
mov ebx, [ebx+2]
|
|
cmp [ebp+.OrderFall], 0
|
|
jnz .nc0
|
|
cmp ebx, [ebp+.pText]
|
|
jbe .nc0
|
|
mov [ebp+.MinContext], ebx
|
|
mov [ebp+.MaxContext], ebx
|
|
ret
|
|
.nc0:
|
|
call .UpdateModel
|
|
cmp [ebp+.EscCount], 0
|
|
jz @f
|
|
ret
|
|
@@:
|
|
mov [ebp+.EscCount], 1
|
|
push edi
|
|
lea edi, [ebp+.CharMask]
|
|
mov ecx, 256/4
|
|
xor eax, eax
|
|
rep stosd
|
|
pop edi
|
|
ret
|
|
|
|
.makeEscFreq2:
|
|
; CInfo::makeEscFreq2(ecx=Diff)->{eax->SEE2_CONTEXT,edx=scale}
|
|
mov esi, [ebp+.MinContext]
|
|
cmp word [esi], 256
|
|
jz .mef0
|
|
movzx edx, [.NS2Indx+ecx-1]
|
|
shl edx, 4
|
|
mov eax, [esi+8]
|
|
movzx eax, word [eax]
|
|
sub ax, [esi]
|
|
cmp ecx, eax
|
|
adc edx, 0
|
|
movzx eax, word [esi]
|
|
push edx
|
|
lea edx, [eax*9]
|
|
lea edx, [edx+eax*2]
|
|
movzx eax, word [esi+2]
|
|
cmp eax, edx
|
|
pop edx
|
|
setc al
|
|
movzx eax, al
|
|
lea edx, [edx+eax*2]
|
|
cmp ecx, [ebp+.NumMasked]
|
|
setc al
|
|
lea edx, [edx+eax*4]
|
|
add dl, [ebp+.HiBitsFlag]
|
|
lea eax, [ebp+edx*4+.SEE2Cont]
|
|
movzx edx, word [eax]
|
|
push ecx
|
|
mov cl, [eax+2]
|
|
shr edx, cl
|
|
sub [eax], dx
|
|
pop ecx
|
|
cmp edx, 1
|
|
adc edx, 0
|
|
ret
|
|
.mef0:
|
|
lea eax, [ebp+.DummySEE2Cont]
|
|
mov edx, 1
|
|
ret
|
|
|
|
.RangeDecoder.DecodeBit:
|
|
; CRangeDecoder::DecodeBit(eax=size0,numTotalBits=.TOT_BITS)
|
|
mov edx, [ebp+.range]
|
|
shr edx, .TOT_BITS
|
|
imul eax, edx
|
|
cmp [ebp+.code], eax
|
|
jae .rddb
|
|
mov [ebp+.range], eax
|
|
call .RangeDecoder.Normalize
|
|
clc
|
|
ret
|
|
.rddb:
|
|
sub [ebp+.code], eax
|
|
sub [ebp+.range], eax
|
|
call .RangeDecoder.Normalize
|
|
stc
|
|
ret
|
|
|
|
.RangeDecoder.Decode:
|
|
imul eax, [ebp+.range]
|
|
sub [ebp+.code], eax
|
|
mov eax, [ebp+.range]
|
|
imul eax, edx
|
|
mov [ebp+.range], eax
|
|
.RangeDecoder.Normalize:
|
|
cmp byte [ebp+.range+3], 0
|
|
jz @f
|
|
ret
|
|
@@:
|
|
sub [ebp+.inLen], 1
|
|
js .refill
|
|
.filled:
|
|
shl [ebp+.range], 8
|
|
shl [ebp+.code], 8
|
|
mov eax, [ebp+.inPtr]
|
|
add [ebp+.inPtr], 1
|
|
mov al, [eax]
|
|
mov byte [ebp+.code], al
|
|
jmp .RangeDecoder.Normalize
|
|
.refill:
|
|
mov eax, [ebp+.inStream]
|
|
call fillBuf
|
|
push [eax+streamInfo.bufPtr]
|
|
pop [ebp+.inPtr]
|
|
mov eax, [eax+streamInfo.bufDataLen]
|
|
sub eax, 1
|
|
js return.err
|
|
mov [ebp+.inLen], eax
|
|
jmp .filled
|
|
|
|
.GlueFreeBlocks:
|
|
; CSubAllocator::GlueFreeBlocks, called from AllocUnitsRare
|
|
push eax
|
|
mov [ebp+.GlueCount], 255
|
|
mov edx, [ebp+.HeapStart]
|
|
add edx, [ebp+.usedMemorySize]
|
|
; we need add extra MEM_BLK with Stamp=0
|
|
and word [edx], 0
|
|
add edx, .UNIT_SIZE
|
|
mov eax, [ebp+.LoUnit]
|
|
cmp eax, [ebp+.HiUnit]
|
|
jz @f
|
|
mov byte [eax], 0
|
|
@@:
|
|
mov [edx+4], edx
|
|
mov [edx+8], edx
|
|
push ecx
|
|
xor ecx, ecx
|
|
.gfb1:
|
|
mov eax, [ebp+ecx*4+.FreeList]
|
|
test eax, eax
|
|
jz .gfb2
|
|
push dword [eax]
|
|
pop dword [ebp+ecx*4+.FreeList]
|
|
mov [eax+8], edx
|
|
push edx
|
|
mov edx, [edx+4]
|
|
mov [eax+4], edx
|
|
mov [edx+8], eax
|
|
or word [eax], 0xFFFF
|
|
movzx edx, [.Indx2Units+ecx]
|
|
mov [eax+2], dx
|
|
pop edx
|
|
mov [edx+4], eax
|
|
jmp .gfb1
|
|
.gfb2:
|
|
inc ecx
|
|
cmp ecx, .N_INDEXES
|
|
jb .gfb1
|
|
mov ecx, edx
|
|
.gfb3:
|
|
mov ecx, [ecx+4]
|
|
cmp ecx, edx
|
|
jz .gfb5
|
|
.gfb4:
|
|
movzx eax, word [ecx+2]
|
|
lea eax, [eax*3]
|
|
lea eax, [ecx+eax*4]
|
|
cmp word [eax], 0xFFFF
|
|
jnz .gfb3
|
|
push eax
|
|
mov ax, [eax+2]
|
|
add ax, [ecx+2]
|
|
pop eax
|
|
jc .gfb3
|
|
push edx
|
|
mov edx, [eax+4]
|
|
push dword [eax+8]
|
|
pop dword [edx+8]
|
|
mov edx, [eax+8]
|
|
push dword [eax+4]
|
|
pop dword [edx+4]
|
|
pop edx
|
|
mov ax, [eax+2]
|
|
add [ecx+2], ax
|
|
jmp .gfb4
|
|
.gfb5:
|
|
mov ecx, [edx+4]
|
|
cmp ecx, edx
|
|
jz .gfb8
|
|
mov eax, [ecx+4]
|
|
mov [eax+8], edx
|
|
mov [edx+4], eax
|
|
movzx eax, word [ecx+2]
|
|
push edx
|
|
.gfb6:
|
|
sub eax, 128
|
|
jbe .gfb7
|
|
mov edx, ecx
|
|
xchg edx, [ebp+.FreeList+(.N_INDEXES-1)*4]
|
|
mov [ecx], edx
|
|
add ecx, 128*.UNIT_SIZE
|
|
jmp .gfb6
|
|
.gfb7:
|
|
add eax, 128
|
|
movzx edx, [.Units2Indx+eax-1]
|
|
cmp [.Indx2Units+edx], al
|
|
jz @f
|
|
dec edx
|
|
push edx
|
|
movzx edx, [.Indx2Units+edx]
|
|
sub eax, edx
|
|
lea eax, [ebp+.FreeList+(eax-1)*4]
|
|
lea edx, [edx*3]
|
|
lea edx, [ecx+edx*4]
|
|
push dword [eax]
|
|
pop dword [edx]
|
|
mov [eax], edx
|
|
pop edx
|
|
@@:
|
|
mov eax, ecx
|
|
xchg eax, [ebp+.FreeList+edx*4]
|
|
mov [ecx], eax
|
|
pop edx
|
|
jmp .gfb5
|
|
.gfb8:
|
|
pop ecx
|
|
pop eax
|
|
mov edx, [ebp+.FreeList+eax*4]
|
|
test edx, edx
|
|
jz .aur.cont
|
|
push edx
|
|
mov edx, [edx]
|
|
mov [ebp+.FreeList+eax*4], edx
|
|
pop eax
|
|
ret
|
|
|
|
.AllocContext:
|
|
; CSubAllocator::AllocContext
|
|
mov eax, [ebp+.HiUnit]
|
|
cmp eax, [ebp+.LoUnit]
|
|
jz @f
|
|
sub eax, .UNIT_SIZE
|
|
mov [ebp+.HiUnit], eax
|
|
ret
|
|
@@:
|
|
mov eax, [ebp+.FreeList]
|
|
test eax, eax
|
|
jz @f
|
|
mov edx, [eax]
|
|
mov [ebp+.FreeList], edx
|
|
ret
|
|
@@:
|
|
xor eax, eax
|
|
jmp .AllocUnitsRare
|
|
|
|
.AllocUnits:
|
|
; CSubAllocator::AllocUnits(ecx)
|
|
movzx ecx, [.Units2Indx+ecx-1]
|
|
mov eax, [ebp+.FreeList+ecx*4]
|
|
test eax, eax
|
|
jz @f
|
|
mov edx, [eax]
|
|
mov [ebp+.FreeList+ecx*4], edx
|
|
ret
|
|
@@:
|
|
mov eax, [ebp+.LoUnit]
|
|
movzx edx, [.Indx2Units+ecx]
|
|
lea edx, [edx*3]
|
|
lea eax, [eax+edx*4]
|
|
cmp eax, [ebp+.HiUnit]
|
|
ja @f
|
|
xchg eax, [ebp+.LoUnit]
|
|
ret
|
|
@@:
|
|
mov eax, ecx
|
|
|
|
.AllocUnitsRare:
|
|
; CSubAllocator::AllocUnitsRare(eax)
|
|
cmp [ebp+.GlueCount], 0
|
|
jz .GlueFreeBlocks
|
|
.aur.cont:
|
|
push eax
|
|
.aur1:
|
|
inc eax
|
|
cmp eax, .N_INDEXES
|
|
jz .aur3
|
|
mov edx, [ebp+.FreeList+eax*4]
|
|
test edx, edx
|
|
jz .aur1
|
|
push edx
|
|
mov edx, [edx]
|
|
mov [ebp+.FreeList+eax*4], edx
|
|
call .SplitBlock
|
|
pop eax
|
|
pop edx
|
|
ret
|
|
.aur3:
|
|
dec [ebp+.GlueCount]
|
|
pop eax
|
|
movzx eax, [.Indx2Units+eax]
|
|
lea edx, [eax*3]
|
|
shl edx, 2
|
|
mov eax, [ebp+.UnitsStart]
|
|
sub eax, [ebp+.pText]
|
|
cmp eax, edx
|
|
jbe .aur4
|
|
mov eax, [ebp+.UnitsStart]
|
|
sub eax, edx
|
|
mov [ebp+.UnitsStart], eax
|
|
ret
|
|
.aur4:
|
|
xor eax, eax
|
|
ret
|
|
|
|
.SplitBlock:
|
|
; CSubAllocator::SplitBlock(pv=[esp+4],oldIndx=eax,newIndx=[esp+8])
|
|
push eax
|
|
mov edx, [esp+12]
|
|
movzx eax, [.Indx2Units+eax]
|
|
movzx edx, [.Indx2Units+edx]
|
|
sub eax, edx
|
|
lea edx, [edx*3]
|
|
push ecx
|
|
mov ecx, [esp+12]
|
|
lea ecx, [ecx+edx*4]
|
|
movzx edx, [.Units2Indx+eax-1]
|
|
cmp [.Indx2Units+edx], al
|
|
jz .aur2
|
|
push dword [ebp+.FreeList+(edx-1)*4]
|
|
pop dword [ecx]
|
|
mov [ebp+.FreeList+(edx-1)*4], ecx
|
|
movzx edx, [.Indx2Units+edx-1]
|
|
sub eax, edx
|
|
lea edx, [edx*3]
|
|
lea ecx, [ecx+edx*4]
|
|
.aur2:
|
|
movzx eax, [.Units2Indx+eax-1]
|
|
push dword [ebp+.FreeList+eax*4]
|
|
pop dword [ecx]
|
|
mov [ebp+.FreeList+eax*4], ecx
|
|
pop ecx
|
|
pop eax
|
|
ret
|
|
|
|
.ExpandUnits:
|
|
; CSubAllocator::ExpandUnits(void* oldPtr=esi, int oldNU=eax)
|
|
push edx
|
|
movzx edx, [.Units2Indx + eax - 1]
|
|
cmp dl, [.Units2Indx + eax]
|
|
jnz @f
|
|
pop edx
|
|
mov eax, esi
|
|
ret
|
|
@@:
|
|
push eax ecx edx
|
|
lea ecx, [eax+1]
|
|
call .AllocUnits
|
|
pop edx
|
|
test eax, eax
|
|
jz @f
|
|
push esi edi
|
|
mov edi, eax
|
|
mov ecx, [esp+8+4]
|
|
lea ecx, [ecx*3]
|
|
rep movsd
|
|
pop edi esi
|
|
mov ecx, [ebp+.FreeList+edx*4]
|
|
mov [esi], ecx
|
|
mov [ebp+.FreeList+edx*4], esi
|
|
@@:
|
|
pop ecx
|
|
add esp, 4
|
|
pop edx
|
|
ret
|
|
|
|
.ShrinkUnits:
|
|
; CSubAllocator::ShrinkUnits(void* oldPtr=eax, int oldNU=ebx, int newNU=ecx)
|
|
push ecx
|
|
movzx ebx, [.Units2Indx+ebx-1]
|
|
movzx ecx, [.Units2Indx+ecx-1]
|
|
cmp ebx, ecx
|
|
jnz @f
|
|
pop ecx
|
|
ret
|
|
@@:
|
|
mov edx, [ebp+.FreeList+ecx*4]
|
|
test edx, edx
|
|
jz @f
|
|
push dword [edx]
|
|
pop [ebp+.FreeList+ecx*4]
|
|
pop ecx
|
|
push esi edi
|
|
mov esi, eax
|
|
mov edi, edx
|
|
lea ecx, [ecx*3]
|
|
rep movsd
|
|
pop edi esi
|
|
mov ecx, [ebp+.FreeList+ebx*4]
|
|
mov [eax], ecx
|
|
mov [ebp+.FreeList+ebx*4], eax
|
|
mov eax, edx
|
|
ret
|
|
@@:
|
|
push ecx
|
|
push eax
|
|
mov eax, ebx
|
|
call .SplitBlock
|
|
pop eax
|
|
pop ecx
|
|
pop ecx
|
|
ret
|
|
|
|
.FreeUnits:
|
|
; CSubAllocator::FreeUnits(void* ptr=eax, int oldNU=ebx)
|
|
movzx ebx, [.Units2Indx+ebx-1]
|
|
push [ebp+.FreeList+ebx*4]
|
|
pop dword [eax]
|
|
mov [ebp+.FreeList+ebx*4], eax
|
|
ret
|
|
|
|
ppmd_get_buf_size:
|
|
cmp dword [esi-4], 5
|
|
jb return.err
|
|
lodsb
|
|
lodsd
|
|
cmp eax, ppmd_decoder.kMaxMemBlockSize
|
|
ja return.err
|
|
add eax, ppmd_decoder.basesize + ppmd_decoder.kExtraSize
|
|
mov edx, 0x4000
|
|
ret
|
|
|
|
ppmd_init_decoder:
|
|
mov [ebp+ppmd_decoder.bInited], 0
|
|
; CDecoder::SetDecoderProperties2
|
|
lodsb
|
|
mov [ebp+ppmd_decoder.order], al
|
|
lodsd
|
|
mov [ebp+ppmd_decoder.usedMemorySize], eax
|
|
; CSubAllocator::CSubAllocator
|
|
xor eax, eax
|
|
mov [ebp+ppmd_decoder.GlueCount], al
|
|
lea edi, [ebp+ppmd_decoder.LoUnit]
|
|
mov ecx, (ppmd_decoder.SEE2Cont - ppmd_decoder.LoUnit)/4
|
|
rep stosd
|
|
; CSubAllocator::StartSubAllocator
|
|
lea eax, [ebp+ppmd_decoder.Base+ppmd_decoder.UNIT_SIZE]
|
|
mov [ebp+ppmd_decoder.HeapStart], eax
|
|
mov [ebp+streamInfo.fillBuf], ppmd_decoder.fillBuf
|
|
ret
|