1 /* |
|
2 LzmaDecode.c |
|
3 LZMA Decoder (optimized for Speed 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 #define RC_READ_BYTE (*Buffer++) |
|
32 |
|
33 #define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \ |
|
34 { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }} |
|
35 |
|
36 #ifdef _LZMA_IN_CB |
|
37 |
|
38 #define RC_TEST { if (Buffer == BufferLim) \ |
|
39 { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \ |
|
40 BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }} |
|
41 |
|
42 #define RC_INIT Buffer = BufferLim = 0; RC_INIT2 |
|
43 |
|
44 #else |
|
45 |
|
46 #define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; } |
|
47 |
|
48 #define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2 |
|
49 |
|
50 #endif |
|
51 |
|
52 #define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; } |
|
53 |
|
54 #define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound) |
|
55 #define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits; |
|
56 #define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits; |
|
57 |
|
58 #define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \ |
|
59 { UpdateBit0(p); mi <<= 1; A0; } else \ |
|
60 { UpdateBit1(p); mi = (mi + mi) + 1; A1; } |
|
61 |
|
62 #define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;) |
|
63 |
|
64 #define RangeDecoderBitTreeDecode(probs, numLevels, res) \ |
|
65 { int i = numLevels; res = 1; \ |
|
66 do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \ |
|
67 res -= (1 << numLevels); } |
|
68 |
|
69 |
|
70 #define kNumPosBitsMax 4 |
|
71 #define kNumPosStatesMax (1 << kNumPosBitsMax) |
|
72 |
|
73 #define kLenNumLowBits 3 |
|
74 #define kLenNumLowSymbols (1 << kLenNumLowBits) |
|
75 #define kLenNumMidBits 3 |
|
76 #define kLenNumMidSymbols (1 << kLenNumMidBits) |
|
77 #define kLenNumHighBits 8 |
|
78 #define kLenNumHighSymbols (1 << kLenNumHighBits) |
|
79 |
|
80 #define LenChoice 0 |
|
81 #define LenChoice2 (LenChoice + 1) |
|
82 #define LenLow (LenChoice2 + 1) |
|
83 #define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits)) |
|
84 #define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits)) |
|
85 #define kNumLenProbs (LenHigh + kLenNumHighSymbols) |
|
86 |
|
87 |
|
88 #define kNumStates 12 |
|
89 #define kNumLitStates 7 |
|
90 |
|
91 #define kStartPosModelIndex 4 |
|
92 #define kEndPosModelIndex 14 |
|
93 #define kNumFullDistances (1 << (kEndPosModelIndex >> 1)) |
|
94 |
|
95 #define kNumPosSlotBits 6 |
|
96 #define kNumLenToPosStates 4 |
|
97 |
|
98 #define kNumAlignBits 4 |
|
99 #define kAlignTableSize (1 << kNumAlignBits) |
|
100 |
|
101 #define kMatchMinLen 2 |
|
102 |
|
103 #define IsMatch 0 |
|
104 #define IsRep (IsMatch + (kNumStates << kNumPosBitsMax)) |
|
105 #define IsRepG0 (IsRep + kNumStates) |
|
106 #define IsRepG1 (IsRepG0 + kNumStates) |
|
107 #define IsRepG2 (IsRepG1 + kNumStates) |
|
108 #define IsRep0Long (IsRepG2 + kNumStates) |
|
109 #define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax)) |
|
110 #define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits)) |
|
111 #define Align (SpecPos + kNumFullDistances - kEndPosModelIndex) |
|
112 #define LenCoder (Align + kAlignTableSize) |
|
113 #define RepLenCoder (LenCoder + kNumLenProbs) |
|
114 #define Literal (RepLenCoder + kNumLenProbs) |
|
115 |
|
116 #if Literal != LZMA_BASE_SIZE |
|
117 StopCompilingDueBUG |
|
118 #endif |
|
119 |
|
120 int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size) |
|
121 { |
|
122 unsigned char prop0; |
|
123 if (size < LZMA_PROPERTIES_SIZE) |
|
124 return LZMA_RESULT_DATA_ERROR; |
|
125 prop0 = propsData[0]; |
|
126 if (prop0 >= (9 * 5 * 5)) |
|
127 return LZMA_RESULT_DATA_ERROR; |
|
128 { |
|
129 for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5)); |
|
130 for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9); |
|
131 propsRes->lc = prop0; |
|
132 /* |
|
133 unsigned char remainder = (unsigned char)(prop0 / 9); |
|
134 propsRes->lc = prop0 % 9; |
|
135 propsRes->pb = remainder / 5; |
|
136 propsRes->lp = remainder % 5; |
|
137 */ |
|
138 } |
|
139 |
|
140 #ifdef _LZMA_OUT_READ |
|
141 { |
|
142 int i; |
|
143 propsRes->DictionarySize = 0; |
|
144 for (i = 0; i < 4; i++) |
|
145 propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8); |
|
146 if (propsRes->DictionarySize == 0) |
|
147 propsRes->DictionarySize = 1; |
|
148 } |
|
149 #endif |
|
150 return LZMA_RESULT_OK; |
|
151 } |
|
152 |
|
153 #define kLzmaStreamWasFinishedId (-1) |
|
154 |
|
155 int LzmaDecode(CLzmaDecoderState *vs, |
|
156 #ifdef _LZMA_IN_CB |
|
157 ILzmaInCallback *InCallback, |
|
158 #else |
|
159 const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed, |
|
160 #endif |
|
161 unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed) |
|
162 { |
|
163 CProb *p = vs->Probs; |
|
164 SizeT nowPos = 0; |
|
165 Byte previousByte = 0; |
|
166 UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1; |
|
167 UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1; |
|
168 int lc = vs->Properties.lc; |
|
169 |
|
170 #ifdef _LZMA_OUT_READ |
|
171 |
|
172 UInt32 Range = vs->Range; |
|
173 UInt32 Code = vs->Code; |
|
174 #ifdef _LZMA_IN_CB |
|
175 const Byte *Buffer = vs->Buffer; |
|
176 const Byte *BufferLim = vs->BufferLim; |
|
177 #else |
|
178 const Byte *Buffer = inStream; |
|
179 const Byte *BufferLim = inStream + inSize; |
|
180 #endif |
|
181 int state = vs->State; |
|
182 UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3]; |
|
183 int len = vs->RemainLen; |
|
184 UInt32 globalPos = vs->GlobalPos; |
|
185 UInt32 distanceLimit = vs->DistanceLimit; |
|
186 |
|
187 Byte *dictionary = vs->Dictionary; |
|
188 UInt32 dictionarySize = vs->Properties.DictionarySize; |
|
189 UInt32 dictionaryPos = vs->DictionaryPos; |
|
190 |
|
191 Byte tempDictionary[4]; |
|
192 |
|
193 #ifndef _LZMA_IN_CB |
|
194 *inSizeProcessed = 0; |
|
195 #endif |
|
196 *outSizeProcessed = 0; |
|
197 if (len == kLzmaStreamWasFinishedId) |
|
198 return LZMA_RESULT_OK; |
|
199 |
|
200 if (dictionarySize == 0) |
|
201 { |
|
202 dictionary = tempDictionary; |
|
203 dictionarySize = 1; |
|
204 tempDictionary[0] = vs->TempDictionary[0]; |
|
205 } |
|
206 |
|
207 if (len == kLzmaNeedInitId) |
|
208 { |
|
209 { |
|
210 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp)); |
|
211 UInt32 i; |
|
212 for (i = 0; i < numProbs; i++) |
|
213 p[i] = kBitModelTotal >> 1; |
|
214 rep0 = rep1 = rep2 = rep3 = 1; |
|
215 state = 0; |
|
216 globalPos = 0; |
|
217 distanceLimit = 0; |
|
218 dictionaryPos = 0; |
|
219 dictionary[dictionarySize - 1] = 0; |
|
220 #ifdef _LZMA_IN_CB |
|
221 RC_INIT; |
|
222 #else |
|
223 RC_INIT(inStream, inSize); |
|
224 #endif |
|
225 } |
|
226 len = 0; |
|
227 } |
|
228 while(len != 0 && nowPos < outSize) |
|
229 { |
|
230 UInt32 pos = dictionaryPos - rep0; |
|
231 if (pos >= dictionarySize) |
|
232 pos += dictionarySize; |
|
233 outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos]; |
|
234 if (++dictionaryPos == dictionarySize) |
|
235 dictionaryPos = 0; |
|
236 len--; |
|
237 } |
|
238 if (dictionaryPos == 0) |
|
239 previousByte = dictionary[dictionarySize - 1]; |
|
240 else |
|
241 previousByte = dictionary[dictionaryPos - 1]; |
|
242 |
|
243 #else /* if !_LZMA_OUT_READ */ |
|
244 |
|
245 int state = 0; |
|
246 UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1; |
|
247 int len = 0; |
|
248 const Byte *Buffer; |
|
249 const Byte *BufferLim; |
|
250 UInt32 Range; |
|
251 UInt32 Code; |
|
252 |
|
253 #ifndef _LZMA_IN_CB |
|
254 *inSizeProcessed = 0; |
|
255 #endif |
|
256 *outSizeProcessed = 0; |
|
257 |
|
258 { |
|
259 UInt32 i; |
|
260 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp)); |
|
261 for (i = 0; i < numProbs; i++) |
|
262 p[i] = kBitModelTotal >> 1; |
|
263 } |
|
264 |
|
265 #ifdef _LZMA_IN_CB |
|
266 RC_INIT; |
|
267 #else |
|
268 RC_INIT(inStream, inSize); |
|
269 #endif |
|
270 |
|
271 #endif /* _LZMA_OUT_READ */ |
|
272 |
|
273 while(nowPos < outSize) |
|
274 { |
|
275 CProb *prob; |
|
276 UInt32 bound; |
|
277 int posState = (int)( |
|
278 (nowPos |
|
279 #ifdef _LZMA_OUT_READ |
|
280 + globalPos |
|
281 #endif |
|
282 ) |
|
283 & posStateMask); |
|
284 |
|
285 prob = p + IsMatch + (state << kNumPosBitsMax) + posState; |
|
286 IfBit0(prob) |
|
287 { |
|
288 int symbol = 1; |
|
289 UpdateBit0(prob) |
|
290 prob = p + Literal + (LZMA_LIT_SIZE * |
|
291 ((( |
|
292 (nowPos |
|
293 #ifdef _LZMA_OUT_READ |
|
294 + globalPos |
|
295 #endif |
|
296 ) |
|
297 & literalPosMask) << lc) + (previousByte >> (8 - lc)))); |
|
298 |
|
299 if (state >= kNumLitStates) |
|
300 { |
|
301 int matchByte; |
|
302 #ifdef _LZMA_OUT_READ |
|
303 UInt32 pos = dictionaryPos - rep0; |
|
304 if (pos >= dictionarySize) |
|
305 pos += dictionarySize; |
|
306 matchByte = dictionary[pos]; |
|
307 #else |
|
308 matchByte = outStream[nowPos - rep0]; |
|
309 #endif |
|
310 do |
|
311 { |
|
312 int bit; |
|
313 CProb *probLit; |
|
314 matchByte <<= 1; |
|
315 bit = (matchByte & 0x100); |
|
316 probLit = prob + 0x100 + bit + symbol; |
|
317 RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break) |
|
318 } |
|
319 while (symbol < 0x100); |
|
320 } |
|
321 while (symbol < 0x100) |
|
322 { |
|
323 CProb *probLit = prob + symbol; |
|
324 RC_GET_BIT(probLit, symbol) |
|
325 } |
|
326 previousByte = (Byte)symbol; |
|
327 |
|
328 outStream[nowPos++] = previousByte; |
|
329 #ifdef _LZMA_OUT_READ |
|
330 if (distanceLimit < dictionarySize) |
|
331 distanceLimit++; |
|
332 |
|
333 dictionary[dictionaryPos] = previousByte; |
|
334 if (++dictionaryPos == dictionarySize) |
|
335 dictionaryPos = 0; |
|
336 #endif |
|
337 if (state < 4) state = 0; |
|
338 else if (state < 10) state -= 3; |
|
339 else state -= 6; |
|
340 } |
|
341 else |
|
342 { |
|
343 UpdateBit1(prob); |
|
344 prob = p + IsRep + state; |
|
345 IfBit0(prob) |
|
346 { |
|
347 UpdateBit0(prob); |
|
348 rep3 = rep2; |
|
349 rep2 = rep1; |
|
350 rep1 = rep0; |
|
351 state = state < kNumLitStates ? 0 : 3; |
|
352 prob = p + LenCoder; |
|
353 } |
|
354 else |
|
355 { |
|
356 UpdateBit1(prob); |
|
357 prob = p + IsRepG0 + state; |
|
358 IfBit0(prob) |
|
359 { |
|
360 UpdateBit0(prob); |
|
361 prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState; |
|
362 IfBit0(prob) |
|
363 { |
|
364 #ifdef _LZMA_OUT_READ |
|
365 UInt32 pos; |
|
366 #endif |
|
367 UpdateBit0(prob); |
|
368 |
|
369 #ifdef _LZMA_OUT_READ |
|
370 if (distanceLimit == 0) |
|
371 #else |
|
372 if (nowPos == 0) |
|
373 #endif |
|
374 return LZMA_RESULT_DATA_ERROR; |
|
375 |
|
376 state = state < kNumLitStates ? 9 : 11; |
|
377 #ifdef _LZMA_OUT_READ |
|
378 pos = dictionaryPos - rep0; |
|
379 if (pos >= dictionarySize) |
|
380 pos += dictionarySize; |
|
381 previousByte = dictionary[pos]; |
|
382 dictionary[dictionaryPos] = previousByte; |
|
383 if (++dictionaryPos == dictionarySize) |
|
384 dictionaryPos = 0; |
|
385 #else |
|
386 previousByte = outStream[nowPos - rep0]; |
|
387 #endif |
|
388 outStream[nowPos++] = previousByte; |
|
389 #ifdef _LZMA_OUT_READ |
|
390 if (distanceLimit < dictionarySize) |
|
391 distanceLimit++; |
|
392 #endif |
|
393 |
|
394 continue; |
|
395 } |
|
396 else |
|
397 { |
|
398 UpdateBit1(prob); |
|
399 } |
|
400 } |
|
401 else |
|
402 { |
|
403 UInt32 distance; |
|
404 UpdateBit1(prob); |
|
405 prob = p + IsRepG1 + state; |
|
406 IfBit0(prob) |
|
407 { |
|
408 UpdateBit0(prob); |
|
409 distance = rep1; |
|
410 } |
|
411 else |
|
412 { |
|
413 UpdateBit1(prob); |
|
414 prob = p + IsRepG2 + state; |
|
415 IfBit0(prob) |
|
416 { |
|
417 UpdateBit0(prob); |
|
418 distance = rep2; |
|
419 } |
|
420 else |
|
421 { |
|
422 UpdateBit1(prob); |
|
423 distance = rep3; |
|
424 rep3 = rep2; |
|
425 } |
|
426 rep2 = rep1; |
|
427 } |
|
428 rep1 = rep0; |
|
429 rep0 = distance; |
|
430 } |
|
431 state = state < kNumLitStates ? 8 : 11; |
|
432 prob = p + RepLenCoder; |
|
433 } |
|
434 { |
|
435 int numBits, offset; |
|
436 CProb *probLen = prob + LenChoice; |
|
437 IfBit0(probLen) |
|
438 { |
|
439 UpdateBit0(probLen); |
|
440 probLen = prob + LenLow + (posState << kLenNumLowBits); |
|
441 offset = 0; |
|
442 numBits = kLenNumLowBits; |
|
443 } |
|
444 else |
|
445 { |
|
446 UpdateBit1(probLen); |
|
447 probLen = prob + LenChoice2; |
|
448 IfBit0(probLen) |
|
449 { |
|
450 UpdateBit0(probLen); |
|
451 probLen = prob + LenMid + (posState << kLenNumMidBits); |
|
452 offset = kLenNumLowSymbols; |
|
453 numBits = kLenNumMidBits; |
|
454 } |
|
455 else |
|
456 { |
|
457 UpdateBit1(probLen); |
|
458 probLen = prob + LenHigh; |
|
459 offset = kLenNumLowSymbols + kLenNumMidSymbols; |
|
460 numBits = kLenNumHighBits; |
|
461 } |
|
462 } |
|
463 RangeDecoderBitTreeDecode(probLen, numBits, len); |
|
464 len += offset; |
|
465 } |
|
466 |
|
467 if (state < 4) |
|
468 { |
|
469 int posSlot; |
|
470 state += kNumLitStates; |
|
471 prob = p + PosSlot + |
|
472 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << |
|
473 kNumPosSlotBits); |
|
474 RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot); |
|
475 if (posSlot >= kStartPosModelIndex) |
|
476 { |
|
477 int numDirectBits = ((posSlot >> 1) - 1); |
|
478 rep0 = (2 | ((UInt32)posSlot & 1)); |
|
479 if (posSlot < kEndPosModelIndex) |
|
480 { |
|
481 rep0 <<= numDirectBits; |
|
482 prob = p + SpecPos + rep0 - posSlot - 1; |
|
483 } |
|
484 else |
|
485 { |
|
486 numDirectBits -= kNumAlignBits; |
|
487 do |
|
488 { |
|
489 RC_NORMALIZE |
|
490 Range >>= 1; |
|
491 rep0 <<= 1; |
|
492 if (Code >= Range) |
|
493 { |
|
494 Code -= Range; |
|
495 rep0 |= 1; |
|
496 } |
|
497 } |
|
498 while (--numDirectBits != 0); |
|
499 prob = p + Align; |
|
500 rep0 <<= kNumAlignBits; |
|
501 numDirectBits = kNumAlignBits; |
|
502 } |
|
503 { |
|
504 int i = 1; |
|
505 int mi = 1; |
|
506 do |
|
507 { |
|
508 CProb *prob3 = prob + mi; |
|
509 RC_GET_BIT2(prob3, mi, ; , rep0 |= i); |
|
510 i <<= 1; |
|
511 } |
|
512 while(--numDirectBits != 0); |
|
513 } |
|
514 } |
|
515 else |
|
516 rep0 = posSlot; |
|
517 if (++rep0 == (UInt32)(0)) |
|
518 { |
|
519 /* it's for stream version */ |
|
520 len = kLzmaStreamWasFinishedId; |
|
521 break; |
|
522 } |
|
523 } |
|
524 |
|
525 len += kMatchMinLen; |
|
526 #ifdef _LZMA_OUT_READ |
|
527 if (rep0 > distanceLimit) |
|
528 #else |
|
529 if (rep0 > nowPos) |
|
530 #endif |
|
531 return LZMA_RESULT_DATA_ERROR; |
|
532 |
|
533 #ifdef _LZMA_OUT_READ |
|
534 if (dictionarySize - distanceLimit > (UInt32)len) |
|
535 distanceLimit += len; |
|
536 else |
|
537 distanceLimit = dictionarySize; |
|
538 #endif |
|
539 |
|
540 do |
|
541 { |
|
542 #ifdef _LZMA_OUT_READ |
|
543 UInt32 pos = dictionaryPos - rep0; |
|
544 if (pos >= dictionarySize) |
|
545 pos += dictionarySize; |
|
546 previousByte = dictionary[pos]; |
|
547 dictionary[dictionaryPos] = previousByte; |
|
548 if (++dictionaryPos == dictionarySize) |
|
549 dictionaryPos = 0; |
|
550 #else |
|
551 previousByte = outStream[nowPos - rep0]; |
|
552 #endif |
|
553 len--; |
|
554 outStream[nowPos++] = previousByte; |
|
555 } |
|
556 while(len != 0 && nowPos < outSize); |
|
557 } |
|
558 } |
|
559 RC_NORMALIZE; |
|
560 |
|
561 #ifdef _LZMA_OUT_READ |
|
562 vs->Range = Range; |
|
563 vs->Code = Code; |
|
564 vs->DictionaryPos = dictionaryPos; |
|
565 vs->GlobalPos = globalPos + (UInt32)nowPos; |
|
566 vs->DistanceLimit = distanceLimit; |
|
567 vs->Reps[0] = rep0; |
|
568 vs->Reps[1] = rep1; |
|
569 vs->Reps[2] = rep2; |
|
570 vs->Reps[3] = rep3; |
|
571 vs->State = state; |
|
572 vs->RemainLen = len; |
|
573 vs->TempDictionary[0] = tempDictionary[0]; |
|
574 #endif |
|
575 |
|
576 #ifdef _LZMA_IN_CB |
|
577 vs->Buffer = Buffer; |
|
578 vs->BufferLim = BufferLim; |
|
579 #else |
|
580 *inSizeProcessed = (SizeT)(Buffer - inStream); |
|
581 #endif |
|
582 *outSizeProcessed = nowPos; |
|
583 return LZMA_RESULT_OK; |
|
584 } |
|