| 0,0 → 1,504 |
|---|
| ; void __stdcall unpack(void* packed_data, void* unpacked_data); |
| unpack: |
| pushad |
| mov esi, [esp+32+4] |
| mov edi, [esp+32+8] |
| mov eax, [esi+8] |
| and al, 0xC0 |
| cmp al, 0xC0 |
| jz .failed |
| mov eax, [esi+8] |
| push eax |
| add esi, 12 |
| and al, not 0xC0 |
| dec eax |
| jz .lzma |
| .failed: |
| pop eax |
| popad |
| ret 8 |
| .lzma: |
| call .lzma_unpack |
| .common: |
| pop eax |
| test al, 0x80 |
| jnz .ctr1 |
| test al, 0x40 |
| jz .ok |
| lodsd |
| mov ecx, eax |
| jecxz .ok |
| mov dl, [esi] |
| mov esi, [esp+32+8] |
| .c1: |
| lodsb |
| sub al, 0E8h |
| cmp al, 1 |
| ja .c1 |
| cmp byte [esi], dl |
| jnz .c1 |
| lodsd |
| ; "bswap eax" is not supported on i386 |
| shr ax, 8 |
| ror eax, 16 |
| xchg al, ah |
| sub eax, esi |
| add eax, [esp+32+8] |
| mov [esi-4], eax |
| loop .c1 |
| .ok: |
| popad |
| ret 8 |
| .ctr1: |
| lodsd |
| mov ecx, eax |
| jecxz .ok |
| mov dl, [esi] |
| mov esi, [esp+32+8] |
| .c2: |
| lodsb |
| @@: |
| cmp al, 0xF |
| jnz .f |
| lodsb |
| cmp al, 80h |
| jb @b |
| cmp al, 90h |
| jb @f |
| .f: |
| sub al, 0E8h |
| cmp al, 1 |
| ja .c2 |
| @@: |
| cmp byte [esi], dl |
| jnz .c2 |
| lodsd |
| shr ax, 8 |
| ror eax, 16 |
| xchg al, ah |
| sub eax, esi |
| add eax, [esp+32+8] |
| mov [esi-4], eax |
| loop .c2 |
| jmp .ok |
| |
| .lzma_unpack: |
| |
| .pb = 2 ; pos state bits |
| .lp = 0 ; literal pos state bits |
| .lc = 3 ; literal context bits |
| .posStateMask = ((1 shl .pb)-1) |
| .literalPosMask = ((1 shl .lp)-1) |
| |
| .kNumPosBitsMax = 4 |
| .kNumPosStatesMax = (1 shl .kNumPosBitsMax) |
| |
| .kLenNumLowBits = 3 |
| .kLenNumLowSymbols = (1 shl .kLenNumLowBits) |
| .kLenNumMidBits = 3 |
| .kLenNumMidSymbols = (1 shl .kLenNumMidBits) |
| .kLenNumHighBits = 8 |
| .kLenNumHighSymbols = (1 shl .kLenNumHighBits) |
| |
| .LenChoice = 0 |
| .LenChoice2 = 1 |
| .LenLow = 2 |
| .LenMid = (.LenLow + (.kNumPosStatesMax shl .kLenNumLowBits)) |
| .LenHigh = (.LenMid + (.kNumPosStatesMax shl .kLenNumMidBits)) |
| .kNumLenProbs = (.LenHigh + .kLenNumHighSymbols) |
| |
| .kNumStates = 12 |
| .kNumLitStates = 7 |
| .kStartPosModelIndex = 4 |
| .kEndPosModelIndex = 14 |
| .kNumFullDistances = (1 shl (.kEndPosModelIndex/2)) |
| .kNumPosSlotBits = 6 |
| .kNumLenToPosStates = 4 |
| .kNumAlignBits = 4 |
| .kAlignTableSize = (1 shl .kNumAlignBits) |
| .kMatchMinLen = 2 |
| |
| .IsMatch = 0 |
| .IsRep = (.IsMatch + (.kNumStates shl .kNumPosBitsMax)) |
| .IsRepG0 = (.IsRep + .kNumStates) |
| .IsRepG1 = (.IsRepG0 + .kNumStates) |
| .IsRepG2 = (.IsRepG1 + .kNumStates) |
| .IsRep0Long = (.IsRepG2 + .kNumStates) |
| .PosSlot = (.IsRep0Long + (.kNumStates shl .kNumPosBitsMax)) |
| .SpecPos = (.PosSlot + (.kNumLenToPosStates shl .kNumPosSlotBits)) |
| .Align_ = (.SpecPos + .kNumFullDistances - .kEndPosModelIndex) |
| .Lencoder = (.Align_ + .kAlignTableSize) |
| .RepLencoder = (.Lencoder + .kNumLenProbs) |
| .Literal = (.RepLencoder + .kNumLenProbs) |
| |
| .LZMA_BASE_SIZE = 1846 ; must be ==Literal |
| .LZMA_LIT_SIZE = 768 |
| |
| .kNumTopBits = 24 |
| .kTopValue = (1 shl .kNumTopBits) |
| |
| .kNumBitModelTotalBits = 11 |
| .kBitModelTotal = (1 shl .kNumBitModelTotalBits) |
| .kNumMoveBits = 5 |
| |
| push edi |
| ; int state=0; |
| xor ebx, ebx |
| mov [.previousByte], bl |
| ; unsigned rep0=1,rep1=1,rep2=1,rep3=1; |
| mov eax, 1 |
| mov edi, .rep0 |
| stosd |
| stosd |
| stosd |
| stosd |
| ; int len=0; |
| ; result=0; |
| mov ecx, .Literal + (.LZMA_LIT_SIZE shl (.lc+.lp)) |
| mov eax, .kBitModelTotal/2 |
| mov edi, .p |
| rep stosd |
| ; RangeDecoderInit |
| ; rd->ExtraBytes = 0 |
| ; rd->Buffer = stream |
| ; rd->BufferLim = stream+bufferSize |
| ; rd->Range = 0xFFFFFFFF |
| pop edi |
| mov ebp, [esi-8] ; dest_length |
| add ebp, edi ; ebp = destination limit |
| lodsd |
| ; rd->code_ = eax |
| mov [.code_], eax |
| or [.range], -1 |
| .main_loop: |
| cmp edi, ebp |
| jae .main_loop_done |
| mov edx, edi |
| and edx, .posStateMask |
| mov eax, ebx |
| shl eax, .kNumPosBitsMax+2 |
| lea eax, [.p + .IsMatch*4 + eax + edx*4] |
| call .RangeDecoderBitDecode |
| jc .1 |
| movzx eax, [.previousByte] |
| if .literalPosMask |
| mov ah, dl |
| and ah, .literalPosMask |
| end if |
| shr eax, 8-.lc |
| imul eax, .LZMA_LIT_SIZE*4 |
| add eax, .p+.Literal*4 |
| cmp ebx, .kNumLitStates |
| jb .literal |
| xor edx, edx |
| sub edx, [.rep0] |
| mov dl, [edi + edx] |
| call .LzmaLiteralDecodeMatch |
| jmp @f |
| .literal: |
| call .LzmaLiteralDecode |
| @@: |
| mov [.previousByte], al |
| stosb |
| mov al, bl |
| cmp bl, 4 |
| jb @f |
| mov al, 3 |
| cmp bl, 10 |
| jb @f |
| mov al, 6 |
| @@: sub bl, al |
| jmp .main_loop |
| .1: |
| lea eax, [.p + .IsRep*4 + ebx*4] |
| call .RangeDecoderBitDecode |
| jnc .10 |
| lea eax, [.p + .IsRepG0*4 + ebx*4] |
| call .RangeDecoderBitDecode |
| jc .111 |
| mov eax, ebx |
| shl eax, .kNumPosBitsMax+2 |
| lea eax, [.p + .IsRep0Long*4 + eax + edx*4] |
| call .RangeDecoderBitDecode |
| jc .1101 |
| cmp bl, 7 |
| setae bl |
| lea ebx, [9 + ebx + ebx] |
| xor edx, edx |
| sub edx, [.rep0] |
| mov al, [edi + edx] |
| stosb |
| mov [.previousByte], al |
| jmp .main_loop |
| .111: |
| lea eax, [.p + .IsRepG1*4 + ebx*4] |
| call .RangeDecoderBitDecode |
| mov eax, [.rep1] |
| jnc .l3 |
| .l1: |
| lea eax, [.p + .IsRepG2*4 + ebx*4] |
| call .RangeDecoderBitDecode |
| mov eax, [.rep2] |
| jnc .l2 |
| xchg [.rep3], eax |
| .l2: |
| push [.rep1] |
| pop [.rep2] |
| .l3: |
| xchg eax, [.rep0] |
| mov [.rep1], eax |
| .1101: |
| mov eax, .p + .RepLencoder*4 |
| call .LzmaLenDecode |
| cmp bl, 7 |
| setc bl |
| adc bl, bl |
| xor bl, 3 |
| add bl, 8 |
| jmp .repmovsb |
| .10: |
| mov eax, [.rep0] |
| xchg eax, [.rep1] |
| xchg eax, [.rep2] |
| xchg eax, [.rep3] |
| cmp bl, 7 |
| setc bl |
| adc bl, bl |
| xor bl, 3 |
| add bl, 7 |
| mov eax, .p + .Lencoder*4 |
| call .LzmaLenDecode |
| mov eax, .kNumLenToPosStates-1 |
| cmp eax, ecx |
| jb @f |
| mov eax, ecx |
| @@: |
| push ecx |
| mov ecx, .kNumPosSlotBits |
| shl eax, cl |
| shl eax, 2 |
| add eax, .p+.PosSlot*4 |
| call .RangeDecoderBitTreeDecode |
| mov [.rep0], ecx |
| cmp ecx, .kStartPosModelIndex |
| jb .l6 |
| push ecx |
| mov eax, ecx |
| and eax, 1 |
| shr ecx, 1 |
| or eax, 2 |
| dec ecx |
| shl eax, cl |
| mov [.rep0], eax |
| pop edx |
| cmp edx, .kEndPosModelIndex |
| jae .l5 |
| sub eax, edx |
| shl eax, 2 |
| add eax, .p + (.SpecPos - 1)*4 |
| call .RangeDecoderReverseBitTreeDecode |
| add [.rep0], ecx |
| jmp .l6 |
| .l5: |
| sub ecx, .kNumAlignBits |
| call .RangeDecoderDecodeDirectBits |
| mov ecx, .kNumAlignBits |
| shl eax, cl |
| add [.rep0], eax |
| mov eax, .p+.Align_*4 |
| call .RangeDecoderReverseBitTreeDecode |
| add [.rep0], ecx |
| .l6: |
| pop ecx |
| inc [.rep0] |
| jz .main_loop_done |
| .repmovsb: |
| add ecx, .kMatchMinLen |
| push esi |
| mov esi, edi |
| sub esi, [.rep0] |
| rep movsb |
| pop esi |
| mov al, [edi-1] |
| mov [.previousByte], al |
| jmp .main_loop |
| .main_loop_done: |
| ret |
| |
| .RangeDecoderBitDecode: |
| ; in: eax->prob |
| ; out: CF=bit; destroys eax |
| push edx |
| mov edx, [.range] |
| shr edx, .kNumBitModelTotalBits |
| imul edx, [eax] |
| cmp [.code_], edx |
| jae .ae |
| mov [.range], edx |
| mov edx, .kBitModelTotal |
| sub edx, [eax] |
| shr edx, .kNumMoveBits |
| add [eax], edx |
| clc |
| .n: |
| lahf |
| cmp [.range], .kTopValue |
| jae @f |
| shl [.range], 8 |
| shl [.code_], 8 |
| lodsb |
| mov byte [.code_], al |
| @@: |
| sahf |
| pop edx |
| ret |
| .ae: |
| sub [.range], edx |
| sub [.code_], edx |
| mov edx, [eax] |
| shr edx, .kNumMoveBits |
| sub [eax], edx |
| stc |
| jmp .n |
| |
| .RangeDecoderDecodeDirectBits: |
| ; in: ecx=numTotalBits |
| ; out: eax=result; destroys edx |
| xor eax, eax |
| .l: |
| shr [.range], 1 |
| shl eax, 1 |
| mov edx, [.code_] |
| sub edx, [.range] |
| jb @f |
| mov [.code_], edx |
| or eax, 1 |
| @@: |
| cmp [.range], .kTopValue |
| jae @f |
| shl [.range], 8 |
| shl [.code_], 8 |
| push eax |
| lodsb |
| mov byte [.code_], al |
| pop eax |
| @@: |
| loop .l |
| ret |
| |
| .LzmaLiteralDecode: |
| ; in: eax->probs |
| ; out: al=byte; destroys edx |
| push ecx |
| mov ecx, 1 |
| @@: |
| push eax |
| lea eax, [eax+ecx*4] |
| call .RangeDecoderBitDecode |
| pop eax |
| adc cl, cl |
| jnc @b |
| .LzmaLiteralDecode.ret: |
| mov al, cl |
| pop ecx |
| ret |
| .LzmaLiteralDecodeMatch: |
| ; in: eax->probs, dl=matchByte |
| ; out: al=byte; destroys edx |
| push ecx |
| mov ecx, 1 |
| .LzmaLiteralDecodeMatch.1: |
| add dl, dl |
| setc ch |
| push eax |
| lea eax, [eax+ecx*4+0x100*4] |
| call .RangeDecoderBitDecode |
| pop eax |
| adc cl, cl |
| jc .LzmaLiteralDecode.ret |
| xor ch, cl |
| test ch, 1 |
| mov ch, 0 |
| jnz @b |
| jmp .LzmaLiteralDecodeMatch.1 |
| |
| .LzmaLenDecode: |
| ; in: eax->prob, edx=posState |
| ; out: ecx=len |
| push eax |
| add eax, .LenChoice*4 |
| call .RangeDecoderBitDecode |
| pop eax |
| jnc .0 |
| push eax |
| add eax, .LenChoice2*4 |
| call .RangeDecoderBitDecode |
| pop eax |
| jc @f |
| mov ecx, .kLenNumMidBits |
| shl edx, cl |
| lea eax, [eax + .LenMid*4 + edx*4] |
| call .RangeDecoderBitTreeDecode |
| add ecx, .kLenNumLowSymbols |
| ret |
| @@: |
| add eax, .LenHigh*4 |
| mov ecx, .kLenNumHighBits |
| call .RangeDecoderBitTreeDecode |
| add ecx, .kLenNumLowSymbols + .kLenNumMidSymbols |
| ret |
| .0: |
| mov ecx, .kLenNumLowBits |
| shl edx, cl |
| lea eax, [eax + .LenLow*4 + edx*4] |
| .RangeDecoderBitTreeDecode: |
| ; in: eax->probs,ecx=numLevels |
| ; out: ecx=length; destroys edx |
| push ebx |
| mov edx, 1 |
| mov ebx, edx |
| @@: |
| push eax |
| lea eax, [eax+edx*4] |
| call .RangeDecoderBitDecode |
| pop eax |
| adc dl, dl |
| add bl, bl |
| loop @b |
| sub dl, bl |
| pop ebx |
| mov ecx, edx |
| ret |
| .RangeDecoderReverseBitTreeDecode: |
| ; in: eax->probs,ecx=numLevels |
| ; out: ecx=length; destroys edx |
| push ebx ecx |
| mov edx, 1 |
| xor ebx, ebx |
| @@: |
| push eax |
| lea eax, [eax+edx*4] |
| call .RangeDecoderBitDecode |
| lahf |
| adc edx, edx |
| sahf |
| rcr ebx, 1 |
| pop eax |
| loop @b |
| pop ecx |
| rol ebx, cl |
| mov ecx, ebx |
| pop ebx |
| ret |
| |
| uglobal |
| align 4 |
| unpack.p rd unpack.LZMA_BASE_SIZE + (unpack.LZMA_LIT_SIZE shl (unpack.lc+unpack.lp)) |
| unpack.code_ dd ? |
| unpack.range dd ? |
| unpack.rep0 dd ? |
| unpack.rep1 dd ? |
| unpack.rep2 dd ? |
| unpack.rep3 dd ? |
| unpack.previousByte db ? |
| endg |
| Property changes: |
|---|
| Added: svn:executable |
|---|
| +* |
|---|
| \ No newline at end of property |
|---|