WebSVN – Kolibri OS – Diff – /kernel/trunk/unpacker.inc


$Revision: 431 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; 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

Rev 425	Rev 431
1	$Revision: 425 $	1	$Revision: 431 $
-		2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		3	;; ;;
-		4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
-		5	;; Distributed under terms of the GNU General Public License ;;
-		6	;; ;;
-		7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		8
2	; void __stdcall unpack(void* packed_data, void* unpacked_data);	9	; void __stdcall unpack(void* packed_data, void* unpacked_data);
3	unpack:	10	unpack:
4	pushad	11	pushad
5	mov esi, [esp+32+4]	12	mov esi, [esp+32+4]
6	mov edi, [esp+32+8]	13	mov edi, [esp+32+8]
7	mov eax, [esi+8]	14	mov eax, [esi+8]
8	and al, 0xC0	15	and al, 0xC0
9	cmp al, 0xC0	16	cmp al, 0xC0
10	jz .failed	17	jz .failed
11	mov eax, [esi+8]	18	mov eax, [esi+8]
12	push eax	19	push eax
13	add esi, 12	20	add esi, 12
14	and al, not 0xC0	21	and al, not 0xC0
15	dec eax	22	dec eax
16	jz .lzma	23	jz .lzma
17	.failed:	24	.failed:
18	pop eax	25	pop eax
19	popad	26	popad
20	ret 8	27	ret 8
21	.lzma:	28	.lzma:
22	call .lzma_unpack	29	call .lzma_unpack
23	.common:	30	.common:
24	pop eax	31	pop eax
25	test al, 0x80	32	test al, 0x80
26	jnz .ctr1	33	jnz .ctr1
27	test al, 0x40	34	test al, 0x40
28	jz .ok	35	jz .ok
29	lodsd	36	lodsd
30	mov ecx, eax	37	mov ecx, eax
31	jecxz .ok	38	jecxz .ok
32	mov dl, [esi]	39	mov dl, [esi]
33	mov esi, [esp+32+8]	40	mov esi, [esp+32+8]
34	.c1:	41	.c1:
35	lodsb	42	lodsb
36	sub al, 0E8h	43	sub al, 0E8h
37	cmp al, 1	44	cmp al, 1
38	ja .c1	45	ja .c1
39	cmp byte [esi], dl	46	cmp byte [esi], dl
40	jnz .c1	47	jnz .c1
41	lodsd	48	lodsd
42	; "bswap eax" is not supported on i386	49	; "bswap eax" is not supported on i386
43	shr ax, 8	50	shr ax, 8
44	ror eax, 16	51	ror eax, 16
45	xchg al, ah	52	xchg al, ah
46	sub eax, esi	53	sub eax, esi
47	add eax, [esp+32+8]	54	add eax, [esp+32+8]
48	mov [esi-4], eax	55	mov [esi-4], eax
49	loop .c1	56	loop .c1
50	.ok:	57	.ok:
51	popad	58	popad
52	ret 8	59	ret 8
53	.ctr1:	60	.ctr1:
54	lodsd	61	lodsd
55	mov ecx, eax	62	mov ecx, eax
56	jecxz .ok	63	jecxz .ok
57	mov dl, [esi]	64	mov dl, [esi]
58	mov esi, [esp+32+8]	65	mov esi, [esp+32+8]
59	.c2:	66	.c2:
60	lodsb	67	lodsb
61	@@:	68	@@:
62	cmp al, 0xF	69	cmp al, 0xF
63	jnz .f	70	jnz .f
64	lodsb	71	lodsb
65	cmp al, 80h	72	cmp al, 80h
66	jb @b	73	jb @b
67	cmp al, 90h	74	cmp al, 90h
68	jb @f	75	jb @f
69	.f:	76	.f:
70	sub al, 0E8h	77	sub al, 0E8h
71	cmp al, 1	78	cmp al, 1
72	ja .c2	79	ja .c2
73	@@:	80	@@:
74	cmp byte [esi], dl	81	cmp byte [esi], dl
75	jnz .c2	82	jnz .c2
76	lodsd	83	lodsd
77	shr ax, 8	84	shr ax, 8
78	ror eax, 16	85	ror eax, 16
79	xchg al, ah	86	xchg al, ah
80	sub eax, esi	87	sub eax, esi
81	add eax, [esp+32+8]	88	add eax, [esp+32+8]
82	mov [esi-4], eax	89	mov [esi-4], eax
83	loop .c2	90	loop .c2
84	jmp .ok	91	jmp .ok
85		92
86	.lzma_unpack:	93	.lzma_unpack:
87		94
88	.pb = 2 ; pos state bits	95	.pb = 2 ; pos state bits
89	.lp = 0 ; literal pos state bits	96	.lp = 0 ; literal pos state bits
90	.lc = 3 ; literal context bits	97	.lc = 3 ; literal context bits
91	.posStateMask = ((1 shl .pb)-1)	98	.posStateMask = ((1 shl .pb)-1)
92	.literalPosMask = ((1 shl .lp)-1)	99	.literalPosMask = ((1 shl .lp)-1)
93		100
94	.kNumPosBitsMax = 4	101	.kNumPosBitsMax = 4
95	.kNumPosStatesMax = (1 shl .kNumPosBitsMax)	102	.kNumPosStatesMax = (1 shl .kNumPosBitsMax)
96		103
97	.kLenNumLowBits = 3	104	.kLenNumLowBits = 3
98	.kLenNumLowSymbols = (1 shl .kLenNumLowBits)	105	.kLenNumLowSymbols = (1 shl .kLenNumLowBits)
99	.kLenNumMidBits = 3	106	.kLenNumMidBits = 3
100	.kLenNumMidSymbols = (1 shl .kLenNumMidBits)	107	.kLenNumMidSymbols = (1 shl .kLenNumMidBits)
101	.kLenNumHighBits = 8	108	.kLenNumHighBits = 8
102	.kLenNumHighSymbols = (1 shl .kLenNumHighBits)	109	.kLenNumHighSymbols = (1 shl .kLenNumHighBits)
103		110
104	.LenChoice = 0	111	.LenChoice = 0
105	.LenChoice2 = 1	112	.LenChoice2 = 1
106	.LenLow = 2	113	.LenLow = 2
107	.LenMid = (.LenLow + (.kNumPosStatesMax shl .kLenNumLowBits))	114	.LenMid = (.LenLow + (.kNumPosStatesMax shl .kLenNumLowBits))
108	.LenHigh = (.LenMid + (.kNumPosStatesMax shl .kLenNumMidBits))	115	.LenHigh = (.LenMid + (.kNumPosStatesMax shl .kLenNumMidBits))
109	.kNumLenProbs = (.LenHigh + .kLenNumHighSymbols)	116	.kNumLenProbs = (.LenHigh + .kLenNumHighSymbols)
110		117
111	.kNumStates = 12	118	.kNumStates = 12
112	.kNumLitStates = 7	119	.kNumLitStates = 7
113	.kStartPosModelIndex = 4	120	.kStartPosModelIndex = 4
114	.kEndPosModelIndex = 14	121	.kEndPosModelIndex = 14
115	.kNumFullDistances = (1 shl (.kEndPosModelIndex/2))	122	.kNumFullDistances = (1 shl (.kEndPosModelIndex/2))
116	.kNumPosSlotBits = 6	123	.kNumPosSlotBits = 6
117	.kNumLenToPosStates = 4	124	.kNumLenToPosStates = 4
118	.kNumAlignBits = 4	125	.kNumAlignBits = 4
119	.kAlignTableSize = (1 shl .kNumAlignBits)	126	.kAlignTableSize = (1 shl .kNumAlignBits)
120	.kMatchMinLen = 2	127	.kMatchMinLen = 2
121		128
122	.IsMatch = 0	129	.IsMatch = 0
123	.IsRep = (.IsMatch + (.kNumStates shl .kNumPosBitsMax))	130	.IsRep = (.IsMatch + (.kNumStates shl .kNumPosBitsMax))
124	.IsRepG0 = (.IsRep + .kNumStates)	131	.IsRepG0 = (.IsRep + .kNumStates)
125	.IsRepG1 = (.IsRepG0 + .kNumStates)	132	.IsRepG1 = (.IsRepG0 + .kNumStates)
126	.IsRepG2 = (.IsRepG1 + .kNumStates)	133	.IsRepG2 = (.IsRepG1 + .kNumStates)
127	.IsRep0Long = (.IsRepG2 + .kNumStates)	134	.IsRep0Long = (.IsRepG2 + .kNumStates)
128	.PosSlot = (.IsRep0Long + (.kNumStates shl .kNumPosBitsMax))	135	.PosSlot = (.IsRep0Long + (.kNumStates shl .kNumPosBitsMax))
129	.SpecPos = (.PosSlot + (.kNumLenToPosStates shl .kNumPosSlotBits))	136	.SpecPos = (.PosSlot + (.kNumLenToPosStates shl .kNumPosSlotBits))
130	.Align_ = (.SpecPos + .kNumFullDistances - .kEndPosModelIndex)	137	.Align_ = (.SpecPos + .kNumFullDistances - .kEndPosModelIndex)
131	.Lencoder = (.Align_ + .kAlignTableSize)	138	.Lencoder = (.Align_ + .kAlignTableSize)
132	.RepLencoder = (.Lencoder + .kNumLenProbs)	139	.RepLencoder = (.Lencoder + .kNumLenProbs)
133	.Literal = (.RepLencoder + .kNumLenProbs)	140	.Literal = (.RepLencoder + .kNumLenProbs)
134		141
135	.LZMA_BASE_SIZE = 1846 ; must be ==Literal	142	.LZMA_BASE_SIZE = 1846 ; must be ==Literal
136	.LZMA_LIT_SIZE = 768	143	.LZMA_LIT_SIZE = 768
137		144
138	.kNumTopBits = 24	145	.kNumTopBits = 24
139	.kTopValue = (1 shl .kNumTopBits)	146	.kTopValue = (1 shl .kNumTopBits)
140		147
141	.kNumBitModelTotalBits = 11	148	.kNumBitModelTotalBits = 11
142	.kBitModelTotal = (1 shl .kNumBitModelTotalBits)	149	.kBitModelTotal = (1 shl .kNumBitModelTotalBits)
143	.kNumMoveBits = 5	150	.kNumMoveBits = 5
144		151
145	push edi	152	push edi
146	; int state=0;	153	; int state=0;
147	xor ebx, ebx	154	xor ebx, ebx
148	mov [.previousByte], bl	155	mov [.previousByte], bl
149	; unsigned rep0=1,rep1=1,rep2=1,rep3=1;	156	; unsigned rep0=1,rep1=1,rep2=1,rep3=1;
150	mov eax, 1	157	mov eax, 1
151	mov edi, .rep0	158	mov edi, .rep0
152	stosd	159	stosd
153	stosd	160	stosd
154	stosd	161	stosd
155	stosd	162	stosd
156	; int len=0;	163	; int len=0;
157	; result=0;	164	; result=0;
158	mov ecx, .Literal + (.LZMA_LIT_SIZE shl (.lc+.lp))	165	mov ecx, .Literal + (.LZMA_LIT_SIZE shl (.lc+.lp))
159	mov eax, .kBitModelTotal/2	166	mov eax, .kBitModelTotal/2
160	mov edi, .p	167	mov edi, .p
161	rep stosd	168	rep stosd
162	; RangeDecoderInit	169	; RangeDecoderInit
163	; rd->ExtraBytes = 0	170	; rd->ExtraBytes = 0
164	; rd->Buffer = stream	171	; rd->Buffer = stream
165	; rd->BufferLim = stream+bufferSize	172	; rd->BufferLim = stream+bufferSize
166	; rd->Range = 0xFFFFFFFF	173	; rd->Range = 0xFFFFFFFF
167	pop edi	174	pop edi
168	mov ebp, [esi-8] ; dest_length	175	mov ebp, [esi-8] ; dest_length
169	add ebp, edi ; ebp = destination limit	176	add ebp, edi ; ebp = destination limit
170	lodsd	177	lodsd
171	; rd->code_ = eax	178	; rd->code_ = eax
172	mov [.code_], eax	179	mov [.code_], eax
173	or [.range], -1	180	or [.range], -1
174	.main_loop:	181	.main_loop:
175	cmp edi, ebp	182	cmp edi, ebp
176	jae .main_loop_done	183	jae .main_loop_done
177	mov edx, edi	184	mov edx, edi
178	and edx, .posStateMask	185	and edx, .posStateMask
179	mov eax, ebx	186	mov eax, ebx
180	shl eax, .kNumPosBitsMax+2	187	shl eax, .kNumPosBitsMax+2
181	lea eax, [.p + .IsMatch4 + eax + edx4]	188	lea eax, [.p + .IsMatch4 + eax + edx4]
182	call .RangeDecoderBitDecode	189	call .RangeDecoderBitDecode
183	jc .1	190	jc .1
184	movzx eax, [.previousByte]	191	movzx eax, [.previousByte]
185	if .literalPosMask	192	if .literalPosMask
186	mov ah, dl	193	mov ah, dl
187	and ah, .literalPosMask	194	and ah, .literalPosMask
188	end if	195	end if
189	shr eax, 8-.lc	196	shr eax, 8-.lc
190	imul eax, .LZMA_LIT_SIZE*4	197	imul eax, .LZMA_LIT_SIZE*4
191	add eax, .p+.Literal*4	198	add eax, .p+.Literal*4
192	cmp ebx, .kNumLitStates	199	cmp ebx, .kNumLitStates
193	jb .literal	200	jb .literal
194	xor edx, edx	201	xor edx, edx
195	sub edx, [.rep0]	202	sub edx, [.rep0]
196	mov dl, [edi + edx]	203	mov dl, [edi + edx]
197	call .LzmaLiteralDecodeMatch	204	call .LzmaLiteralDecodeMatch
198	jmp @f	205	jmp @f
199	.literal:	206	.literal:
200	call .LzmaLiteralDecode	207	call .LzmaLiteralDecode
201	@@:	208	@@:
202	mov [.previousByte], al	209	mov [.previousByte], al
203	stosb	210	stosb
204	mov al, bl	211	mov al, bl
205	cmp bl, 4	212	cmp bl, 4
206	jb @f	213	jb @f
207	mov al, 3	214	mov al, 3
208	cmp bl, 10	215	cmp bl, 10
209	jb @f	216	jb @f
210	mov al, 6	217	mov al, 6
211	@@: sub bl, al	218	@@: sub bl, al
212	jmp .main_loop	219	jmp .main_loop
213	.1:	220	.1:
214	lea eax, [.p + .IsRep4 + ebx4]	221	lea eax, [.p + .IsRep4 + ebx4]
215	call .RangeDecoderBitDecode	222	call .RangeDecoderBitDecode
216	jnc .10	223	jnc .10
217	lea eax, [.p + .IsRepG04 + ebx4]	224	lea eax, [.p + .IsRepG04 + ebx4]
218	call .RangeDecoderBitDecode	225	call .RangeDecoderBitDecode
219	jc .111	226	jc .111
220	mov eax, ebx	227	mov eax, ebx
221	shl eax, .kNumPosBitsMax+2	228	shl eax, .kNumPosBitsMax+2
222	lea eax, [.p + .IsRep0Long4 + eax + edx4]	229	lea eax, [.p + .IsRep0Long4 + eax + edx4]
223	call .RangeDecoderBitDecode	230	call .RangeDecoderBitDecode
224	jc .1101	231	jc .1101
225	cmp bl, 7	232	cmp bl, 7
226	setae bl	233	setae bl
227	lea ebx, [9 + ebx + ebx]	234	lea ebx, [9 + ebx + ebx]
228	xor edx, edx	235	xor edx, edx
229	sub edx, [.rep0]	236	sub edx, [.rep0]
230	mov al, [edi + edx]	237	mov al, [edi + edx]
231	stosb	238	stosb
232	mov [.previousByte], al	239	mov [.previousByte], al
233	jmp .main_loop	240	jmp .main_loop
234	.111:	241	.111:
235	lea eax, [.p + .IsRepG14 + ebx4]	242	lea eax, [.p + .IsRepG14 + ebx4]
236	call .RangeDecoderBitDecode	243	call .RangeDecoderBitDecode
237	mov eax, [.rep1]	244	mov eax, [.rep1]
238	jnc .l3	245	jnc .l3
239	.l1:	246	.l1:
240	lea eax, [.p + .IsRepG24 + ebx4]	247	lea eax, [.p + .IsRepG24 + ebx4]
241	call .RangeDecoderBitDecode	248	call .RangeDecoderBitDecode
242	mov eax, [.rep2]	249	mov eax, [.rep2]
243	jnc .l2	250	jnc .l2
244	xchg [.rep3], eax	251	xchg [.rep3], eax
245	.l2:	252	.l2:
246	push [.rep1]	253	push [.rep1]
247	pop [.rep2]	254	pop [.rep2]
248	.l3:	255	.l3:
249	xchg eax, [.rep0]	256	xchg eax, [.rep0]
250	mov [.rep1], eax	257	mov [.rep1], eax
251	.1101:	258	.1101:
252	mov eax, .p + .RepLencoder*4	259	mov eax, .p + .RepLencoder*4
253	call .LzmaLenDecode	260	call .LzmaLenDecode
254	cmp bl, 7	261	cmp bl, 7
255	setc bl	262	setc bl
256	adc bl, bl	263	adc bl, bl
257	xor bl, 3	264	xor bl, 3
258	add bl, 8	265	add bl, 8
259	jmp .repmovsb	266	jmp .repmovsb
260	.10:	267	.10:
261	mov eax, [.rep0]	268	mov eax, [.rep0]
262	xchg eax, [.rep1]	269	xchg eax, [.rep1]
263	xchg eax, [.rep2]	270	xchg eax, [.rep2]
264	xchg eax, [.rep3]	271	xchg eax, [.rep3]
265	cmp bl, 7	272	cmp bl, 7
266	setc bl	273	setc bl
267	adc bl, bl	274	adc bl, bl
268	xor bl, 3	275	xor bl, 3
269	add bl, 7	276	add bl, 7
270	mov eax, .p + .Lencoder*4	277	mov eax, .p + .Lencoder*4
271	call .LzmaLenDecode	278	call .LzmaLenDecode
272	mov eax, .kNumLenToPosStates-1	279	mov eax, .kNumLenToPosStates-1
273	cmp eax, ecx	280	cmp eax, ecx
274	jb @f	281	jb @f
275	mov eax, ecx	282	mov eax, ecx
276	@@:	283	@@:
277	push ecx	284	push ecx
278	mov ecx, .kNumPosSlotBits	285	mov ecx, .kNumPosSlotBits
279	shl eax, cl	286	shl eax, cl
280	shl eax, 2	287	shl eax, 2
281	add eax, .p+.PosSlot*4	288	add eax, .p+.PosSlot*4
282	call .RangeDecoderBitTreeDecode	289	call .RangeDecoderBitTreeDecode
283	mov [.rep0], ecx	290	mov [.rep0], ecx
284	cmp ecx, .kStartPosModelIndex	291	cmp ecx, .kStartPosModelIndex
285	jb .l6	292	jb .l6
286	push ecx	293	push ecx
287	mov eax, ecx	294	mov eax, ecx
288	and eax, 1	295	and eax, 1
289	shr ecx, 1	296	shr ecx, 1
290	or eax, 2	297	or eax, 2
291	dec ecx	298	dec ecx
292	shl eax, cl	299	shl eax, cl
293	mov [.rep0], eax	300	mov [.rep0], eax
294	pop edx	301	pop edx
295	cmp edx, .kEndPosModelIndex	302	cmp edx, .kEndPosModelIndex
296	jae .l5	303	jae .l5
297	sub eax, edx	304	sub eax, edx
298	shl eax, 2	305	shl eax, 2
299	add eax, .p + (.SpecPos - 1)*4	306	add eax, .p + (.SpecPos - 1)*4
300	call .RangeDecoderReverseBitTreeDecode	307	call .RangeDecoderReverseBitTreeDecode
301	add [.rep0], ecx	308	add [.rep0], ecx
302	jmp .l6	309	jmp .l6
303	.l5:	310	.l5:
304	sub ecx, .kNumAlignBits	311	sub ecx, .kNumAlignBits
305	call .RangeDecoderDecodeDirectBits	312	call .RangeDecoderDecodeDirectBits
306	mov ecx, .kNumAlignBits	313	mov ecx, .kNumAlignBits
307	shl eax, cl	314	shl eax, cl
308	add [.rep0], eax	315	add [.rep0], eax
309	mov eax, .p+.Align_*4	316	mov eax, .p+.Align_*4
310	call .RangeDecoderReverseBitTreeDecode	317	call .RangeDecoderReverseBitTreeDecode
311	add [.rep0], ecx	318	add [.rep0], ecx
312	.l6:	319	.l6:
313	pop ecx	320	pop ecx
314	inc [.rep0]	321	inc [.rep0]
315	jz .main_loop_done	322	jz .main_loop_done
316	.repmovsb:	323	.repmovsb:
317	add ecx, .kMatchMinLen	324	add ecx, .kMatchMinLen
318	push esi	325	push esi
319	mov esi, edi	326	mov esi, edi
320	sub esi, [.rep0]	327	sub esi, [.rep0]
321	rep movsb	328	rep movsb
322	pop esi	329	pop esi
323	mov al, [edi-1]	330	mov al, [edi-1]
324	mov [.previousByte], al	331	mov [.previousByte], al
325	jmp .main_loop	332	jmp .main_loop
326	.main_loop_done:	333	.main_loop_done:
327	ret	334	ret
328		335
329	.RangeDecoderBitDecode:	336	.RangeDecoderBitDecode:
330	; in: eax->prob	337	; in: eax->prob
331	; out: CF=bit; destroys eax	338	; out: CF=bit; destroys eax
332	push edx	339	push edx
333	mov edx, [.range]	340	mov edx, [.range]
334	shr edx, .kNumBitModelTotalBits	341	shr edx, .kNumBitModelTotalBits
335	imul edx, [eax]	342	imul edx, [eax]
336	cmp [.code_], edx	343	cmp [.code_], edx
337	jae .ae	344	jae .ae
338	mov [.range], edx	345	mov [.range], edx
339	mov edx, .kBitModelTotal	346	mov edx, .kBitModelTotal
340	sub edx, [eax]	347	sub edx, [eax]
341	shr edx, .kNumMoveBits	348	shr edx, .kNumMoveBits
342	add [eax], edx	349	add [eax], edx
343	clc	350	clc
344	.n:	351	.n:
345	lahf	352	lahf
346	cmp [.range], .kTopValue	353	cmp [.range], .kTopValue
347	jae @f	354	jae @f
348	shl [.range], 8	355	shl [.range], 8
349	shl [.code_], 8	356	shl [.code_], 8
350	lodsb	357	lodsb
351	mov byte [.code_], al	358	mov byte [.code_], al
352	@@:	359	@@:
353	sahf	360	sahf
354	pop edx	361	pop edx
355	ret	362	ret
356	.ae:	363	.ae:
357	sub [.range], edx	364	sub [.range], edx
358	sub [.code_], edx	365	sub [.code_], edx
359	mov edx, [eax]	366	mov edx, [eax]
360	shr edx, .kNumMoveBits	367	shr edx, .kNumMoveBits
361	sub [eax], edx	368	sub [eax], edx
362	stc	369	stc
363	jmp .n	370	jmp .n
364		371
365	.RangeDecoderDecodeDirectBits:	372	.RangeDecoderDecodeDirectBits:
366	; in: ecx=numTotalBits	373	; in: ecx=numTotalBits
367	; out: eax=result; destroys edx	374	; out: eax=result; destroys edx
368	xor eax, eax	375	xor eax, eax
369	.l:	376	.l:
370	shr [.range], 1	377	shr [.range], 1
371	shl eax, 1	378	shl eax, 1
372	mov edx, [.code_]	379	mov edx, [.code_]
373	sub edx, [.range]	380	sub edx, [.range]
374	jb @f	381	jb @f
375	mov [.code_], edx	382	mov [.code_], edx
376	or eax, 1	383	or eax, 1
377	@@:	384	@@:
378	cmp [.range], .kTopValue	385	cmp [.range], .kTopValue
379	jae @f	386	jae @f
380	shl [.range], 8	387	shl [.range], 8
381	shl [.code_], 8	388	shl [.code_], 8
382	push eax	389	push eax
383	lodsb	390	lodsb
384	mov byte [.code_], al	391	mov byte [.code_], al
385	pop eax	392	pop eax
386	@@:	393	@@:
387	loop .l	394	loop .l
388	ret	395	ret
389		396
390	.LzmaLiteralDecode:	397	.LzmaLiteralDecode:
391	; in: eax->probs	398	; in: eax->probs
392	; out: al=byte; destroys edx	399	; out: al=byte; destroys edx
393	push ecx	400	push ecx
394	mov ecx, 1	401	mov ecx, 1
395	@@:	402	@@:
396	push eax	403	push eax
397	lea eax, [eax+ecx*4]	404	lea eax, [eax+ecx*4]
398	call .RangeDecoderBitDecode	405	call .RangeDecoderBitDecode
399	pop eax	406	pop eax
400	adc cl, cl	407	adc cl, cl
401	jnc @b	408	jnc @b
402	.LzmaLiteralDecode.ret:	409	.LzmaLiteralDecode.ret:
403	mov al, cl	410	mov al, cl
404	pop ecx	411	pop ecx
405	ret	412	ret
406	.LzmaLiteralDecodeMatch:	413	.LzmaLiteralDecodeMatch:
407	; in: eax->probs, dl=matchByte	414	; in: eax->probs, dl=matchByte
408	; out: al=byte; destroys edx	415	; out: al=byte; destroys edx
409	push ecx	416	push ecx
410	mov ecx, 1	417	mov ecx, 1
411	.LzmaLiteralDecodeMatch.1:	418	.LzmaLiteralDecodeMatch.1:
412	add dl, dl	419	add dl, dl
413	setc ch	420	setc ch
414	push eax	421	push eax
415	lea eax, [eax+ecx4+0x1004]	422	lea eax, [eax+ecx4+0x1004]
416	call .RangeDecoderBitDecode	423	call .RangeDecoderBitDecode
417	pop eax	424	pop eax
418	adc cl, cl	425	adc cl, cl
419	jc .LzmaLiteralDecode.ret	426	jc .LzmaLiteralDecode.ret
420	xor ch, cl	427	xor ch, cl
421	test ch, 1	428	test ch, 1
422	mov ch, 0	429	mov ch, 0
423	jnz @b	430	jnz @b
424	jmp .LzmaLiteralDecodeMatch.1	431	jmp .LzmaLiteralDecodeMatch.1
425		432
426	.LzmaLenDecode:	433	.LzmaLenDecode:
427	; in: eax->prob, edx=posState	434	; in: eax->prob, edx=posState
428	; out: ecx=len	435	; out: ecx=len
429	push eax	436	push eax
430	add eax, .LenChoice*4	437	add eax, .LenChoice*4
431	call .RangeDecoderBitDecode	438	call .RangeDecoderBitDecode
432	pop eax	439	pop eax
433	jnc .0	440	jnc .0
434	push eax	441	push eax
435	add eax, .LenChoice2*4	442	add eax, .LenChoice2*4
436	call .RangeDecoderBitDecode	443	call .RangeDecoderBitDecode
437	pop eax	444	pop eax
438	jc @f	445	jc @f
439	mov ecx, .kLenNumMidBits	446	mov ecx, .kLenNumMidBits
440	shl edx, cl	447	shl edx, cl
441	lea eax, [eax + .LenMid4 + edx4]	448	lea eax, [eax + .LenMid4 + edx4]
442	call .RangeDecoderBitTreeDecode	449	call .RangeDecoderBitTreeDecode
443	add ecx, .kLenNumLowSymbols	450	add ecx, .kLenNumLowSymbols
444	ret	451	ret
445	@@:	452	@@:
446	add eax, .LenHigh*4	453	add eax, .LenHigh*4
447	mov ecx, .kLenNumHighBits	454	mov ecx, .kLenNumHighBits
448	call .RangeDecoderBitTreeDecode	455	call .RangeDecoderBitTreeDecode
449	add ecx, .kLenNumLowSymbols + .kLenNumMidSymbols	456	add ecx, .kLenNumLowSymbols + .kLenNumMidSymbols
450	ret	457	ret
451	.0:	458	.0:
452	mov ecx, .kLenNumLowBits	459	mov ecx, .kLenNumLowBits
453	shl edx, cl	460	shl edx, cl
454	lea eax, [eax + .LenLow4 + edx4]	461	lea eax, [eax + .LenLow4 + edx4]
455	.RangeDecoderBitTreeDecode:	462	.RangeDecoderBitTreeDecode:
456	; in: eax->probs,ecx=numLevels	463	; in: eax->probs,ecx=numLevels
457	; out: ecx=length; destroys edx	464	; out: ecx=length; destroys edx
458	push ebx	465	push ebx
459	mov edx, 1	466	mov edx, 1
460	mov ebx, edx	467	mov ebx, edx
461	@@:	468	@@:
462	push eax	469	push eax
463	lea eax, [eax+edx*4]	470	lea eax, [eax+edx*4]
464	call .RangeDecoderBitDecode	471	call .RangeDecoderBitDecode
465	pop eax	472	pop eax
466	adc dl, dl	473	adc dl, dl
467	add bl, bl	474	add bl, bl
468	loop @b	475	loop @b
469	sub dl, bl	476	sub dl, bl
470	pop ebx	477	pop ebx
471	mov ecx, edx	478	mov ecx, edx
472	ret	479	ret
473	.RangeDecoderReverseBitTreeDecode:	480	.RangeDecoderReverseBitTreeDecode:
474	; in: eax->probs,ecx=numLevels	481	; in: eax->probs,ecx=numLevels
475	; out: ecx=length; destroys edx	482	; out: ecx=length; destroys edx
476	push ebx ecx	483	push ebx ecx
477	mov edx, 1	484	mov edx, 1
478	xor ebx, ebx	485	xor ebx, ebx
479	@@:	486	@@:
480	push eax	487	push eax
481	lea eax, [eax+edx*4]	488	lea eax, [eax+edx*4]
482	call .RangeDecoderBitDecode	489	call .RangeDecoderBitDecode
483	lahf	490	lahf
484	adc edx, edx	491	adc edx, edx
485	sahf	492	sahf
486	rcr ebx, 1	493	rcr ebx, 1
487	pop eax	494	pop eax
488	loop @b	495	loop @b
489	pop ecx	496	pop ecx
490	rol ebx, cl	497	rol ebx, cl
491	mov ecx, ebx	498	mov ecx, ebx
492	pop ebx	499	pop ebx
493	ret	500	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/unpacker.inc @ 467 – Rev 425 → 431