1 /* LzmaDec.c -- LZMA Decoder
2 2023-04-07 : Igor Pavlov : Public domain */
8 /* #include "CpuArch.h" */
11 // #define kNumTopBits 24
12 #define kTopValue ((UInt32)1 << 24)
14 #define kNumBitModelTotalBits 11
15 #define kBitModelTotal (1 << kNumBitModelTotalBits)
17 #define RC_INIT_SIZE 5
19 #ifndef Z7_LZMA_DEC_OPT
21 #define kNumMoveBits 5
22 #define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
24 #define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)
25 #define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
26 #define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));
27 #define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \
28 { UPDATE_0(p) i = (i + i); A0; } else \
29 { UPDATE_1(p) i = (i + i) + 1; A1; }
31 #define TREE_GET_BIT(probs, i) { GET_BIT2(probs + i, i, ;, ;); }
33 #define REV_BIT(p, i, A0, A1) IF_BIT_0(p + i) \
34 { UPDATE_0(p + i) A0; } else \
35 { UPDATE_1(p + i) A1; }
36 #define REV_BIT_VAR( p, i, m) REV_BIT(p, i, i += m; m += m, m += m; i += m; )
37 #define REV_BIT_CONST(p, i, m) REV_BIT(p, i, i += m; , i += m * 2; )
38 #define REV_BIT_LAST( p, i, m) REV_BIT(p, i, i -= m , ; )
40 #define TREE_DECODE(probs, limit, i) \
41 { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }
43 /* #define Z7_LZMA_SIZE_OPT */
45 #ifdef Z7_LZMA_SIZE_OPT
46 #define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)
48 #define TREE_6_DECODE(probs, i) \
50 TREE_GET_BIT(probs, i) \
51 TREE_GET_BIT(probs, i) \
52 TREE_GET_BIT(probs, i) \
53 TREE_GET_BIT(probs, i) \
54 TREE_GET_BIT(probs, i) \
55 TREE_GET_BIT(probs, i) \
59 #define NORMAL_LITER_DEC TREE_GET_BIT(prob, symbol)
60 #define MATCHED_LITER_DEC \
61 matchByte += matchByte; \
64 probLit = prob + (offs + bit + symbol); \
65 GET_BIT2(probLit, symbol, offs ^= bit; , ;)
67 #endif // Z7_LZMA_DEC_OPT
70 #define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_INPUT_EOF; range <<= 8; code = (code << 8) | (*buf++); }
72 #define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)
73 #define UPDATE_0_CHECK range = bound;
74 #define UPDATE_1_CHECK range -= bound; code -= bound;
75 #define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
76 { UPDATE_0_CHECK i = (i + i); A0; } else \
77 { UPDATE_1_CHECK i = (i + i) + 1; A1; }
78 #define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)
79 #define TREE_DECODE_CHECK(probs, limit, i) \
80 { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }
83 #define REV_BIT_CHECK(p, i, m) IF_BIT_0_CHECK(p + i) \
84 { UPDATE_0_CHECK i += m; m += m; } else \
85 { UPDATE_1_CHECK m += m; i += m; }
88 #define kNumPosBitsMax 4
89 #define kNumPosStatesMax (1 << kNumPosBitsMax)
91 #define kLenNumLowBits 3
92 #define kLenNumLowSymbols (1 << kLenNumLowBits)
93 #define kLenNumHighBits 8
94 #define kLenNumHighSymbols (1 << kLenNumHighBits)
97 #define LenHigh (LenLow + 2 * (kNumPosStatesMax << kLenNumLowBits))
98 #define kNumLenProbs (LenHigh + kLenNumHighSymbols)
100 #define LenChoice LenLow
101 #define LenChoice2 (LenLow + (1 << kLenNumLowBits))
103 #define kNumStates 12
104 #define kNumStates2 16
105 #define kNumLitStates 7
107 #define kStartPosModelIndex 4
108 #define kEndPosModelIndex 14
109 #define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
111 #define kNumPosSlotBits 6
112 #define kNumLenToPosStates 4
114 #define kNumAlignBits 4
115 #define kAlignTableSize (1 << kNumAlignBits)
117 #define kMatchMinLen 2
118 #define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)
120 #define kMatchSpecLen_Error_Data (1 << 9)
121 #define kMatchSpecLen_Error_Fail (kMatchSpecLen_Error_Data - 1)
123 /* External ASM code needs same CLzmaProb array layout. So don't change it. */
125 /* (probs_1664) is faster and better for code size at some platforms */
127 #ifdef MY_CPU_X86_OR_AMD64
129 #define kStartOffset 1664
130 #define GET_PROBS p->probs_1664
132 #define GET_PROBS p->probs + kStartOffset
134 #define kStartOffset 0
135 #define GET_PROBS p->probs
139 #define SpecPos (-kStartOffset)
140 #define IsRep0Long (SpecPos + kNumFullDistances)
141 #define RepLenCoder (IsRep0Long + (kNumStates2 << kNumPosBitsMax))
142 #define LenCoder (RepLenCoder + kNumLenProbs)
143 #define IsMatch (LenCoder + kNumLenProbs)
144 #define Align (IsMatch + (kNumStates2 << kNumPosBitsMax))
145 #define IsRep (Align + kAlignTableSize)
146 #define IsRepG0 (IsRep + kNumStates)
147 #define IsRepG1 (IsRepG0 + kNumStates)
148 #define IsRepG2 (IsRepG1 + kNumStates)
149 #define PosSlot (IsRepG2 + kNumStates)
150 #define Literal (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
151 #define NUM_BASE_PROBS (Literal + kStartOffset)
153 #if Align != 0 && kStartOffset != 0
154 #error Stop_Compiling_Bad_LZMA_kAlign
157 #if NUM_BASE_PROBS != 1984
158 #error Stop_Compiling_Bad_LZMA_PROBS
162 #define LZMA_LIT_SIZE 0x300
164 #define LzmaProps_GetNumProbs(p) (NUM_BASE_PROBS + ((UInt32)LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
167 #define CALC_POS_STATE(processedPos, pbMask) (((processedPos) & (pbMask)) << 4)
168 #define COMBINED_PS_STATE (posState + state)
169 #define GET_LEN_STATE (posState)
171 #define LZMA_DIC_MIN (1 << 12)
174 p->remainLen : shows status of LZMA decoder:
175 < kMatchSpecLenStart : the number of bytes to be copied with (p->rep0) offset
176 = kMatchSpecLenStart : the LZMA stream was finished with end mark
177 = kMatchSpecLenStart + 1 : need init range coder
178 = kMatchSpecLenStart + 2 : need init range coder and state
179 = kMatchSpecLen_Error_Fail : Internal Code Failure
180 = kMatchSpecLen_Error_Data + [0 ... 273] : LZMA Data Error
183 /* ---------- LZMA_DECODE_REAL ---------- */
185 LzmaDec_DecodeReal_3() can be implemented in external ASM file.
186 3 - is the code compatibility version of that function for check at link time.
189 #define LZMA_DECODE_REAL LzmaDec_DecodeReal_3
194 RangeCoder is normalized
195 if (p->dicPos == limit)
197 LzmaDec_TryDummy() was called before to exclude LITERAL and MATCH-REP cases.
198 So first symbol can be only MATCH-NON-REP. And if that MATCH-NON-REP symbol
199 is not END_OF_PAYALOAD_MARKER, then the function doesn't write any byte to dictionary,
200 the function returns SZ_OK, and the caller can use (p->remainLen) and (p->reps[0]) later.
204 The first LZMA symbol will be decoded in any case.
205 All main checks for limits are at the end of main loop,
206 It decodes additional LZMA-symbols while (p->buf < bufLimit && dicPos < limit),
207 RangeCoder is still without last normalization when (p->buf < bufLimit) is being checked.
208 But if (p->buf < bufLimit), the caller provided at least (LZMA_REQUIRED_INPUT_MAX + 1) bytes for
209 next iteration before limit (bufLimit + LZMA_REQUIRED_INPUT_MAX),
210 that is enough for worst case LZMA symbol with one additional RangeCoder normalization for one bit.
211 So that function never reads bufLimit [LZMA_REQUIRED_INPUT_MAX] byte.
214 RangeCoder is normalized
218 < kMatchSpecLenStart : the number of bytes to be copied with (p->reps[0]) offset
219 = kMatchSpecLenStart : the LZMA stream was finished with end mark
221 SZ_ERROR_DATA - error, when the MATCH-Symbol refers out of dictionary
222 p->remainLen : undefined
223 p->reps[*] : undefined
227 #ifdef Z7_LZMA_DEC_OPT
229 int Z7_FASTCALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit);
234 int Z7_FASTCALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
236 CLzmaProb *probs = GET_PROBS;
237 unsigned state = (unsigned)p->state;
238 UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
239 unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
240 unsigned lc = p->prop.lc;
241 unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);
244 SizeT dicBufSize = p->dicBufSize;
245 SizeT dicPos = p->dicPos;
247 UInt32 processedPos = p->processedPos;
248 UInt32 checkDicSize = p->checkDicSize;
251 const Byte *buf = p->buf;
252 UInt32 range = p->range;
253 UInt32 code = p->code;
260 unsigned posState = CALC_POS_STATE(processedPos, pbMask);
262 prob = probs + IsMatch + COMBINED_PS_STATE;
267 prob = probs + Literal;
268 if (processedPos != 0 || checkDicSize != 0)
269 prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
272 if (state < kNumLitStates)
274 state -= (state < 4) ? state : 3;
276 #ifdef Z7_LZMA_SIZE_OPT
277 do { NORMAL_LITER_DEC } while (symbol < 0x100);
291 unsigned matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
292 unsigned offs = 0x100;
293 state -= (state < 10) ? 3 : 6;
295 #ifdef Z7_LZMA_SIZE_OPT
302 while (symbol < 0x100);
319 dic[dicPos++] = (Byte)symbol;
325 prob = probs + IsRep + state;
330 prob = probs + LenCoder;
335 prob = probs + IsRepG0 + state;
339 prob = probs + IsRep0Long + COMBINED_PS_STATE;
344 // that case was checked before with kBadRepCode
345 // if (checkDicSize == 0 && processedPos == 0) { len = kMatchSpecLen_Error_Data + 1; break; }
346 // The caller doesn't allow (dicPos == limit) case here
347 // so we don't need the following check:
348 // if (dicPos == limit) { state = state < kNumLitStates ? 9 : 11; len = 1; break; }
350 dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
353 state = state < kNumLitStates ? 9 : 11;
362 prob = probs + IsRepG1 + state;
371 prob = probs + IsRepG2 + state;
388 state = state < kNumLitStates ? 8 : 11;
389 prob = probs + RepLenCoder;
392 #ifdef Z7_LZMA_SIZE_OPT
394 unsigned lim, offset;
395 CLzmaProb *probLen = prob + LenChoice;
399 probLen = prob + LenLow + GET_LEN_STATE;
401 lim = (1 << kLenNumLowBits);
406 probLen = prob + LenChoice2;
410 probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);
411 offset = kLenNumLowSymbols;
412 lim = (1 << kLenNumLowBits);
417 probLen = prob + LenHigh;
418 offset = kLenNumLowSymbols * 2;
419 lim = (1 << kLenNumHighBits);
422 TREE_DECODE(probLen, lim, len)
427 CLzmaProb *probLen = prob + LenChoice;
431 probLen = prob + LenLow + GET_LEN_STATE;
433 TREE_GET_BIT(probLen, len)
434 TREE_GET_BIT(probLen, len)
435 TREE_GET_BIT(probLen, len)
441 probLen = prob + LenChoice2;
445 probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);
447 TREE_GET_BIT(probLen, len)
448 TREE_GET_BIT(probLen, len)
449 TREE_GET_BIT(probLen, len)
454 probLen = prob + LenHigh;
455 TREE_DECODE(probLen, (1 << kLenNumHighBits), len)
456 len += kLenNumLowSymbols * 2;
462 if (state >= kNumStates)
465 prob = probs + PosSlot +
466 ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
467 TREE_6_DECODE(prob, distance)
468 if (distance >= kStartPosModelIndex)
470 unsigned posSlot = (unsigned)distance;
471 unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));
472 distance = (2 | (distance & 1));
473 if (posSlot < kEndPosModelIndex)
475 distance <<= numDirectBits;
476 prob = probs + SpecPos;
482 REV_BIT_VAR(prob, distance, m)
484 while (--numDirectBits);
490 numDirectBits -= kNumAlignBits;
499 t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */
500 distance = (distance << 1) + (t + 1);
512 while (--numDirectBits);
513 prob = probs + Align;
514 distance <<= kNumAlignBits;
517 REV_BIT_CONST(prob, i, 1)
518 REV_BIT_CONST(prob, i, 2)
519 REV_BIT_CONST(prob, i, 4)
520 REV_BIT_LAST (prob, i, 8)
523 if (distance == (UInt32)0xFFFFFFFF)
525 len = kMatchSpecLenStart;
536 state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
537 if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))
539 len += kMatchSpecLen_Error_Data + kMatchMinLen;
540 // len = kMatchSpecLen_Error_Data;
541 // len += kMatchMinLen;
553 if ((rem = limit - dicPos) == 0)
556 We stop decoding and return SZ_OK, and we can resume decoding later.
557 Any error conditions can be tested later in caller code.
558 For more strict mode we can stop decoding with error
559 // len += kMatchSpecLen_Error_Data;
564 curLen = ((rem < len) ? (unsigned)rem : len);
565 pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
567 processedPos += (UInt32)curLen;
570 if (curLen <= dicBufSize - pos)
572 Byte *dest = dic + dicPos;
573 ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
574 const Byte *lim = dest + curLen;
575 dicPos += (SizeT)curLen;
577 *(dest) = (Byte)*(dest + src);
578 while (++dest != lim);
584 dic[dicPos++] = dic[pos];
585 if (++pos == dicBufSize)
588 while (--curLen != 0);
593 while (dicPos < limit && buf < bufLimit);
600 p->remainLen = (UInt32)len; // & (kMatchSpecLen_Error_Data - 1); // we can write real length for error matches too.
602 p->processedPos = processedPos;
607 p->state = (UInt32)state;
608 if (len >= kMatchSpecLen_Error_Data)
609 return SZ_ERROR_DATA;
616 static void Z7_FASTCALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
618 unsigned len = (unsigned)p->remainLen;
619 if (len == 0 /* || len >= kMatchSpecLenStart */)
622 SizeT dicPos = p->dicPos;
625 SizeT rep0; /* we use SizeT to avoid the BUG of VC14 for AMD64 */
627 SizeT rem = limit - dicPos;
630 len = (unsigned)(rem);
636 if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
637 p->checkDicSize = p->prop.dicSize;
639 p->processedPos += (UInt32)len;
640 p->remainLen -= (UInt32)len;
643 dicBufSize = p->dicBufSize;
646 dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
656 At staring of new stream we have one of the following symbols:
657 - Literal - is allowed
658 - Non-Rep-Match - is allowed only if it's end marker symbol
659 - Rep-Match - is not allowed
660 We use early check of (RangeCoder:Code) over kBadRepCode to simplify main decoding code
663 #define kRange0 0xFFFFFFFF
664 #define kBound0 ((kRange0 >> kNumBitModelTotalBits) << (kNumBitModelTotalBits - 1))
665 #define kBadRepCode (kBound0 + (((kRange0 - kBound0) >> kNumBitModelTotalBits) << (kNumBitModelTotalBits - 1)))
666 #if kBadRepCode != (0xC0000000 - 0x400)
667 #error Stop_Compiling_Bad_LZMA_Check
672 LzmaDec_DecodeReal2():
673 It calls LZMA_DECODE_REAL() and it adjusts limit according (p->checkDicSize).
675 We correct (p->checkDicSize) after LZMA_DECODE_REAL() and in LzmaDec_WriteRem(),
676 and we support the following state of (p->checkDicSize):
677 if (total_processed < p->prop.dicSize) then
679 (total_processed == p->processedPos)
680 (p->checkDicSize == 0)
683 (p->checkDicSize == p->prop.dicSize)
686 static int Z7_FASTCALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
688 if (p->checkDicSize == 0)
690 UInt32 rem = p->prop.dicSize - p->processedPos;
691 if (limit - p->dicPos > rem)
692 limit = p->dicPos + rem;
695 int res = LZMA_DECODE_REAL(p, limit, bufLimit);
696 if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)
697 p->checkDicSize = p->prop.dicSize;
706 DUMMY_INPUT_EOF, /* need more input data */
713 #define IS_DUMMY_END_MARKER_POSSIBLE(dummyRes) ((dummyRes) == DUMMY_MATCH)
715 static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, const Byte **bufOut)
717 UInt32 range = p->range;
718 UInt32 code = p->code;
719 const Byte *bufLimit = *bufOut;
720 const CLzmaProb *probs = GET_PROBS;
721 unsigned state = (unsigned)p->state;
726 const CLzmaProb *prob;
729 unsigned posState = CALC_POS_STATE(p->processedPos, ((unsigned)1 << p->prop.pb) - 1);
731 prob = probs + IsMatch + COMBINED_PS_STATE;
736 prob = probs + Literal;
737 if (p->checkDicSize != 0 || p->processedPos != 0)
738 prob += ((UInt32)LZMA_LIT_SIZE *
739 ((((p->processedPos) & (((unsigned)1 << (p->prop.lp)) - 1)) << p->prop.lc) +
740 ((unsigned)p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
742 if (state < kNumLitStates)
745 do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);
749 unsigned matchByte = p->dic[p->dicPos - p->reps[0] +
750 (p->dicPos < p->reps[0] ? p->dicBufSize : 0)];
751 unsigned offs = 0x100;
756 const CLzmaProb *probLit;
757 matchByte += matchByte;
760 probLit = prob + (offs + bit + symbol);
761 GET_BIT2_CHECK(probLit, symbol, offs ^= bit; , ; )
763 while (symbol < 0x100);
772 prob = probs + IsRep + state;
777 prob = probs + LenCoder;
784 prob = probs + IsRepG0 + state;
788 prob = probs + IsRep0Long + COMBINED_PS_STATE;
802 prob = probs + IsRepG1 + state;
810 prob = probs + IsRepG2 + state;
822 prob = probs + RepLenCoder;
825 unsigned limit, offset;
826 const CLzmaProb *probLen = prob + LenChoice;
827 IF_BIT_0_CHECK(probLen)
830 probLen = prob + LenLow + GET_LEN_STATE;
832 limit = 1 << kLenNumLowBits;
837 probLen = prob + LenChoice2;
838 IF_BIT_0_CHECK(probLen)
841 probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);
842 offset = kLenNumLowSymbols;
843 limit = 1 << kLenNumLowBits;
848 probLen = prob + LenHigh;
849 offset = kLenNumLowSymbols * 2;
850 limit = 1 << kLenNumHighBits;
853 TREE_DECODE_CHECK(probLen, limit, len)
860 prob = probs + PosSlot +
861 ((len < kNumLenToPosStates - 1 ? len : kNumLenToPosStates - 1) <<
863 TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot)
864 if (posSlot >= kStartPosModelIndex)
866 unsigned numDirectBits = ((posSlot >> 1) - 1);
868 if (posSlot < kEndPosModelIndex)
870 prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits);
874 numDirectBits -= kNumAlignBits;
879 code -= range & (((code - range) >> 31) - 1);
880 /* if (code >= range) code -= range; */
882 while (--numDirectBits);
883 prob = probs + Align;
884 numDirectBits = kNumAlignBits;
891 REV_BIT_CHECK(prob, i, m)
893 while (--numDirectBits);
906 void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState);
907 void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState)
909 p->remainLen = kMatchSpecLenStart + 1;
916 p->remainLen = kMatchSpecLenStart + 2;
919 p->remainLen = kMatchSpecLenStart + 2;
922 void LzmaDec_Init(CLzmaDec *p)
925 LzmaDec_InitDicAndState(p, True, True);
930 LZMA supports optional end_marker.
931 So the decoder can lookahead for one additional LZMA-Symbol to check end_marker.
932 That additional LZMA-Symbol can require up to LZMA_REQUIRED_INPUT_MAX bytes in input stream.
933 When the decoder reaches dicLimit, it looks (finishMode) parameter:
934 if (finishMode == LZMA_FINISH_ANY), the decoder doesn't lookahead
935 if (finishMode != LZMA_FINISH_ANY), the decoder lookahead, if end_marker is possible for current position
937 When the decoder lookahead, and the lookahead symbol is not end_marker, we have two ways:
938 1) Strict mode (default) : the decoder returns SZ_ERROR_DATA.
939 2) The relaxed mode (alternative mode) : we could return SZ_OK, and the caller
940 must check (status) value. The caller can show the error,
941 if the end of stream is expected, and the (status) is noit
942 LZMA_STATUS_FINISHED_WITH_MARK or LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK.
946 #define RETURN_NOT_FINISHED_FOR_FINISH \
947 *status = LZMA_STATUS_NOT_FINISHED; \
948 return SZ_ERROR_DATA; // for strict mode
949 // return SZ_OK; // for relaxed mode
952 SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
953 ELzmaFinishMode finishMode, ELzmaStatus *status)
955 SizeT inSize = *srcLen;
957 *status = LZMA_STATUS_NOT_SPECIFIED;
959 if (p->remainLen > kMatchSpecLenStart)
961 if (p->remainLen > kMatchSpecLenStart + 2)
962 return p->remainLen == kMatchSpecLen_Error_Fail ? SZ_ERROR_FAIL : SZ_ERROR_DATA;
964 for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)
965 p->tempBuf[p->tempBufSize++] = *src++;
966 if (p->tempBufSize != 0 && p->tempBuf[0] != 0)
967 return SZ_ERROR_DATA;
968 if (p->tempBufSize < RC_INIT_SIZE)
970 *status = LZMA_STATUS_NEEDS_MORE_INPUT;
974 ((UInt32)p->tempBuf[1] << 24)
975 | ((UInt32)p->tempBuf[2] << 16)
976 | ((UInt32)p->tempBuf[3] << 8)
977 | ((UInt32)p->tempBuf[4]);
979 if (p->checkDicSize == 0
980 && p->processedPos == 0
981 && p->code >= kBadRepCode)
982 return SZ_ERROR_DATA;
984 p->range = 0xFFFFFFFF;
987 if (p->remainLen > kMatchSpecLenStart + 1)
989 SizeT numProbs = LzmaProps_GetNumProbs(&p->prop);
991 CLzmaProb *probs = p->probs;
992 for (i = 0; i < numProbs; i++)
993 probs[i] = kBitModelTotal >> 1;
994 p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
1003 if (p->remainLen == kMatchSpecLenStart)
1006 return SZ_ERROR_DATA;
1007 *status = LZMA_STATUS_FINISHED_WITH_MARK;
1011 LzmaDec_WriteRem(p, dicLimit);
1014 // (p->remainLen == 0 || p->dicPos == dicLimit)
1016 int checkEndMarkNow = 0;
1018 if (p->dicPos >= dicLimit)
1020 if (p->remainLen == 0 && p->code == 0)
1022 *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK;
1025 if (finishMode == LZMA_FINISH_ANY)
1027 *status = LZMA_STATUS_NOT_FINISHED;
1030 if (p->remainLen != 0)
1032 RETURN_NOT_FINISHED_FOR_FINISH
1034 checkEndMarkNow = 1;
1037 // (p->remainLen == 0)
1039 if (p->tempBufSize == 0)
1041 const Byte *bufLimit;
1042 int dummyProcessed = -1;
1044 if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
1046 const Byte *bufOut = src + inSize;
1048 ELzmaDummy dummyRes = LzmaDec_TryDummy(p, src, &bufOut);
1050 if (dummyRes == DUMMY_INPUT_EOF)
1053 if (inSize >= LZMA_REQUIRED_INPUT_MAX)
1055 (*srcLen) += inSize;
1056 p->tempBufSize = (unsigned)inSize;
1057 for (i = 0; i < inSize; i++)
1058 p->tempBuf[i] = src[i];
1059 *status = LZMA_STATUS_NEEDS_MORE_INPUT;
1063 dummyProcessed = (int)(bufOut - src);
1064 if ((unsigned)dummyProcessed > LZMA_REQUIRED_INPUT_MAX)
1067 if (checkEndMarkNow && !IS_DUMMY_END_MARKER_POSSIBLE(dummyRes))
1070 (*srcLen) += (unsigned)dummyProcessed;
1071 p->tempBufSize = (unsigned)dummyProcessed;
1072 for (i = 0; i < (unsigned)dummyProcessed; i++)
1073 p->tempBuf[i] = src[i];
1074 // p->remainLen = kMatchSpecLen_Error_Data;
1075 RETURN_NOT_FINISHED_FOR_FINISH
1079 // we will decode only one iteration
1082 bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;
1087 int res = LzmaDec_DecodeReal2(p, dicLimit, bufLimit);
1089 SizeT processed = (SizeT)(p->buf - src);
1091 if (dummyProcessed < 0)
1093 if (processed > inSize)
1096 else if ((unsigned)dummyProcessed != processed)
1100 inSize -= processed;
1101 (*srcLen) += processed;
1105 p->remainLen = kMatchSpecLen_Error_Data;
1106 return SZ_ERROR_DATA;
1113 // we have some data in (p->tempBuf)
1114 // in strict mode: tempBufSize is not enough for one Symbol decoding.
1115 // in relaxed mode: tempBufSize not larger than required for one Symbol decoding.
1117 unsigned rem = p->tempBufSize;
1119 int dummyProcessed = -1;
1121 while (rem < LZMA_REQUIRED_INPUT_MAX && ahead < inSize)
1122 p->tempBuf[rem++] = src[ahead++];
1124 // ahead - the size of new data copied from (src) to (p->tempBuf)
1125 // rem - the size of temp buffer including new data from (src)
1127 if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
1129 const Byte *bufOut = p->tempBuf + rem;
1131 ELzmaDummy dummyRes = LzmaDec_TryDummy(p, p->tempBuf, &bufOut);
1133 if (dummyRes == DUMMY_INPUT_EOF)
1135 if (rem >= LZMA_REQUIRED_INPUT_MAX)
1137 p->tempBufSize = rem;
1138 (*srcLen) += (SizeT)ahead;
1139 *status = LZMA_STATUS_NEEDS_MORE_INPUT;
1143 dummyProcessed = (int)(bufOut - p->tempBuf);
1145 if ((unsigned)dummyProcessed < p->tempBufSize)
1148 if (checkEndMarkNow && !IS_DUMMY_END_MARKER_POSSIBLE(dummyRes))
1150 (*srcLen) += (unsigned)dummyProcessed - p->tempBufSize;
1151 p->tempBufSize = (unsigned)dummyProcessed;
1152 // p->remainLen = kMatchSpecLen_Error_Data;
1153 RETURN_NOT_FINISHED_FOR_FINISH
1157 p->buf = p->tempBuf;
1160 // we decode one symbol from (p->tempBuf) here, so the (bufLimit) is equal to (p->buf)
1161 int res = LzmaDec_DecodeReal2(p, dicLimit, p->buf);
1163 SizeT processed = (SizeT)(p->buf - p->tempBuf);
1164 rem = p->tempBufSize;
1166 if (dummyProcessed < 0)
1168 if (processed > LZMA_REQUIRED_INPUT_MAX)
1170 if (processed < rem)
1173 else if ((unsigned)dummyProcessed != processed)
1179 inSize -= processed;
1180 (*srcLen) += processed;
1185 p->remainLen = kMatchSpecLen_Error_Data;
1186 return SZ_ERROR_DATA;
1193 /* Some unexpected error: internal error of code, memory corruption or hardware failure */
1194 p->remainLen = kMatchSpecLen_Error_Fail;
1195 return SZ_ERROR_FAIL;
1200 SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
1202 SizeT outSize = *destLen;
1203 SizeT inSize = *srcLen;
1204 *srcLen = *destLen = 0;
1207 SizeT inSizeCur = inSize, outSizeCur, dicPos;
1208 ELzmaFinishMode curFinishMode;
1210 if (p->dicPos == p->dicBufSize)
1213 if (outSize > p->dicBufSize - dicPos)
1215 outSizeCur = p->dicBufSize;
1216 curFinishMode = LZMA_FINISH_ANY;
1220 outSizeCur = dicPos + outSize;
1221 curFinishMode = finishMode;
1224 res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);
1226 inSize -= inSizeCur;
1227 *srcLen += inSizeCur;
1228 outSizeCur = p->dicPos - dicPos;
1229 memcpy(dest, p->dic + dicPos, outSizeCur);
1231 outSize -= outSizeCur;
1232 *destLen += outSizeCur;
1235 if (outSizeCur == 0 || outSize == 0)
1240 void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc)
1242 ISzAlloc_Free(alloc, p->probs);
1246 static void LzmaDec_FreeDict(CLzmaDec *p, ISzAllocPtr alloc)
1248 ISzAlloc_Free(alloc, p->dic);
1252 void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc)
1254 LzmaDec_FreeProbs(p, alloc);
1255 LzmaDec_FreeDict(p, alloc);
1258 SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
1263 if (size < LZMA_PROPS_SIZE)
1264 return SZ_ERROR_UNSUPPORTED;
1266 dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
1268 if (dicSize < LZMA_DIC_MIN)
1269 dicSize = LZMA_DIC_MIN;
1270 p->dicSize = dicSize;
1273 if (d >= (9 * 5 * 5))
1274 return SZ_ERROR_UNSUPPORTED;
1276 p->lc = (Byte)(d % 9);
1278 p->pb = (Byte)(d / 5);
1279 p->lp = (Byte)(d % 5);
1284 static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAllocPtr alloc)
1286 UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
1287 if (!p->probs || numProbs != p->numProbs)
1289 LzmaDec_FreeProbs(p, alloc);
1290 p->probs = (CLzmaProb *)ISzAlloc_Alloc(alloc, numProbs * sizeof(CLzmaProb));
1292 return SZ_ERROR_MEM;
1293 p->probs_1664 = p->probs + 1664;
1294 p->numProbs = numProbs;
1299 SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)
1302 RINOK(LzmaProps_Decode(&propNew, props, propsSize))
1303 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc))
1308 SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)
1312 RINOK(LzmaProps_Decode(&propNew, props, propsSize))
1313 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc))
1316 UInt32 dictSize = propNew.dicSize;
1317 SizeT mask = ((UInt32)1 << 12) - 1;
1318 if (dictSize >= ((UInt32)1 << 30)) mask = ((UInt32)1 << 22) - 1;
1319 else if (dictSize >= ((UInt32)1 << 22)) mask = ((UInt32)1 << 20) - 1;
1320 dicBufSize = ((SizeT)dictSize + mask) & ~mask;
1321 if (dicBufSize < dictSize)
1322 dicBufSize = dictSize;
1325 if (!p->dic || dicBufSize != p->dicBufSize)
1327 LzmaDec_FreeDict(p, alloc);
1328 p->dic = (Byte *)ISzAlloc_Alloc(alloc, dicBufSize);
1331 LzmaDec_FreeProbs(p, alloc);
1332 return SZ_ERROR_MEM;
1335 p->dicBufSize = dicBufSize;
1340 SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
1341 const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
1342 ELzmaStatus *status, ISzAllocPtr alloc)
1346 SizeT outSize = *destLen, inSize = *srcLen;
1347 *destLen = *srcLen = 0;
1348 *status = LZMA_STATUS_NOT_SPECIFIED;
1349 if (inSize < RC_INIT_SIZE)
1350 return SZ_ERROR_INPUT_EOF;
1351 LzmaDec_CONSTRUCT(&p)
1352 RINOK(LzmaDec_AllocateProbs(&p, propData, propSize, alloc))
1354 p.dicBufSize = outSize;
1357 res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
1358 *destLen = p.dicPos;
1359 if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
1360 res = SZ_ERROR_INPUT_EOF;
1361 LzmaDec_FreeProbs(&p, alloc);