1 /* |
|
2 LzmaDecodeSize.c |
|
3 LZMA Decoder (optimized for Size version) |
|
4 |
|
5 LZMA SDK 4.40 Copyright (c) 1999-2006 Igor Pavlov (2006-05-01) |
|
6 http://www.7-zip.org/ |
|
7 |
|
8 LZMA SDK is licensed under two licenses: |
|
9 1) GNU Lesser General Public License (GNU LGPL) |
|
10 2) Common Public License (CPL) |
|
11 It means that you can select one of these two licenses and |
|
12 follow rules of that license. |
|
13 |
|
14 SPECIAL EXCEPTION: |
|
15 Igor Pavlov, as the author of this code, expressly permits you to |
|
16 statically or dynamically link your code (or bind by name) to the |
|
17 interfaces of this file without subjecting your linked code to the |
|
18 terms of the CPL or GNU LGPL. Any modifications or additions |
|
19 to this file, however, are subject to the LGPL or CPL terms. |
|
20 */ |
|
21 |
|
22 #include "LzmaDecode.h" |
|
23 |
|
24 #define kNumTopBits 24 |
|
25 #define kTopValue ((UInt32)1 << kNumTopBits) |
|
26 |
|
27 #define kNumBitModelTotalBits 11 |
|
28 #define kBitModelTotal (1 << kNumBitModelTotalBits) |
|
29 #define kNumMoveBits 5 |
|
30 |
|
31 typedef struct _CRangeDecoder |
|
32 { |
|
33 const Byte *Buffer; |
|
34 const Byte *BufferLim; |
|
35 UInt32 Range; |
|
36 UInt32 Code; |
|
37 #ifdef _LZMA_IN_CB |
|
38 ILzmaInCallback *InCallback; |
|
39 int Result; |
|
40 #endif |
|
41 int ExtraBytes; |
|
42 } CRangeDecoder; |
|
43 |
|
44 Byte RangeDecoderReadByte(CRangeDecoder *rd) |
|
45 { |
|
46 if (rd->Buffer == rd->BufferLim) |
|
47 { |
|
48 #ifdef _LZMA_IN_CB |
|
49 SizeT size; |
|
50 rd->Result = rd->InCallback->Read(rd->InCallback, &rd->Buffer, &size); |
|
51 rd->BufferLim = rd->Buffer + size; |
|
52 if (size == 0) |
|
53 #endif |
|
54 { |
|
55 rd->ExtraBytes = 1; |
|
56 return 0xFF; |
|
57 } |
|
58 } |
|
59 return (*rd->Buffer++); |
|
60 } |
|
61 |
|
62 /* #define ReadByte (*rd->Buffer++) */ |
|
63 #define ReadByte (RangeDecoderReadByte(rd)) |
|
64 |
|
65 void RangeDecoderInit(CRangeDecoder *rd |
|
66 #ifndef _LZMA_IN_CB |
|
67 , const Byte *stream, SizeT bufferSize |
|
68 #endif |
|
69 ) |
|
70 { |
|
71 int i; |
|
72 #ifdef _LZMA_IN_CB |
|
73 rd->Buffer = rd->BufferLim = 0; |
|
74 #else |
|
75 rd->Buffer = stream; |
|
76 rd->BufferLim = stream + bufferSize; |
|
77 #endif |
|
78 rd->ExtraBytes = 0; |
|
79 rd->Code = 0; |
|
80 rd->Range = (0xFFFFFFFF); |
|
81 for(i = 0; i < 5; i++) |
|
82 rd->Code = (rd->Code << 8) | ReadByte; |
|
83 } |
|
84 |
|
85 #define RC_INIT_VAR UInt32 range = rd->Range; UInt32 code = rd->Code; |
|
86 #define RC_FLUSH_VAR rd->Range = range; rd->Code = code; |
|
87 #define RC_NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | ReadByte; } |
|
88 |
|
89 UInt32 RangeDecoderDecodeDirectBits(CRangeDecoder *rd, int numTotalBits) |
|
90 { |
|
91 RC_INIT_VAR |
|
92 UInt32 result = 0; |
|
93 int i; |
|
94 for (i = numTotalBits; i != 0; i--) |
|
95 { |
|
96 /* UInt32 t; */ |
|
97 range >>= 1; |
|
98 |
|
99 result <<= 1; |
|
100 if (code >= range) |
|
101 { |
|
102 code -= range; |
|
103 result |= 1; |
|
104 } |
|
105 /* |
|
106 t = (code - range) >> 31; |
|
107 t &= 1; |
|
108 code -= range & (t - 1); |
|
109 result = (result + result) | (1 - t); |
|
110 */ |
|
111 RC_NORMALIZE |
|
112 } |
|
113 RC_FLUSH_VAR |
|
114 return result; |
|
115 } |
|
116 |
|
117 int RangeDecoderBitDecode(CProb *prob, CRangeDecoder *rd) |
|
118 { |
|
119 UInt32 bound = (rd->Range >> kNumBitModelTotalBits) * *prob; |
|
120 if (rd->Code < bound) |
|
121 { |
|
122 rd->Range = bound; |
|
123 *prob += (kBitModelTotal - *prob) >> kNumMoveBits; |
|
124 if (rd->Range < kTopValue) |
|
125 { |
|
126 rd->Code = (rd->Code << 8) | ReadByte; |
|
127 rd->Range <<= 8; |
|
128 } |
|
129 return 0; |
|
130 } |
|
131 else |
|
132 { |
|
133 rd->Range -= bound; |
|
134 rd->Code -= bound; |
|
135 *prob -= (*prob) >> kNumMoveBits; |
|
136 if (rd->Range < kTopValue) |
|
137 { |
|
138 rd->Code = (rd->Code << 8) | ReadByte; |
|
139 rd->Range <<= 8; |
|
140 } |
|
141 return 1; |
|
142 } |
|
143 } |
|
144 |
|
145 #define RC_GET_BIT2(prob, mi, A0, A1) \ |
|
146 UInt32 bound = (range >> kNumBitModelTotalBits) * *prob; \ |
|
147 if (code < bound) \ |
|
148 { A0; range = bound; *prob += (kBitModelTotal - *prob) >> kNumMoveBits; mi <<= 1; } \ |
|
149 else \ |
|
150 { A1; range -= bound; code -= bound; *prob -= (*prob) >> kNumMoveBits; mi = (mi + mi) + 1; } \ |
|
151 RC_NORMALIZE |
|
152 |
|
153 #define RC_GET_BIT(prob, mi) RC_GET_BIT2(prob, mi, ; , ;) |
|
154 |
|
155 int RangeDecoderBitTreeDecode(CProb *probs, int numLevels, CRangeDecoder *rd) |
|
156 { |
|
157 int mi = 1; |
|
158 int i; |
|
159 #ifdef _LZMA_LOC_OPT |
|
160 RC_INIT_VAR |
|
161 #endif |
|
162 for(i = numLevels; i != 0; i--) |
|
163 { |
|
164 #ifdef _LZMA_LOC_OPT |
|
165 CProb *prob = probs + mi; |
|
166 RC_GET_BIT(prob, mi) |
|
167 #else |
|
168 mi = (mi + mi) + RangeDecoderBitDecode(probs + mi, rd); |
|
169 #endif |
|
170 } |
|
171 #ifdef _LZMA_LOC_OPT |
|
172 RC_FLUSH_VAR |
|
173 #endif |
|
174 return mi - (1 << numLevels); |
|
175 } |
|
176 |
|
177 int RangeDecoderReverseBitTreeDecode(CProb *probs, int numLevels, CRangeDecoder *rd) |
|
178 { |
|
179 int mi = 1; |
|
180 int i; |
|
181 int symbol = 0; |
|
182 #ifdef _LZMA_LOC_OPT |
|
183 RC_INIT_VAR |
|
184 #endif |
|
185 for(i = 0; i < numLevels; i++) |
|
186 { |
|
187 #ifdef _LZMA_LOC_OPT |
|
188 CProb *prob = probs + mi; |
|
189 RC_GET_BIT2(prob, mi, ; , symbol |= (1 << i)) |
|
190 #else |
|
191 int bit = RangeDecoderBitDecode(probs + mi, rd); |
|
192 mi = mi + mi + bit; |
|
193 symbol |= (bit << i); |
|
194 #endif |
|
195 } |
|
196 #ifdef _LZMA_LOC_OPT |
|
197 RC_FLUSH_VAR |
|
198 #endif |
|
199 return symbol; |
|
200 } |
|
201 |
|
202 Byte LzmaLiteralDecode(CProb *probs, CRangeDecoder *rd) |
|
203 { |
|
204 int symbol = 1; |
|
205 #ifdef _LZMA_LOC_OPT |
|
206 RC_INIT_VAR |
|
207 #endif |
|
208 do |
|
209 { |
|
210 #ifdef _LZMA_LOC_OPT |
|
211 CProb *prob = probs + symbol; |
|
212 RC_GET_BIT(prob, symbol) |
|
213 #else |
|
214 symbol = (symbol + symbol) | RangeDecoderBitDecode(probs + symbol, rd); |
|
215 #endif |
|
216 } |
|
217 while (symbol < 0x100); |
|
218 #ifdef _LZMA_LOC_OPT |
|
219 RC_FLUSH_VAR |
|
220 #endif |
|
221 return symbol; |
|
222 } |
|
223 |
|
224 Byte LzmaLiteralDecodeMatch(CProb *probs, CRangeDecoder *rd, Byte matchByte) |
|
225 { |
|
226 int symbol = 1; |
|
227 #ifdef _LZMA_LOC_OPT |
|
228 RC_INIT_VAR |
|
229 #endif |
|
230 do |
|
231 { |
|
232 int bit; |
|
233 int matchBit = (matchByte >> 7) & 1; |
|
234 matchByte <<= 1; |
|
235 #ifdef _LZMA_LOC_OPT |
|
236 { |
|
237 CProb *prob = probs + 0x100 + (matchBit << 8) + symbol; |
|
238 RC_GET_BIT2(prob, symbol, bit = 0, bit = 1) |
|
239 } |
|
240 #else |
|
241 bit = RangeDecoderBitDecode(probs + 0x100 + (matchBit << 8) + symbol, rd); |
|
242 symbol = (symbol << 1) | bit; |
|
243 #endif |
|
244 if (matchBit != bit) |
|
245 { |
|
246 while (symbol < 0x100) |
|
247 { |
|
248 #ifdef _LZMA_LOC_OPT |
|
249 CProb *prob = probs + symbol; |
|
250 RC_GET_BIT(prob, symbol) |
|
251 #else |
|
252 symbol = (symbol + symbol) | RangeDecoderBitDecode(probs + symbol, rd); |
|
253 #endif |
|
254 } |
|
255 break; |
|
256 } |
|
257 } |
|
258 while (symbol < 0x100); |
|
259 #ifdef _LZMA_LOC_OPT |
|
260 RC_FLUSH_VAR |
|
261 #endif |
|
262 return symbol; |
|
263 } |
|
264 |
|
265 #define kNumPosBitsMax 4 |
|
266 #define kNumPosStatesMax (1 << kNumPosBitsMax) |
|
267 |
|
268 #define kLenNumLowBits 3 |
|
269 #define kLenNumLowSymbols (1 << kLenNumLowBits) |
|
270 #define kLenNumMidBits 3 |
|
271 #define kLenNumMidSymbols (1 << kLenNumMidBits) |
|
272 #define kLenNumHighBits 8 |
|
273 #define kLenNumHighSymbols (1 << kLenNumHighBits) |
|
274 |
|
275 #define LenChoice 0 |
|
276 #define LenChoice2 (LenChoice + 1) |
|
277 #define LenLow (LenChoice2 + 1) |
|
278 #define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits)) |
|
279 #define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits)) |
|
280 #define kNumLenProbs (LenHigh + kLenNumHighSymbols) |
|
281 |
|
282 int LzmaLenDecode(CProb *p, CRangeDecoder *rd, int posState) |
|
283 { |
|
284 if(RangeDecoderBitDecode(p + LenChoice, rd) == 0) |
|
285 return RangeDecoderBitTreeDecode(p + LenLow + |
|
286 (posState << kLenNumLowBits), kLenNumLowBits, rd); |
|
287 if(RangeDecoderBitDecode(p + LenChoice2, rd) == 0) |
|
288 return kLenNumLowSymbols + RangeDecoderBitTreeDecode(p + LenMid + |
|
289 (posState << kLenNumMidBits), kLenNumMidBits, rd); |
|
290 return kLenNumLowSymbols + kLenNumMidSymbols + |
|
291 RangeDecoderBitTreeDecode(p + LenHigh, kLenNumHighBits, rd); |
|
292 } |
|
293 |
|
294 #define kNumStates 12 |
|
295 #define kNumLitStates 7 |
|
296 |
|
297 #define kStartPosModelIndex 4 |
|
298 #define kEndPosModelIndex 14 |
|
299 #define kNumFullDistances (1 << (kEndPosModelIndex >> 1)) |
|
300 |
|
301 #define kNumPosSlotBits 6 |
|
302 #define kNumLenToPosStates 4 |
|
303 |
|
304 #define kNumAlignBits 4 |
|
305 #define kAlignTableSize (1 << kNumAlignBits) |
|
306 |
|
307 #define kMatchMinLen 2 |
|
308 |
|
309 #define IsMatch 0 |
|
310 #define IsRep (IsMatch + (kNumStates << kNumPosBitsMax)) |
|
311 #define IsRepG0 (IsRep + kNumStates) |
|
312 #define IsRepG1 (IsRepG0 + kNumStates) |
|
313 #define IsRepG2 (IsRepG1 + kNumStates) |
|
314 #define IsRep0Long (IsRepG2 + kNumStates) |
|
315 #define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax)) |
|
316 #define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits)) |
|
317 #define Align (SpecPos + kNumFullDistances - kEndPosModelIndex) |
|
318 #define LenCoder (Align + kAlignTableSize) |
|
319 #define RepLenCoder (LenCoder + kNumLenProbs) |
|
320 #define Literal (RepLenCoder + kNumLenProbs) |
|
321 |
|
322 #if Literal != LZMA_BASE_SIZE |
|
323 StopCompilingDueBUG |
|
324 #endif |
|
325 |
|
326 int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size) |
|
327 { |
|
328 unsigned char prop0; |
|
329 if (size < LZMA_PROPERTIES_SIZE) |
|
330 return LZMA_RESULT_DATA_ERROR; |
|
331 prop0 = propsData[0]; |
|
332 if (prop0 >= (9 * 5 * 5)) |
|
333 return LZMA_RESULT_DATA_ERROR; |
|
334 { |
|
335 for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5)); |
|
336 for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9); |
|
337 propsRes->lc = prop0; |
|
338 /* |
|
339 unsigned char remainder = (unsigned char)(prop0 / 9); |
|
340 propsRes->lc = prop0 % 9; |
|
341 propsRes->pb = remainder / 5; |
|
342 propsRes->lp = remainder % 5; |
|
343 */ |
|
344 } |
|
345 |
|
346 #ifdef _LZMA_OUT_READ |
|
347 { |
|
348 int i; |
|
349 propsRes->DictionarySize = 0; |
|
350 for (i = 0; i < 4; i++) |
|
351 propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8); |
|
352 if (propsRes->DictionarySize == 0) |
|
353 propsRes->DictionarySize = 1; |
|
354 } |
|
355 #endif |
|
356 return LZMA_RESULT_OK; |
|
357 } |
|
358 |
|
359 #define kLzmaStreamWasFinishedId (-1) |
|
360 |
|
361 int LzmaDecode(CLzmaDecoderState *vs, |
|
362 #ifdef _LZMA_IN_CB |
|
363 ILzmaInCallback *InCallback, |
|
364 #else |
|
365 const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed, |
|
366 #endif |
|
367 unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed) |
|
368 { |
|
369 CProb *p = vs->Probs; |
|
370 SizeT nowPos = 0; |
|
371 Byte previousByte = 0; |
|
372 UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1; |
|
373 UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1; |
|
374 int lc = vs->Properties.lc; |
|
375 CRangeDecoder rd; |
|
376 |
|
377 #ifdef _LZMA_OUT_READ |
|
378 |
|
379 int state = vs->State; |
|
380 UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3]; |
|
381 int len = vs->RemainLen; |
|
382 UInt32 globalPos = vs->GlobalPos; |
|
383 UInt32 distanceLimit = vs->DistanceLimit; |
|
384 |
|
385 Byte *dictionary = vs->Dictionary; |
|
386 UInt32 dictionarySize = vs->Properties.DictionarySize; |
|
387 UInt32 dictionaryPos = vs->DictionaryPos; |
|
388 |
|
389 Byte tempDictionary[4]; |
|
390 |
|
391 rd.Range = vs->Range; |
|
392 rd.Code = vs->Code; |
|
393 #ifdef _LZMA_IN_CB |
|
394 rd.InCallback = InCallback; |
|
395 rd.Buffer = vs->Buffer; |
|
396 rd.BufferLim = vs->BufferLim; |
|
397 #else |
|
398 rd.Buffer = inStream; |
|
399 rd.BufferLim = inStream + inSize; |
|
400 #endif |
|
401 |
|
402 #ifndef _LZMA_IN_CB |
|
403 *inSizeProcessed = 0; |
|
404 #endif |
|
405 *outSizeProcessed = 0; |
|
406 if (len == kLzmaStreamWasFinishedId) |
|
407 return LZMA_RESULT_OK; |
|
408 |
|
409 if (dictionarySize == 0) |
|
410 { |
|
411 dictionary = tempDictionary; |
|
412 dictionarySize = 1; |
|
413 tempDictionary[0] = vs->TempDictionary[0]; |
|
414 } |
|
415 |
|
416 if (len == kLzmaNeedInitId) |
|
417 { |
|
418 { |
|
419 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp)); |
|
420 UInt32 i; |
|
421 for (i = 0; i < numProbs; i++) |
|
422 p[i] = kBitModelTotal >> 1; |
|
423 rep0 = rep1 = rep2 = rep3 = 1; |
|
424 state = 0; |
|
425 globalPos = 0; |
|
426 distanceLimit = 0; |
|
427 dictionaryPos = 0; |
|
428 dictionary[dictionarySize - 1] = 0; |
|
429 RangeDecoderInit(&rd |
|
430 #ifndef _LZMA_IN_CB |
|
431 , inStream, inSize |
|
432 #endif |
|
433 ); |
|
434 #ifdef _LZMA_IN_CB |
|
435 if (rd.Result != LZMA_RESULT_OK) |
|
436 return rd.Result; |
|
437 #endif |
|
438 if (rd.ExtraBytes != 0) |
|
439 return LZMA_RESULT_DATA_ERROR; |
|
440 } |
|
441 len = 0; |
|
442 } |
|
443 while(len != 0 && nowPos < outSize) |
|
444 { |
|
445 UInt32 pos = dictionaryPos - rep0; |
|
446 if (pos >= dictionarySize) |
|
447 pos += dictionarySize; |
|
448 outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos]; |
|
449 if (++dictionaryPos == dictionarySize) |
|
450 dictionaryPos = 0; |
|
451 len--; |
|
452 } |
|
453 if (dictionaryPos == 0) |
|
454 previousByte = dictionary[dictionarySize - 1]; |
|
455 else |
|
456 previousByte = dictionary[dictionaryPos - 1]; |
|
457 |
|
458 #ifdef _LZMA_IN_CB |
|
459 rd.Result = LZMA_RESULT_OK; |
|
460 #endif |
|
461 rd.ExtraBytes = 0; |
|
462 |
|
463 #else /* if !_LZMA_OUT_READ */ |
|
464 |
|
465 int state = 0; |
|
466 UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1; |
|
467 int len = 0; |
|
468 |
|
469 #ifndef _LZMA_IN_CB |
|
470 *inSizeProcessed = 0; |
|
471 #endif |
|
472 *outSizeProcessed = 0; |
|
473 |
|
474 { |
|
475 UInt32 i; |
|
476 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp)); |
|
477 for (i = 0; i < numProbs; i++) |
|
478 p[i] = kBitModelTotal >> 1; |
|
479 } |
|
480 |
|
481 #ifdef _LZMA_IN_CB |
|
482 rd.InCallback = InCallback; |
|
483 #endif |
|
484 RangeDecoderInit(&rd |
|
485 #ifndef _LZMA_IN_CB |
|
486 , inStream, inSize |
|
487 #endif |
|
488 ); |
|
489 |
|
490 #ifdef _LZMA_IN_CB |
|
491 if (rd.Result != LZMA_RESULT_OK) |
|
492 return rd.Result; |
|
493 #endif |
|
494 if (rd.ExtraBytes != 0) |
|
495 return LZMA_RESULT_DATA_ERROR; |
|
496 |
|
497 #endif /* _LZMA_OUT_READ */ |
|
498 |
|
499 |
|
500 while(nowPos < outSize) |
|
501 { |
|
502 int posState = (int)( |
|
503 (nowPos |
|
504 #ifdef _LZMA_OUT_READ |
|
505 + globalPos |
|
506 #endif |
|
507 ) |
|
508 & posStateMask); |
|
509 #ifdef _LZMA_IN_CB |
|
510 if (rd.Result != LZMA_RESULT_OK) |
|
511 return rd.Result; |
|
512 #endif |
|
513 if (rd.ExtraBytes != 0) |
|
514 return LZMA_RESULT_DATA_ERROR; |
|
515 if (RangeDecoderBitDecode(p + IsMatch + (state << kNumPosBitsMax) + posState, &rd) == 0) |
|
516 { |
|
517 CProb *probs = p + Literal + (LZMA_LIT_SIZE * |
|
518 ((( |
|
519 (nowPos |
|
520 #ifdef _LZMA_OUT_READ |
|
521 + globalPos |
|
522 #endif |
|
523 ) |
|
524 & literalPosMask) << lc) + (previousByte >> (8 - lc)))); |
|
525 |
|
526 if (state >= kNumLitStates) |
|
527 { |
|
528 Byte matchByte; |
|
529 #ifdef _LZMA_OUT_READ |
|
530 UInt32 pos = dictionaryPos - rep0; |
|
531 if (pos >= dictionarySize) |
|
532 pos += dictionarySize; |
|
533 matchByte = dictionary[pos]; |
|
534 #else |
|
535 matchByte = outStream[nowPos - rep0]; |
|
536 #endif |
|
537 previousByte = LzmaLiteralDecodeMatch(probs, &rd, matchByte); |
|
538 } |
|
539 else |
|
540 previousByte = LzmaLiteralDecode(probs, &rd); |
|
541 outStream[nowPos++] = previousByte; |
|
542 #ifdef _LZMA_OUT_READ |
|
543 if (distanceLimit < dictionarySize) |
|
544 distanceLimit++; |
|
545 |
|
546 dictionary[dictionaryPos] = previousByte; |
|
547 if (++dictionaryPos == dictionarySize) |
|
548 dictionaryPos = 0; |
|
549 #endif |
|
550 if (state < 4) state = 0; |
|
551 else if (state < 10) state -= 3; |
|
552 else state -= 6; |
|
553 } |
|
554 else |
|
555 { |
|
556 if (RangeDecoderBitDecode(p + IsRep + state, &rd) == 1) |
|
557 { |
|
558 if (RangeDecoderBitDecode(p + IsRepG0 + state, &rd) == 0) |
|
559 { |
|
560 if (RangeDecoderBitDecode(p + IsRep0Long + (state << kNumPosBitsMax) + posState, &rd) == 0) |
|
561 { |
|
562 #ifdef _LZMA_OUT_READ |
|
563 UInt32 pos; |
|
564 #endif |
|
565 |
|
566 #ifdef _LZMA_OUT_READ |
|
567 if (distanceLimit == 0) |
|
568 #else |
|
569 if (nowPos == 0) |
|
570 #endif |
|
571 return LZMA_RESULT_DATA_ERROR; |
|
572 |
|
573 state = state < 7 ? 9 : 11; |
|
574 #ifdef _LZMA_OUT_READ |
|
575 pos = dictionaryPos - rep0; |
|
576 if (pos >= dictionarySize) |
|
577 pos += dictionarySize; |
|
578 previousByte = dictionary[pos]; |
|
579 dictionary[dictionaryPos] = previousByte; |
|
580 if (++dictionaryPos == dictionarySize) |
|
581 dictionaryPos = 0; |
|
582 #else |
|
583 previousByte = outStream[nowPos - rep0]; |
|
584 #endif |
|
585 outStream[nowPos++] = previousByte; |
|
586 |
|
587 #ifdef _LZMA_OUT_READ |
|
588 if (distanceLimit < dictionarySize) |
|
589 distanceLimit++; |
|
590 #endif |
|
591 continue; |
|
592 } |
|
593 } |
|
594 else |
|
595 { |
|
596 UInt32 distance; |
|
597 if(RangeDecoderBitDecode(p + IsRepG1 + state, &rd) == 0) |
|
598 distance = rep1; |
|
599 else |
|
600 { |
|
601 if(RangeDecoderBitDecode(p + IsRepG2 + state, &rd) == 0) |
|
602 distance = rep2; |
|
603 else |
|
604 { |
|
605 distance = rep3; |
|
606 rep3 = rep2; |
|
607 } |
|
608 rep2 = rep1; |
|
609 } |
|
610 rep1 = rep0; |
|
611 rep0 = distance; |
|
612 } |
|
613 len = LzmaLenDecode(p + RepLenCoder, &rd, posState); |
|
614 state = state < 7 ? 8 : 11; |
|
615 } |
|
616 else |
|
617 { |
|
618 int posSlot; |
|
619 rep3 = rep2; |
|
620 rep2 = rep1; |
|
621 rep1 = rep0; |
|
622 state = state < 7 ? 7 : 10; |
|
623 len = LzmaLenDecode(p + LenCoder, &rd, posState); |
|
624 posSlot = RangeDecoderBitTreeDecode(p + PosSlot + |
|
625 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << |
|
626 kNumPosSlotBits), kNumPosSlotBits, &rd); |
|
627 if (posSlot >= kStartPosModelIndex) |
|
628 { |
|
629 int numDirectBits = ((posSlot >> 1) - 1); |
|
630 rep0 = ((2 | ((UInt32)posSlot & 1)) << numDirectBits); |
|
631 if (posSlot < kEndPosModelIndex) |
|
632 { |
|
633 rep0 += RangeDecoderReverseBitTreeDecode( |
|
634 p + SpecPos + rep0 - posSlot - 1, numDirectBits, &rd); |
|
635 } |
|
636 else |
|
637 { |
|
638 rep0 += RangeDecoderDecodeDirectBits(&rd, |
|
639 numDirectBits - kNumAlignBits) << kNumAlignBits; |
|
640 rep0 += RangeDecoderReverseBitTreeDecode(p + Align, kNumAlignBits, &rd); |
|
641 } |
|
642 } |
|
643 else |
|
644 rep0 = posSlot; |
|
645 if (++rep0 == (UInt32)(0)) |
|
646 { |
|
647 /* it's for stream version */ |
|
648 len = kLzmaStreamWasFinishedId; |
|
649 break; |
|
650 } |
|
651 } |
|
652 |
|
653 len += kMatchMinLen; |
|
654 #ifdef _LZMA_OUT_READ |
|
655 if (rep0 > distanceLimit) |
|
656 #else |
|
657 if (rep0 > nowPos) |
|
658 #endif |
|
659 return LZMA_RESULT_DATA_ERROR; |
|
660 |
|
661 #ifdef _LZMA_OUT_READ |
|
662 if (dictionarySize - distanceLimit > (UInt32)len) |
|
663 distanceLimit += len; |
|
664 else |
|
665 distanceLimit = dictionarySize; |
|
666 #endif |
|
667 |
|
668 do |
|
669 { |
|
670 #ifdef _LZMA_OUT_READ |
|
671 UInt32 pos = dictionaryPos - rep0; |
|
672 if (pos >= dictionarySize) |
|
673 pos += dictionarySize; |
|
674 previousByte = dictionary[pos]; |
|
675 dictionary[dictionaryPos] = previousByte; |
|
676 if (++dictionaryPos == dictionarySize) |
|
677 dictionaryPos = 0; |
|
678 #else |
|
679 previousByte = outStream[nowPos - rep0]; |
|
680 #endif |
|
681 len--; |
|
682 outStream[nowPos++] = previousByte; |
|
683 } |
|
684 while(len != 0 && nowPos < outSize); |
|
685 } |
|
686 } |
|
687 |
|
688 |
|
689 #ifdef _LZMA_OUT_READ |
|
690 vs->Range = rd.Range; |
|
691 vs->Code = rd.Code; |
|
692 vs->DictionaryPos = dictionaryPos; |
|
693 vs->GlobalPos = globalPos + (UInt32)nowPos; |
|
694 vs->DistanceLimit = distanceLimit; |
|
695 vs->Reps[0] = rep0; |
|
696 vs->Reps[1] = rep1; |
|
697 vs->Reps[2] = rep2; |
|
698 vs->Reps[3] = rep3; |
|
699 vs->State = state; |
|
700 vs->RemainLen = len; |
|
701 vs->TempDictionary[0] = tempDictionary[0]; |
|
702 #endif |
|
703 |
|
704 #ifdef _LZMA_IN_CB |
|
705 vs->Buffer = rd.Buffer; |
|
706 vs->BufferLim = rd.BufferLim; |
|
707 #else |
|
708 *inSizeProcessed = (SizeT)(rd.Buffer - inStream); |
|
709 #endif |
|
710 *outSizeProcessed = nowPos; |
|
711 return LZMA_RESULT_OK; |
|
712 } |
|