aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/source/Irrlicht/lzma/LzmaDec.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/lzma/LzmaDec.c')
-rw-r--r--libraries/irrlicht-1.8/source/Irrlicht/lzma/LzmaDec.c1998
1 files changed, 999 insertions, 999 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/lzma/LzmaDec.c b/libraries/irrlicht-1.8/source/Irrlicht/lzma/LzmaDec.c
index 4fdc11d..2036761 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/lzma/LzmaDec.c
+++ b/libraries/irrlicht-1.8/source/Irrlicht/lzma/LzmaDec.c
@@ -1,999 +1,999 @@
1/* LzmaDec.c -- LZMA Decoder 1/* LzmaDec.c -- LZMA Decoder
22009-09-20 : Igor Pavlov : Public domain */ 22009-09-20 : Igor Pavlov : Public domain */
3 3
4#include "LzmaDec.h" 4#include "LzmaDec.h"
5 5
6#include <string.h> 6#include <string.h>
7 7
8#define kNumTopBits 24 8#define kNumTopBits 24
9#define kTopValue ((UInt32)1 << kNumTopBits) 9#define kTopValue ((UInt32)1 << kNumTopBits)
10 10
11#define kNumBitModelTotalBits 11 11#define kNumBitModelTotalBits 11
12#define kBitModelTotal (1 << kNumBitModelTotalBits) 12#define kBitModelTotal (1 << kNumBitModelTotalBits)
13#define kNumMoveBits 5 13#define kNumMoveBits 5
14 14
15#define RC_INIT_SIZE 5 15#define RC_INIT_SIZE 5
16 16
17#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); } 17#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
18 18
19#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound) 19#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
20#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); 20#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
21#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits)); 21#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));
22#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \ 22#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \
23 { UPDATE_0(p); i = (i + i); A0; } else \ 23 { UPDATE_0(p); i = (i + i); A0; } else \
24 { UPDATE_1(p); i = (i + i) + 1; A1; } 24 { UPDATE_1(p); i = (i + i) + 1; A1; }
25#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;) 25#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;)
26 26
27#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); } 27#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); }
28#define TREE_DECODE(probs, limit, i) \ 28#define TREE_DECODE(probs, limit, i) \
29 { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; } 29 { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }
30 30
31/* #define _LZMA_SIZE_OPT */ 31/* #define _LZMA_SIZE_OPT */
32 32
33#ifdef _LZMA_SIZE_OPT 33#ifdef _LZMA_SIZE_OPT
34#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i) 34#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)
35#else 35#else
36#define TREE_6_DECODE(probs, i) \ 36#define TREE_6_DECODE(probs, i) \
37 { i = 1; \ 37 { i = 1; \
38 TREE_GET_BIT(probs, i); \ 38 TREE_GET_BIT(probs, i); \
39 TREE_GET_BIT(probs, i); \ 39 TREE_GET_BIT(probs, i); \
40 TREE_GET_BIT(probs, i); \ 40 TREE_GET_BIT(probs, i); \
41 TREE_GET_BIT(probs, i); \ 41 TREE_GET_BIT(probs, i); \
42 TREE_GET_BIT(probs, i); \ 42 TREE_GET_BIT(probs, i); \
43 TREE_GET_BIT(probs, i); \ 43 TREE_GET_BIT(probs, i); \
44 i -= 0x40; } 44 i -= 0x40; }
45#endif 45#endif
46 46
47#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); } 47#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }
48 48
49#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound) 49#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
50#define UPDATE_0_CHECK range = bound; 50#define UPDATE_0_CHECK range = bound;
51#define UPDATE_1_CHECK range -= bound; code -= bound; 51#define UPDATE_1_CHECK range -= bound; code -= bound;
52#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \ 52#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
53 { UPDATE_0_CHECK; i = (i + i); A0; } else \ 53 { UPDATE_0_CHECK; i = (i + i); A0; } else \
54 { UPDATE_1_CHECK; i = (i + i) + 1; A1; } 54 { UPDATE_1_CHECK; i = (i + i) + 1; A1; }
55#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;) 55#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)
56#define TREE_DECODE_CHECK(probs, limit, i) \ 56#define TREE_DECODE_CHECK(probs, limit, i) \
57 { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; } 57 { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }
58 58
59 59
60#define kNumPosBitsMax 4 60#define kNumPosBitsMax 4
61#define kNumPosStatesMax (1 << kNumPosBitsMax) 61#define kNumPosStatesMax (1 << kNumPosBitsMax)
62 62
63#define kLenNumLowBits 3 63#define kLenNumLowBits 3
64#define kLenNumLowSymbols (1 << kLenNumLowBits) 64#define kLenNumLowSymbols (1 << kLenNumLowBits)
65#define kLenNumMidBits 3 65#define kLenNumMidBits 3
66#define kLenNumMidSymbols (1 << kLenNumMidBits) 66#define kLenNumMidSymbols (1 << kLenNumMidBits)
67#define kLenNumHighBits 8 67#define kLenNumHighBits 8
68#define kLenNumHighSymbols (1 << kLenNumHighBits) 68#define kLenNumHighSymbols (1 << kLenNumHighBits)
69 69
70#define LenChoice 0 70#define LenChoice 0
71#define LenChoice2 (LenChoice + 1) 71#define LenChoice2 (LenChoice + 1)
72#define LenLow (LenChoice2 + 1) 72#define LenLow (LenChoice2 + 1)
73#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits)) 73#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
74#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits)) 74#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
75#define kNumLenProbs (LenHigh + kLenNumHighSymbols) 75#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
76 76
77 77
78#define kNumStates 12 78#define kNumStates 12
79#define kNumLitStates 7 79#define kNumLitStates 7
80 80
81#define kStartPosModelIndex 4 81#define kStartPosModelIndex 4
82#define kEndPosModelIndex 14 82#define kEndPosModelIndex 14
83#define kNumFullDistances (1 << (kEndPosModelIndex >> 1)) 83#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
84 84
85#define kNumPosSlotBits 6 85#define kNumPosSlotBits 6
86#define kNumLenToPosStates 4 86#define kNumLenToPosStates 4
87 87
88#define kNumAlignBits 4 88#define kNumAlignBits 4
89#define kAlignTableSize (1 << kNumAlignBits) 89#define kAlignTableSize (1 << kNumAlignBits)
90 90
91#define kMatchMinLen 2 91#define kMatchMinLen 2
92#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols) 92#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)
93 93
94#define IsMatch 0 94#define IsMatch 0
95#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax)) 95#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
96#define IsRepG0 (IsRep + kNumStates) 96#define IsRepG0 (IsRep + kNumStates)
97#define IsRepG1 (IsRepG0 + kNumStates) 97#define IsRepG1 (IsRepG0 + kNumStates)
98#define IsRepG2 (IsRepG1 + kNumStates) 98#define IsRepG2 (IsRepG1 + kNumStates)
99#define IsRep0Long (IsRepG2 + kNumStates) 99#define IsRep0Long (IsRepG2 + kNumStates)
100#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax)) 100#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
101#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits)) 101#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
102#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex) 102#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
103#define LenCoder (Align + kAlignTableSize) 103#define LenCoder (Align + kAlignTableSize)
104#define RepLenCoder (LenCoder + kNumLenProbs) 104#define RepLenCoder (LenCoder + kNumLenProbs)
105#define Literal (RepLenCoder + kNumLenProbs) 105#define Literal (RepLenCoder + kNumLenProbs)
106 106
107#define LZMA_BASE_SIZE 1846 107#define LZMA_BASE_SIZE 1846
108#define LZMA_LIT_SIZE 768 108#define LZMA_LIT_SIZE 768
109 109
110#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp))) 110#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
111 111
112#if Literal != LZMA_BASE_SIZE 112#if Literal != LZMA_BASE_SIZE
113StopCompilingDueBUG 113StopCompilingDueBUG
114#endif 114#endif
115 115
116#define LZMA_DIC_MIN (1 << 12) 116#define LZMA_DIC_MIN (1 << 12)
117 117
118/* First LZMA-symbol is always decoded. 118/* First LZMA-symbol is always decoded.
119And it decodes new LZMA-symbols while (buf < bufLimit), but "buf" is without last normalization 119And it decodes new LZMA-symbols while (buf < bufLimit), but "buf" is without last normalization
120Out: 120Out:
121 Result: 121 Result:
122 SZ_OK - OK 122 SZ_OK - OK
123 SZ_ERROR_DATA - Error 123 SZ_ERROR_DATA - Error
124 p->remainLen: 124 p->remainLen:
125 < kMatchSpecLenStart : normal remain 125 < kMatchSpecLenStart : normal remain
126 = kMatchSpecLenStart : finished 126 = kMatchSpecLenStart : finished
127 = kMatchSpecLenStart + 1 : Flush marker 127 = kMatchSpecLenStart + 1 : Flush marker
128 = kMatchSpecLenStart + 2 : State Init Marker 128 = kMatchSpecLenStart + 2 : State Init Marker
129*/ 129*/
130 130
131static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit) 131static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
132{ 132{
133 CLzmaProb *probs = p->probs; 133 CLzmaProb *probs = p->probs;
134 134
135 unsigned state = p->state; 135 unsigned state = p->state;
136 UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3]; 136 UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
137 unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1; 137 unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
138 unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1; 138 unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
139 unsigned lc = p->prop.lc; 139 unsigned lc = p->prop.lc;
140 140
141 Byte *dic = p->dic; 141 Byte *dic = p->dic;
142 SizeT dicBufSize = p->dicBufSize; 142 SizeT dicBufSize = p->dicBufSize;
143 SizeT dicPos = p->dicPos; 143 SizeT dicPos = p->dicPos;
144 144
145 UInt32 processedPos = p->processedPos; 145 UInt32 processedPos = p->processedPos;
146 UInt32 checkDicSize = p->checkDicSize; 146 UInt32 checkDicSize = p->checkDicSize;
147 unsigned len = 0; 147 unsigned len = 0;
148 148
149 const Byte *buf = p->buf; 149 const Byte *buf = p->buf;
150 UInt32 range = p->range; 150 UInt32 range = p->range;
151 UInt32 code = p->code; 151 UInt32 code = p->code;
152 152
153 do 153 do
154 { 154 {
155 CLzmaProb *prob; 155 CLzmaProb *prob;
156 UInt32 bound; 156 UInt32 bound;
157 unsigned ttt; 157 unsigned ttt;
158 unsigned posState = processedPos & pbMask; 158 unsigned posState = processedPos & pbMask;
159 159
160 prob = probs + IsMatch + (state << kNumPosBitsMax) + posState; 160 prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
161 IF_BIT_0(prob) 161 IF_BIT_0(prob)
162 { 162 {
163 unsigned symbol; 163 unsigned symbol;
164 UPDATE_0(prob); 164 UPDATE_0(prob);
165 prob = probs + Literal; 165 prob = probs + Literal;
166 if (checkDicSize != 0 || processedPos != 0) 166 if (checkDicSize != 0 || processedPos != 0)
167 prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) + 167 prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) +
168 (dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc)))); 168 (dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc))));
169 169
170 if (state < kNumLitStates) 170 if (state < kNumLitStates)
171 { 171 {
172 state -= (state < 4) ? state : 3; 172 state -= (state < 4) ? state : 3;
173 symbol = 1; 173 symbol = 1;
174 do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100); 174 do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100);
175 } 175 }
176 else 176 else
177 { 177 {
178 unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)]; 178 unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
179 unsigned offs = 0x100; 179 unsigned offs = 0x100;
180 state -= (state < 10) ? 3 : 6; 180 state -= (state < 10) ? 3 : 6;
181 symbol = 1; 181 symbol = 1;
182 do 182 do
183 { 183 {
184 unsigned bit; 184 unsigned bit;
185 CLzmaProb *probLit; 185 CLzmaProb *probLit;
186 matchByte <<= 1; 186 matchByte <<= 1;
187 bit = (matchByte & offs); 187 bit = (matchByte & offs);
188 probLit = prob + offs + bit + symbol; 188 probLit = prob + offs + bit + symbol;
189 GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit) 189 GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)
190 } 190 }
191 while (symbol < 0x100); 191 while (symbol < 0x100);
192 } 192 }
193 dic[dicPos++] = (Byte)symbol; 193 dic[dicPos++] = (Byte)symbol;
194 processedPos++; 194 processedPos++;
195 continue; 195 continue;
196 } 196 }
197 else 197 else
198 { 198 {
199 UPDATE_1(prob); 199 UPDATE_1(prob);
200 prob = probs + IsRep + state; 200 prob = probs + IsRep + state;
201 IF_BIT_0(prob) 201 IF_BIT_0(prob)
202 { 202 {
203 UPDATE_0(prob); 203 UPDATE_0(prob);
204 state += kNumStates; 204 state += kNumStates;
205 prob = probs + LenCoder; 205 prob = probs + LenCoder;
206 } 206 }
207 else 207 else
208 { 208 {
209 UPDATE_1(prob); 209 UPDATE_1(prob);
210 if (checkDicSize == 0 && processedPos == 0) 210 if (checkDicSize == 0 && processedPos == 0)
211 return SZ_ERROR_DATA; 211 return SZ_ERROR_DATA;
212 prob = probs + IsRepG0 + state; 212 prob = probs + IsRepG0 + state;
213 IF_BIT_0(prob) 213 IF_BIT_0(prob)
214 { 214 {
215 UPDATE_0(prob); 215 UPDATE_0(prob);
216 prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState; 216 prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
217 IF_BIT_0(prob) 217 IF_BIT_0(prob)
218 { 218 {
219 UPDATE_0(prob); 219 UPDATE_0(prob);
220 dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)]; 220 dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
221 dicPos++; 221 dicPos++;
222 processedPos++; 222 processedPos++;
223 state = state < kNumLitStates ? 9 : 11; 223 state = state < kNumLitStates ? 9 : 11;
224 continue; 224 continue;
225 } 225 }
226 UPDATE_1(prob); 226 UPDATE_1(prob);
227 } 227 }
228 else 228 else
229 { 229 {
230 UInt32 distance; 230 UInt32 distance;
231 UPDATE_1(prob); 231 UPDATE_1(prob);
232 prob = probs + IsRepG1 + state; 232 prob = probs + IsRepG1 + state;
233 IF_BIT_0(prob) 233 IF_BIT_0(prob)
234 { 234 {
235 UPDATE_0(prob); 235 UPDATE_0(prob);
236 distance = rep1; 236 distance = rep1;
237 } 237 }
238 else 238 else
239 { 239 {
240 UPDATE_1(prob); 240 UPDATE_1(prob);
241 prob = probs + IsRepG2 + state; 241 prob = probs + IsRepG2 + state;
242 IF_BIT_0(prob) 242 IF_BIT_0(prob)
243 { 243 {
244 UPDATE_0(prob); 244 UPDATE_0(prob);
245 distance = rep2; 245 distance = rep2;
246 } 246 }
247 else 247 else
248 { 248 {
249 UPDATE_1(prob); 249 UPDATE_1(prob);
250 distance = rep3; 250 distance = rep3;
251 rep3 = rep2; 251 rep3 = rep2;
252 } 252 }
253 rep2 = rep1; 253 rep2 = rep1;
254 } 254 }
255 rep1 = rep0; 255 rep1 = rep0;
256 rep0 = distance; 256 rep0 = distance;
257 } 257 }
258 state = state < kNumLitStates ? 8 : 11; 258 state = state < kNumLitStates ? 8 : 11;
259 prob = probs + RepLenCoder; 259 prob = probs + RepLenCoder;
260 } 260 }
261 { 261 {
262 unsigned limit, offset; 262 unsigned limit, offset;
263 CLzmaProb *probLen = prob + LenChoice; 263 CLzmaProb *probLen = prob + LenChoice;
264 IF_BIT_0(probLen) 264 IF_BIT_0(probLen)
265 { 265 {
266 UPDATE_0(probLen); 266 UPDATE_0(probLen);
267 probLen = prob + LenLow + (posState << kLenNumLowBits); 267 probLen = prob + LenLow + (posState << kLenNumLowBits);
268 offset = 0; 268 offset = 0;
269 limit = (1 << kLenNumLowBits); 269 limit = (1 << kLenNumLowBits);
270 } 270 }
271 else 271 else
272 { 272 {
273 UPDATE_1(probLen); 273 UPDATE_1(probLen);
274 probLen = prob + LenChoice2; 274 probLen = prob + LenChoice2;
275 IF_BIT_0(probLen) 275 IF_BIT_0(probLen)
276 { 276 {
277 UPDATE_0(probLen); 277 UPDATE_0(probLen);
278 probLen = prob + LenMid + (posState << kLenNumMidBits); 278 probLen = prob + LenMid + (posState << kLenNumMidBits);
279 offset = kLenNumLowSymbols; 279 offset = kLenNumLowSymbols;
280 limit = (1 << kLenNumMidBits); 280 limit = (1 << kLenNumMidBits);
281 } 281 }
282 else 282 else
283 { 283 {
284 UPDATE_1(probLen); 284 UPDATE_1(probLen);
285 probLen = prob + LenHigh; 285 probLen = prob + LenHigh;
286 offset = kLenNumLowSymbols + kLenNumMidSymbols; 286 offset = kLenNumLowSymbols + kLenNumMidSymbols;
287 limit = (1 << kLenNumHighBits); 287 limit = (1 << kLenNumHighBits);
288 } 288 }
289 } 289 }
290 TREE_DECODE(probLen, limit, len); 290 TREE_DECODE(probLen, limit, len);
291 len += offset; 291 len += offset;
292 } 292 }
293 293
294 if (state >= kNumStates) 294 if (state >= kNumStates)
295 { 295 {
296 UInt32 distance; 296 UInt32 distance;
297 prob = probs + PosSlot + 297 prob = probs + PosSlot +
298 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits); 298 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
299 TREE_6_DECODE(prob, distance); 299 TREE_6_DECODE(prob, distance);
300 if (distance >= kStartPosModelIndex) 300 if (distance >= kStartPosModelIndex)
301 { 301 {
302 unsigned posSlot = (unsigned)distance; 302 unsigned posSlot = (unsigned)distance;
303 int numDirectBits = (int)(((distance >> 1) - 1)); 303 int numDirectBits = (int)(((distance >> 1) - 1));
304 distance = (2 | (distance & 1)); 304 distance = (2 | (distance & 1));
305 if (posSlot < kEndPosModelIndex) 305 if (posSlot < kEndPosModelIndex)
306 { 306 {
307 distance <<= numDirectBits; 307 distance <<= numDirectBits;
308 prob = probs + SpecPos + distance - posSlot - 1; 308 prob = probs + SpecPos + distance - posSlot - 1;
309 { 309 {
310 UInt32 mask = 1; 310 UInt32 mask = 1;
311 unsigned i = 1; 311 unsigned i = 1;
312 do 312 do
313 { 313 {
314 GET_BIT2(prob + i, i, ; , distance |= mask); 314 GET_BIT2(prob + i, i, ; , distance |= mask);
315 mask <<= 1; 315 mask <<= 1;
316 } 316 }
317 while (--numDirectBits != 0); 317 while (--numDirectBits != 0);
318 } 318 }
319 } 319 }
320 else 320 else
321 { 321 {
322 numDirectBits -= kNumAlignBits; 322 numDirectBits -= kNumAlignBits;
323 do 323 do
324 { 324 {
325 NORMALIZE 325 NORMALIZE
326 range >>= 1; 326 range >>= 1;
327 327
328 { 328 {
329 UInt32 t; 329 UInt32 t;
330 code -= range; 330 code -= range;
331 t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */ 331 t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */
332 distance = (distance << 1) + (t + 1); 332 distance = (distance << 1) + (t + 1);
333 code += range & t; 333 code += range & t;
334 } 334 }
335 /* 335 /*
336 distance <<= 1; 336 distance <<= 1;
337 if (code >= range) 337 if (code >= range)
338 { 338 {
339 code -= range; 339 code -= range;
340 distance |= 1; 340 distance |= 1;
341 } 341 }
342 */ 342 */
343 } 343 }
344 while (--numDirectBits != 0); 344 while (--numDirectBits != 0);
345 prob = probs + Align; 345 prob = probs + Align;
346 distance <<= kNumAlignBits; 346 distance <<= kNumAlignBits;
347 { 347 {
348 unsigned i = 1; 348 unsigned i = 1;
349 GET_BIT2(prob + i, i, ; , distance |= 1); 349 GET_BIT2(prob + i, i, ; , distance |= 1);
350 GET_BIT2(prob + i, i, ; , distance |= 2); 350 GET_BIT2(prob + i, i, ; , distance |= 2);
351 GET_BIT2(prob + i, i, ; , distance |= 4); 351 GET_BIT2(prob + i, i, ; , distance |= 4);
352 GET_BIT2(prob + i, i, ; , distance |= 8); 352 GET_BIT2(prob + i, i, ; , distance |= 8);
353 } 353 }
354 if (distance == (UInt32)0xFFFFFFFF) 354 if (distance == (UInt32)0xFFFFFFFF)
355 { 355 {
356 len += kMatchSpecLenStart; 356 len += kMatchSpecLenStart;
357 state -= kNumStates; 357 state -= kNumStates;
358 break; 358 break;
359 } 359 }
360 } 360 }
361 } 361 }
362 rep3 = rep2; 362 rep3 = rep2;
363 rep2 = rep1; 363 rep2 = rep1;
364 rep1 = rep0; 364 rep1 = rep0;
365 rep0 = distance + 1; 365 rep0 = distance + 1;
366 if (checkDicSize == 0) 366 if (checkDicSize == 0)
367 { 367 {
368 if (distance >= processedPos) 368 if (distance >= processedPos)
369 return SZ_ERROR_DATA; 369 return SZ_ERROR_DATA;
370 } 370 }
371 else if (distance >= checkDicSize) 371 else if (distance >= checkDicSize)
372 return SZ_ERROR_DATA; 372 return SZ_ERROR_DATA;
373 state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3; 373 state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
374 } 374 }
375 375
376 len += kMatchMinLen; 376 len += kMatchMinLen;
377 377
378 if (limit == dicPos) 378 if (limit == dicPos)
379 return SZ_ERROR_DATA; 379 return SZ_ERROR_DATA;
380 { 380 {
381 SizeT rem = limit - dicPos; 381 SizeT rem = limit - dicPos;
382 unsigned curLen = ((rem < len) ? (unsigned)rem : len); 382 unsigned curLen = ((rem < len) ? (unsigned)rem : len);
383 SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0); 383 SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0);
384 384
385 processedPos += curLen; 385 processedPos += curLen;
386 386
387 len -= curLen; 387 len -= curLen;
388 if (pos + curLen <= dicBufSize) 388 if (pos + curLen <= dicBufSize)
389 { 389 {
390 Byte *dest = dic + dicPos; 390 Byte *dest = dic + dicPos;
391 ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos; 391 ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
392 const Byte *lim = dest + curLen; 392 const Byte *lim = dest + curLen;
393 dicPos += curLen; 393 dicPos += curLen;
394 do 394 do
395 *(dest) = (Byte)*(dest + src); 395 *(dest) = (Byte)*(dest + src);
396 while (++dest != lim); 396 while (++dest != lim);
397 } 397 }
398 else 398 else
399 { 399 {
400 do 400 do
401 { 401 {
402 dic[dicPos++] = dic[pos]; 402 dic[dicPos++] = dic[pos];
403 if (++pos == dicBufSize) 403 if (++pos == dicBufSize)
404 pos = 0; 404 pos = 0;
405 } 405 }
406 while (--curLen != 0); 406 while (--curLen != 0);
407 } 407 }
408 } 408 }
409 } 409 }
410 } 410 }
411 while (dicPos < limit && buf < bufLimit); 411 while (dicPos < limit && buf < bufLimit);
412 NORMALIZE; 412 NORMALIZE;
413 p->buf = buf; 413 p->buf = buf;
414 p->range = range; 414 p->range = range;
415 p->code = code; 415 p->code = code;
416 p->remainLen = len; 416 p->remainLen = len;
417 p->dicPos = dicPos; 417 p->dicPos = dicPos;
418 p->processedPos = processedPos; 418 p->processedPos = processedPos;
419 p->reps[0] = rep0; 419 p->reps[0] = rep0;
420 p->reps[1] = rep1; 420 p->reps[1] = rep1;
421 p->reps[2] = rep2; 421 p->reps[2] = rep2;
422 p->reps[3] = rep3; 422 p->reps[3] = rep3;
423 p->state = state; 423 p->state = state;
424 424
425 return SZ_OK; 425 return SZ_OK;
426} 426}
427 427
428static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit) 428static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
429{ 429{
430 if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart) 430 if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
431 { 431 {
432 Byte *dic = p->dic; 432 Byte *dic = p->dic;
433 SizeT dicPos = p->dicPos; 433 SizeT dicPos = p->dicPos;
434 SizeT dicBufSize = p->dicBufSize; 434 SizeT dicBufSize = p->dicBufSize;
435 unsigned len = p->remainLen; 435 unsigned len = p->remainLen;
436 UInt32 rep0 = p->reps[0]; 436 UInt32 rep0 = p->reps[0];
437 if (limit - dicPos < len) 437 if (limit - dicPos < len)
438 len = (unsigned)(limit - dicPos); 438 len = (unsigned)(limit - dicPos);
439 439
440 if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len) 440 if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
441 p->checkDicSize = p->prop.dicSize; 441 p->checkDicSize = p->prop.dicSize;
442 442
443 p->processedPos += len; 443 p->processedPos += len;
444 p->remainLen -= len; 444 p->remainLen -= len;
445 while (len-- != 0) 445 while (len-- != 0)
446 { 446 {
447 dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)]; 447 dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
448 dicPos++; 448 dicPos++;
449 } 449 }
450 p->dicPos = dicPos; 450 p->dicPos = dicPos;
451 } 451 }
452} 452}
453 453
454static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit) 454static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
455{ 455{
456 do 456 do
457 { 457 {
458 SizeT limit2 = limit; 458 SizeT limit2 = limit;
459 if (p->checkDicSize == 0) 459 if (p->checkDicSize == 0)
460 { 460 {
461 UInt32 rem = p->prop.dicSize - p->processedPos; 461 UInt32 rem = p->prop.dicSize - p->processedPos;
462 if (limit - p->dicPos > rem) 462 if (limit - p->dicPos > rem)
463 limit2 = p->dicPos + rem; 463 limit2 = p->dicPos + rem;
464 } 464 }
465 RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit)); 465 RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit));
466 if (p->processedPos >= p->prop.dicSize) 466 if (p->processedPos >= p->prop.dicSize)
467 p->checkDicSize = p->prop.dicSize; 467 p->checkDicSize = p->prop.dicSize;
468 LzmaDec_WriteRem(p, limit); 468 LzmaDec_WriteRem(p, limit);
469 } 469 }
470 while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart); 470 while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
471 471
472 if (p->remainLen > kMatchSpecLenStart) 472 if (p->remainLen > kMatchSpecLenStart)
473 { 473 {
474 p->remainLen = kMatchSpecLenStart; 474 p->remainLen = kMatchSpecLenStart;
475 } 475 }
476 return 0; 476 return 0;
477} 477}
478 478
479typedef enum 479typedef enum
480{ 480{
481 DUMMY_ERROR, /* unexpected end of input stream */ 481 DUMMY_ERROR, /* unexpected end of input stream */
482 DUMMY_LIT, 482 DUMMY_LIT,
483 DUMMY_MATCH, 483 DUMMY_MATCH,
484 DUMMY_REP 484 DUMMY_REP
485} ELzmaDummy; 485} ELzmaDummy;
486 486
487static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize) 487static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
488{ 488{
489 UInt32 range = p->range; 489 UInt32 range = p->range;
490 UInt32 code = p->code; 490 UInt32 code = p->code;
491 const Byte *bufLimit = buf + inSize; 491 const Byte *bufLimit = buf + inSize;
492 CLzmaProb *probs = p->probs; 492 CLzmaProb *probs = p->probs;
493 unsigned state = p->state; 493 unsigned state = p->state;
494 ELzmaDummy res; 494 ELzmaDummy res;
495 495
496 { 496 {
497 CLzmaProb *prob; 497 CLzmaProb *prob;
498 UInt32 bound; 498 UInt32 bound;
499 unsigned ttt; 499 unsigned ttt;
500 unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1); 500 unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
501 501
502 prob = probs + IsMatch + (state << kNumPosBitsMax) + posState; 502 prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
503 IF_BIT_0_CHECK(prob) 503 IF_BIT_0_CHECK(prob)
504 { 504 {
505 UPDATE_0_CHECK 505 UPDATE_0_CHECK
506 506
507 /* if (bufLimit - buf >= 7) return DUMMY_LIT; */ 507 /* if (bufLimit - buf >= 7) return DUMMY_LIT; */
508 508
509 prob = probs + Literal; 509 prob = probs + Literal;
510 if (p->checkDicSize != 0 || p->processedPos != 0) 510 if (p->checkDicSize != 0 || p->processedPos != 0)
511 prob += (LZMA_LIT_SIZE * 511 prob += (LZMA_LIT_SIZE *
512 ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) + 512 ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
513 (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc)))); 513 (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
514 514
515 if (state < kNumLitStates) 515 if (state < kNumLitStates)
516 { 516 {
517 unsigned symbol = 1; 517 unsigned symbol = 1;
518 do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100); 518 do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);
519 } 519 }
520 else 520 else
521 { 521 {
522 unsigned matchByte = p->dic[p->dicPos - p->reps[0] + 522 unsigned matchByte = p->dic[p->dicPos - p->reps[0] +
523 ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)]; 523 ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];
524 unsigned offs = 0x100; 524 unsigned offs = 0x100;
525 unsigned symbol = 1; 525 unsigned symbol = 1;
526 do 526 do
527 { 527 {
528 unsigned bit; 528 unsigned bit;
529 CLzmaProb *probLit; 529 CLzmaProb *probLit;
530 matchByte <<= 1; 530 matchByte <<= 1;
531 bit = (matchByte & offs); 531 bit = (matchByte & offs);
532 probLit = prob + offs + bit + symbol; 532 probLit = prob + offs + bit + symbol;
533 GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit) 533 GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit)
534 } 534 }
535 while (symbol < 0x100); 535 while (symbol < 0x100);
536 } 536 }
537 res = DUMMY_LIT; 537 res = DUMMY_LIT;
538 } 538 }
539 else 539 else
540 { 540 {
541 unsigned len; 541 unsigned len;
542 UPDATE_1_CHECK; 542 UPDATE_1_CHECK;
543 543
544 prob = probs + IsRep + state; 544 prob = probs + IsRep + state;
545 IF_BIT_0_CHECK(prob) 545 IF_BIT_0_CHECK(prob)
546 { 546 {
547 UPDATE_0_CHECK; 547 UPDATE_0_CHECK;
548 state = 0; 548 state = 0;
549 prob = probs + LenCoder; 549 prob = probs + LenCoder;
550 res = DUMMY_MATCH; 550 res = DUMMY_MATCH;
551 } 551 }
552 else 552 else
553 { 553 {
554 UPDATE_1_CHECK; 554 UPDATE_1_CHECK;
555 res = DUMMY_REP; 555 res = DUMMY_REP;
556 prob = probs + IsRepG0 + state; 556 prob = probs + IsRepG0 + state;
557 IF_BIT_0_CHECK(prob) 557 IF_BIT_0_CHECK(prob)
558 { 558 {
559 UPDATE_0_CHECK; 559 UPDATE_0_CHECK;
560 prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState; 560 prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
561 IF_BIT_0_CHECK(prob) 561 IF_BIT_0_CHECK(prob)
562 { 562 {
563 UPDATE_0_CHECK; 563 UPDATE_0_CHECK;
564 NORMALIZE_CHECK; 564 NORMALIZE_CHECK;
565 return DUMMY_REP; 565 return DUMMY_REP;
566 } 566 }
567 else 567 else
568 { 568 {
569 UPDATE_1_CHECK; 569 UPDATE_1_CHECK;
570 } 570 }
571 } 571 }
572 else 572 else
573 { 573 {
574 UPDATE_1_CHECK; 574 UPDATE_1_CHECK;
575 prob = probs + IsRepG1 + state; 575 prob = probs + IsRepG1 + state;
576 IF_BIT_0_CHECK(prob) 576 IF_BIT_0_CHECK(prob)
577 { 577 {
578 UPDATE_0_CHECK; 578 UPDATE_0_CHECK;
579 } 579 }
580 else 580 else
581 { 581 {
582 UPDATE_1_CHECK; 582 UPDATE_1_CHECK;
583 prob = probs + IsRepG2 + state; 583 prob = probs + IsRepG2 + state;
584 IF_BIT_0_CHECK(prob) 584 IF_BIT_0_CHECK(prob)
585 { 585 {
586 UPDATE_0_CHECK; 586 UPDATE_0_CHECK;
587 } 587 }
588 else 588 else
589 { 589 {
590 UPDATE_1_CHECK; 590 UPDATE_1_CHECK;
591 } 591 }
592 } 592 }
593 } 593 }
594 state = kNumStates; 594 state = kNumStates;
595 prob = probs + RepLenCoder; 595 prob = probs + RepLenCoder;
596 } 596 }
597 { 597 {
598 unsigned limit, offset; 598 unsigned limit, offset;
599 CLzmaProb *probLen = prob + LenChoice; 599 CLzmaProb *probLen = prob + LenChoice;
600 IF_BIT_0_CHECK(probLen) 600 IF_BIT_0_CHECK(probLen)
601 { 601 {
602 UPDATE_0_CHECK; 602 UPDATE_0_CHECK;
603 probLen = prob + LenLow + (posState << kLenNumLowBits); 603 probLen = prob + LenLow + (posState << kLenNumLowBits);
604 offset = 0; 604 offset = 0;
605 limit = 1 << kLenNumLowBits; 605 limit = 1 << kLenNumLowBits;
606 } 606 }
607 else 607 else
608 { 608 {
609 UPDATE_1_CHECK; 609 UPDATE_1_CHECK;
610 probLen = prob + LenChoice2; 610 probLen = prob + LenChoice2;
611 IF_BIT_0_CHECK(probLen) 611 IF_BIT_0_CHECK(probLen)
612 { 612 {
613 UPDATE_0_CHECK; 613 UPDATE_0_CHECK;
614 probLen = prob + LenMid + (posState << kLenNumMidBits); 614 probLen = prob + LenMid + (posState << kLenNumMidBits);
615 offset = kLenNumLowSymbols; 615 offset = kLenNumLowSymbols;
616 limit = 1 << kLenNumMidBits; 616 limit = 1 << kLenNumMidBits;
617 } 617 }
618 else 618 else
619 { 619 {
620 UPDATE_1_CHECK; 620 UPDATE_1_CHECK;
621 probLen = prob + LenHigh; 621 probLen = prob + LenHigh;
622 offset = kLenNumLowSymbols + kLenNumMidSymbols; 622 offset = kLenNumLowSymbols + kLenNumMidSymbols;
623 limit = 1 << kLenNumHighBits; 623 limit = 1 << kLenNumHighBits;
624 } 624 }
625 } 625 }
626 TREE_DECODE_CHECK(probLen, limit, len); 626 TREE_DECODE_CHECK(probLen, limit, len);
627 len += offset; 627 len += offset;
628 } 628 }
629 629
630 if (state < 4) 630 if (state < 4)
631 { 631 {
632 unsigned posSlot; 632 unsigned posSlot;
633 prob = probs + PosSlot + 633 prob = probs + PosSlot +
634 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << 634 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
635 kNumPosSlotBits); 635 kNumPosSlotBits);
636 TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot); 636 TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot);
637 if (posSlot >= kStartPosModelIndex) 637 if (posSlot >= kStartPosModelIndex)
638 { 638 {
639 int numDirectBits = ((posSlot >> 1) - 1); 639 int numDirectBits = ((posSlot >> 1) - 1);
640 640
641 /* if (bufLimit - buf >= 8) return DUMMY_MATCH; */ 641 /* if (bufLimit - buf >= 8) return DUMMY_MATCH; */
642 642
643 if (posSlot < kEndPosModelIndex) 643 if (posSlot < kEndPosModelIndex)
644 { 644 {
645 prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1; 645 prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1;
646 } 646 }
647 else 647 else
648 { 648 {
649 numDirectBits -= kNumAlignBits; 649 numDirectBits -= kNumAlignBits;
650 do 650 do
651 { 651 {
652 NORMALIZE_CHECK 652 NORMALIZE_CHECK
653 range >>= 1; 653 range >>= 1;
654 code -= range & (((code - range) >> 31) - 1); 654 code -= range & (((code - range) >> 31) - 1);
655 /* if (code >= range) code -= range; */ 655 /* if (code >= range) code -= range; */
656 } 656 }
657 while (--numDirectBits != 0); 657 while (--numDirectBits != 0);
658 prob = probs + Align; 658 prob = probs + Align;
659 numDirectBits = kNumAlignBits; 659 numDirectBits = kNumAlignBits;
660 } 660 }
661 { 661 {
662 unsigned i = 1; 662 unsigned i = 1;
663 do 663 do
664 { 664 {
665 GET_BIT_CHECK(prob + i, i); 665 GET_BIT_CHECK(prob + i, i);
666 } 666 }
667 while (--numDirectBits != 0); 667 while (--numDirectBits != 0);
668 } 668 }
669 } 669 }
670 } 670 }
671 } 671 }
672 } 672 }
673 NORMALIZE_CHECK; 673 NORMALIZE_CHECK;
674 return res; 674 return res;
675} 675}
676 676
677 677
678static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data) 678static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)
679{ 679{
680 p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]); 680 p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);
681 p->range = 0xFFFFFFFF; 681 p->range = 0xFFFFFFFF;
682 p->needFlush = 0; 682 p->needFlush = 0;
683} 683}
684 684
685void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState) 685void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
686{ 686{
687 p->needFlush = 1; 687 p->needFlush = 1;
688 p->remainLen = 0; 688 p->remainLen = 0;
689 p->tempBufSize = 0; 689 p->tempBufSize = 0;
690 690
691 if (initDic) 691 if (initDic)
692 { 692 {
693 p->processedPos = 0; 693 p->processedPos = 0;
694 p->checkDicSize = 0; 694 p->checkDicSize = 0;
695 p->needInitState = 1; 695 p->needInitState = 1;
696 } 696 }
697 if (initState) 697 if (initState)
698 p->needInitState = 1; 698 p->needInitState = 1;
699} 699}
700 700
701void LzmaDec_Init(CLzmaDec *p) 701void LzmaDec_Init(CLzmaDec *p)
702{ 702{
703 p->dicPos = 0; 703 p->dicPos = 0;
704 LzmaDec_InitDicAndState(p, True, True); 704 LzmaDec_InitDicAndState(p, True, True);
705} 705}
706 706
707static void LzmaDec_InitStateReal(CLzmaDec *p) 707static void LzmaDec_InitStateReal(CLzmaDec *p)
708{ 708{
709 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp)); 709 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));
710 UInt32 i; 710 UInt32 i;
711 CLzmaProb *probs = p->probs; 711 CLzmaProb *probs = p->probs;
712 for (i = 0; i < numProbs; i++) 712 for (i = 0; i < numProbs; i++)
713 probs[i] = kBitModelTotal >> 1; 713 probs[i] = kBitModelTotal >> 1;
714 p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1; 714 p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
715 p->state = 0; 715 p->state = 0;
716 p->needInitState = 0; 716 p->needInitState = 0;
717} 717}
718 718
719SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen, 719SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
720 ELzmaFinishMode finishMode, ELzmaStatus *status) 720 ELzmaFinishMode finishMode, ELzmaStatus *status)
721{ 721{
722 SizeT inSize = *srcLen; 722 SizeT inSize = *srcLen;
723 (*srcLen) = 0; 723 (*srcLen) = 0;
724 LzmaDec_WriteRem(p, dicLimit); 724 LzmaDec_WriteRem(p, dicLimit);
725 725
726 *status = LZMA_STATUS_NOT_SPECIFIED; 726 *status = LZMA_STATUS_NOT_SPECIFIED;
727 727
728 while (p->remainLen != kMatchSpecLenStart) 728 while (p->remainLen != kMatchSpecLenStart)
729 { 729 {
730 int checkEndMarkNow; 730 int checkEndMarkNow;
731 731
732 if (p->needFlush != 0) 732 if (p->needFlush != 0)
733 { 733 {
734 for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--) 734 for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)
735 p->tempBuf[p->tempBufSize++] = *src++; 735 p->tempBuf[p->tempBufSize++] = *src++;
736 if (p->tempBufSize < RC_INIT_SIZE) 736 if (p->tempBufSize < RC_INIT_SIZE)
737 { 737 {
738 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 738 *status = LZMA_STATUS_NEEDS_MORE_INPUT;
739 return SZ_OK; 739 return SZ_OK;
740 } 740 }
741 if (p->tempBuf[0] != 0) 741 if (p->tempBuf[0] != 0)
742 return SZ_ERROR_DATA; 742 return SZ_ERROR_DATA;
743 743
744 LzmaDec_InitRc(p, p->tempBuf); 744 LzmaDec_InitRc(p, p->tempBuf);
745 p->tempBufSize = 0; 745 p->tempBufSize = 0;
746 } 746 }
747 747
748 checkEndMarkNow = 0; 748 checkEndMarkNow = 0;
749 if (p->dicPos >= dicLimit) 749 if (p->dicPos >= dicLimit)
750 { 750 {
751 if (p->remainLen == 0 && p->code == 0) 751 if (p->remainLen == 0 && p->code == 0)
752 { 752 {
753 *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK; 753 *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK;
754 return SZ_OK; 754 return SZ_OK;
755 } 755 }
756 if (finishMode == LZMA_FINISH_ANY) 756 if (finishMode == LZMA_FINISH_ANY)
757 { 757 {
758 *status = LZMA_STATUS_NOT_FINISHED; 758 *status = LZMA_STATUS_NOT_FINISHED;
759 return SZ_OK; 759 return SZ_OK;
760 } 760 }
761 if (p->remainLen != 0) 761 if (p->remainLen != 0)
762 { 762 {
763 *status = LZMA_STATUS_NOT_FINISHED; 763 *status = LZMA_STATUS_NOT_FINISHED;
764 return SZ_ERROR_DATA; 764 return SZ_ERROR_DATA;
765 } 765 }
766 checkEndMarkNow = 1; 766 checkEndMarkNow = 1;
767 } 767 }
768 768
769 if (p->needInitState) 769 if (p->needInitState)
770 LzmaDec_InitStateReal(p); 770 LzmaDec_InitStateReal(p);
771 771
772 if (p->tempBufSize == 0) 772 if (p->tempBufSize == 0)
773 { 773 {
774 SizeT processed; 774 SizeT processed;
775 const Byte *bufLimit; 775 const Byte *bufLimit;
776 if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow) 776 if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
777 { 777 {
778 int dummyRes = LzmaDec_TryDummy(p, src, inSize); 778 int dummyRes = LzmaDec_TryDummy(p, src, inSize);
779 if (dummyRes == DUMMY_ERROR) 779 if (dummyRes == DUMMY_ERROR)
780 { 780 {
781 memcpy(p->tempBuf, src, inSize); 781 memcpy(p->tempBuf, src, inSize);
782 p->tempBufSize = (unsigned)inSize; 782 p->tempBufSize = (unsigned)inSize;
783 (*srcLen) += inSize; 783 (*srcLen) += inSize;
784 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 784 *status = LZMA_STATUS_NEEDS_MORE_INPUT;
785 return SZ_OK; 785 return SZ_OK;
786 } 786 }
787 if (checkEndMarkNow && dummyRes != DUMMY_MATCH) 787 if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
788 { 788 {
789 *status = LZMA_STATUS_NOT_FINISHED; 789 *status = LZMA_STATUS_NOT_FINISHED;
790 return SZ_ERROR_DATA; 790 return SZ_ERROR_DATA;
791 } 791 }
792 bufLimit = src; 792 bufLimit = src;
793 } 793 }
794 else 794 else
795 bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX; 795 bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;
796 p->buf = src; 796 p->buf = src;
797 if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0) 797 if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
798 return SZ_ERROR_DATA; 798 return SZ_ERROR_DATA;
799 processed = (SizeT)(p->buf - src); 799 processed = (SizeT)(p->buf - src);
800 (*srcLen) += processed; 800 (*srcLen) += processed;
801 src += processed; 801 src += processed;
802 inSize -= processed; 802 inSize -= processed;
803 } 803 }
804 else 804 else
805 { 805 {
806 unsigned rem = p->tempBufSize, lookAhead = 0; 806 unsigned rem = p->tempBufSize, lookAhead = 0;
807 while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize) 807 while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize)
808 p->tempBuf[rem++] = src[lookAhead++]; 808 p->tempBuf[rem++] = src[lookAhead++];
809 p->tempBufSize = rem; 809 p->tempBufSize = rem;
810 if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow) 810 if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
811 { 811 {
812 int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem); 812 int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem);
813 if (dummyRes == DUMMY_ERROR) 813 if (dummyRes == DUMMY_ERROR)
814 { 814 {
815 (*srcLen) += lookAhead; 815 (*srcLen) += lookAhead;
816 *status = LZMA_STATUS_NEEDS_MORE_INPUT; 816 *status = LZMA_STATUS_NEEDS_MORE_INPUT;
817 return SZ_OK; 817 return SZ_OK;
818 } 818 }
819 if (checkEndMarkNow && dummyRes != DUMMY_MATCH) 819 if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
820 { 820 {
821 *status = LZMA_STATUS_NOT_FINISHED; 821 *status = LZMA_STATUS_NOT_FINISHED;
822 return SZ_ERROR_DATA; 822 return SZ_ERROR_DATA;
823 } 823 }
824 } 824 }
825 p->buf = p->tempBuf; 825 p->buf = p->tempBuf;
826 if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0) 826 if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
827 return SZ_ERROR_DATA; 827 return SZ_ERROR_DATA;
828 lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf)); 828 lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf));
829 (*srcLen) += lookAhead; 829 (*srcLen) += lookAhead;
830 src += lookAhead; 830 src += lookAhead;
831 inSize -= lookAhead; 831 inSize -= lookAhead;
832 p->tempBufSize = 0; 832 p->tempBufSize = 0;
833 } 833 }
834 } 834 }
835 if (p->code == 0) 835 if (p->code == 0)
836 *status = LZMA_STATUS_FINISHED_WITH_MARK; 836 *status = LZMA_STATUS_FINISHED_WITH_MARK;
837 return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA; 837 return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
838} 838}
839 839
840SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) 840SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
841{ 841{
842 SizeT outSize = *destLen; 842 SizeT outSize = *destLen;
843 SizeT inSize = *srcLen; 843 SizeT inSize = *srcLen;
844 *srcLen = *destLen = 0; 844 *srcLen = *destLen = 0;
845 for (;;) 845 for (;;)
846 { 846 {
847 SizeT inSizeCur = inSize, outSizeCur, dicPos; 847 SizeT inSizeCur = inSize, outSizeCur, dicPos;
848 ELzmaFinishMode curFinishMode; 848 ELzmaFinishMode curFinishMode;
849 SRes res; 849 SRes res;
850 if (p->dicPos == p->dicBufSize) 850 if (p->dicPos == p->dicBufSize)
851 p->dicPos = 0; 851 p->dicPos = 0;
852 dicPos = p->dicPos; 852 dicPos = p->dicPos;
853 if (outSize > p->dicBufSize - dicPos) 853 if (outSize > p->dicBufSize - dicPos)
854 { 854 {
855 outSizeCur = p->dicBufSize; 855 outSizeCur = p->dicBufSize;
856 curFinishMode = LZMA_FINISH_ANY; 856 curFinishMode = LZMA_FINISH_ANY;
857 } 857 }
858 else 858 else
859 { 859 {
860 outSizeCur = dicPos + outSize; 860 outSizeCur = dicPos + outSize;
861 curFinishMode = finishMode; 861 curFinishMode = finishMode;
862 } 862 }
863 863
864 res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status); 864 res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);
865 src += inSizeCur; 865 src += inSizeCur;
866 inSize -= inSizeCur; 866 inSize -= inSizeCur;
867 *srcLen += inSizeCur; 867 *srcLen += inSizeCur;
868 outSizeCur = p->dicPos - dicPos; 868 outSizeCur = p->dicPos - dicPos;
869 memcpy(dest, p->dic + dicPos, outSizeCur); 869 memcpy(dest, p->dic + dicPos, outSizeCur);
870 dest += outSizeCur; 870 dest += outSizeCur;
871 outSize -= outSizeCur; 871 outSize -= outSizeCur;
872 *destLen += outSizeCur; 872 *destLen += outSizeCur;
873 if (res != 0) 873 if (res != 0)
874 return res; 874 return res;
875 if (outSizeCur == 0 || outSize == 0) 875 if (outSizeCur == 0 || outSize == 0)
876 return SZ_OK; 876 return SZ_OK;
877 } 877 }
878} 878}
879 879
880void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc) 880void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
881{ 881{
882 alloc->Free(alloc, p->probs); 882 alloc->Free(alloc, p->probs);
883 p->probs = 0; 883 p->probs = 0;
884} 884}
885 885
886static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc) 886static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)
887{ 887{
888 alloc->Free(alloc, p->dic); 888 alloc->Free(alloc, p->dic);
889 p->dic = 0; 889 p->dic = 0;
890} 890}
891 891
892void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc) 892void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
893{ 893{
894 LzmaDec_FreeProbs(p, alloc); 894 LzmaDec_FreeProbs(p, alloc);
895 LzmaDec_FreeDict(p, alloc); 895 LzmaDec_FreeDict(p, alloc);
896} 896}
897 897
898SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size) 898SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
899{ 899{
900 UInt32 dicSize; 900 UInt32 dicSize;
901 Byte d; 901 Byte d;
902 902
903 if (size < LZMA_PROPS_SIZE) 903 if (size < LZMA_PROPS_SIZE)
904 return SZ_ERROR_UNSUPPORTED; 904 return SZ_ERROR_UNSUPPORTED;
905 else 905 else
906 dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24); 906 dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
907 907
908 if (dicSize < LZMA_DIC_MIN) 908 if (dicSize < LZMA_DIC_MIN)
909 dicSize = LZMA_DIC_MIN; 909 dicSize = LZMA_DIC_MIN;
910 p->dicSize = dicSize; 910 p->dicSize = dicSize;
911 911
912 d = data[0]; 912 d = data[0];
913 if (d >= (9 * 5 * 5)) 913 if (d >= (9 * 5 * 5))
914 return SZ_ERROR_UNSUPPORTED; 914 return SZ_ERROR_UNSUPPORTED;
915 915
916 p->lc = d % 9; 916 p->lc = d % 9;
917 d /= 9; 917 d /= 9;
918 p->pb = d / 5; 918 p->pb = d / 5;
919 p->lp = d % 5; 919 p->lp = d % 5;
920 920
921 return SZ_OK; 921 return SZ_OK;
922} 922}
923 923
924static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc) 924static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)
925{ 925{
926 UInt32 numProbs = LzmaProps_GetNumProbs(propNew); 926 UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
927 if (p->probs == 0 || numProbs != p->numProbs) 927 if (p->probs == 0 || numProbs != p->numProbs)
928 { 928 {
929 LzmaDec_FreeProbs(p, alloc); 929 LzmaDec_FreeProbs(p, alloc);
930 p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb)); 930 p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));
931 p->numProbs = numProbs; 931 p->numProbs = numProbs;
932 if (p->probs == 0) 932 if (p->probs == 0)
933 return SZ_ERROR_MEM; 933 return SZ_ERROR_MEM;
934 } 934 }
935 return SZ_OK; 935 return SZ_OK;
936} 936}
937 937
938SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc) 938SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
939{ 939{
940 CLzmaProps propNew; 940 CLzmaProps propNew;
941 RINOK(LzmaProps_Decode(&propNew, props, propsSize)); 941 RINOK(LzmaProps_Decode(&propNew, props, propsSize));
942 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc)); 942 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
943 p->prop = propNew; 943 p->prop = propNew;
944 return SZ_OK; 944 return SZ_OK;
945} 945}
946 946
947SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc) 947SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
948{ 948{
949 CLzmaProps propNew; 949 CLzmaProps propNew;
950 SizeT dicBufSize; 950 SizeT dicBufSize;
951 RINOK(LzmaProps_Decode(&propNew, props, propsSize)); 951 RINOK(LzmaProps_Decode(&propNew, props, propsSize));
952 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc)); 952 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
953 dicBufSize = propNew.dicSize; 953 dicBufSize = propNew.dicSize;
954 if (p->dic == 0 || dicBufSize != p->dicBufSize) 954 if (p->dic == 0 || dicBufSize != p->dicBufSize)
955 { 955 {
956 LzmaDec_FreeDict(p, alloc); 956 LzmaDec_FreeDict(p, alloc);
957 p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize); 957 p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);
958 if (p->dic == 0) 958 if (p->dic == 0)
959 { 959 {
960 LzmaDec_FreeProbs(p, alloc); 960 LzmaDec_FreeProbs(p, alloc);
961 return SZ_ERROR_MEM; 961 return SZ_ERROR_MEM;
962 } 962 }
963 } 963 }
964 p->dicBufSize = dicBufSize; 964 p->dicBufSize = dicBufSize;
965 p->prop = propNew; 965 p->prop = propNew;
966 return SZ_OK; 966 return SZ_OK;
967} 967}
968 968
969SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, 969SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
970 const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode, 970 const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
971 ELzmaStatus *status, ISzAlloc *alloc) 971 ELzmaStatus *status, ISzAlloc *alloc)
972{ 972{
973 CLzmaDec p; 973 CLzmaDec p;
974 SRes res; 974 SRes res;
975 SizeT inSize = *srcLen; 975 SizeT inSize = *srcLen;
976 SizeT outSize = *destLen; 976 SizeT outSize = *destLen;
977 *srcLen = *destLen = 0; 977 *srcLen = *destLen = 0;
978 if (inSize < RC_INIT_SIZE) 978 if (inSize < RC_INIT_SIZE)
979 return SZ_ERROR_INPUT_EOF; 979 return SZ_ERROR_INPUT_EOF;
980 980
981 LzmaDec_Construct(&p); 981 LzmaDec_Construct(&p);
982 res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc); 982 res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);
983 if (res != 0) 983 if (res != 0)
984 return res; 984 return res;
985 p.dic = dest; 985 p.dic = dest;
986 p.dicBufSize = outSize; 986 p.dicBufSize = outSize;
987 987
988 LzmaDec_Init(&p); 988 LzmaDec_Init(&p);
989 989
990 *srcLen = inSize; 990 *srcLen = inSize;
991 res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status); 991 res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
992 992
993 if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT) 993 if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
994 res = SZ_ERROR_INPUT_EOF; 994 res = SZ_ERROR_INPUT_EOF;
995 995
996 (*destLen) = p.dicPos; 996 (*destLen) = p.dicPos;
997 LzmaDec_FreeProbs(&p, alloc); 997 LzmaDec_FreeProbs(&p, alloc);
998 return res; 998 return res;
999} 999}