1
/* LzmaDec.c -- LZMA Decoder
2
2008-11-06 : Igor Pavlov : Public domain */
9
#define kTopValue ((UInt32)1 << kNumTopBits)
11
#define kNumBitModelTotalBits 11
12
#define kBitModelTotal (1 << kNumBitModelTotalBits)
13
#define kNumMoveBits 5
15
#define RC_INIT_SIZE 5
17
#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
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));
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) \
23
{ UPDATE_0(p); i = (i + i); A0; } else \
24
{ UPDATE_1(p); i = (i + i) + 1; A1; }
25
#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;)
27
#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); }
28
#define TREE_DECODE(probs, limit, i) \
29
{ i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }
31
/* #define _LZMA_SIZE_OPT */
34
#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)
36
#define TREE_6_DECODE(probs, i) \
38
TREE_GET_BIT(probs, i); \
39
TREE_GET_BIT(probs, i); \
40
TREE_GET_BIT(probs, i); \
41
TREE_GET_BIT(probs, i); \
42
TREE_GET_BIT(probs, i); \
43
TREE_GET_BIT(probs, i); \
47
#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }
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;
51
#define UPDATE_1_CHECK range -= bound; code -= bound;
52
#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
53
{ UPDATE_0_CHECK; i = (i + i); A0; } else \
54
{ UPDATE_1_CHECK; i = (i + i) + 1; A1; }
55
#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)
56
#define TREE_DECODE_CHECK(probs, limit, i) \
57
{ i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }
60
#define kNumPosBitsMax 4
61
#define kNumPosStatesMax (1 << kNumPosBitsMax)
63
#define kLenNumLowBits 3
64
#define kLenNumLowSymbols (1 << kLenNumLowBits)
65
#define kLenNumMidBits 3
66
#define kLenNumMidSymbols (1 << kLenNumMidBits)
67
#define kLenNumHighBits 8
68
#define kLenNumHighSymbols (1 << kLenNumHighBits)
71
#define LenChoice2 (LenChoice + 1)
72
#define LenLow (LenChoice2 + 1)
73
#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
74
#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
75
#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
79
#define kNumLitStates 7
81
#define kStartPosModelIndex 4
82
#define kEndPosModelIndex 14
83
#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
85
#define kNumPosSlotBits 6
86
#define kNumLenToPosStates 4
88
#define kNumAlignBits 4
89
#define kAlignTableSize (1 << kNumAlignBits)
91
#define kMatchMinLen 2
92
#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)
95
#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
96
#define IsRepG0 (IsRep + kNumStates)
97
#define IsRepG1 (IsRepG0 + kNumStates)
98
#define IsRepG2 (IsRepG1 + kNumStates)
99
#define IsRep0Long (IsRepG2 + kNumStates)
100
#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
101
#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
102
#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
103
#define LenCoder (Align + kAlignTableSize)
104
#define RepLenCoder (LenCoder + kNumLenProbs)
105
#define Literal (RepLenCoder + kNumLenProbs)
107
#define LZMA_BASE_SIZE 1846
108
#define LZMA_LIT_SIZE 768
110
#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
112
#if Literal != LZMA_BASE_SIZE
116
static const Byte kLiteralNextStates[kNumStates * 2] =
118
0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5,
119
7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10
122
#define LZMA_DIC_MIN (1 << 12)
124
/* First LZMA-symbol is always decoded.
125
And it decodes new LZMA-symbols while (buf < bufLimit), but "buf" is without last normalization
129
SZ_ERROR_DATA - Error
131
< kMatchSpecLenStart : normal remain
132
= kMatchSpecLenStart : finished
133
= kMatchSpecLenStart + 1 : Flush marker
134
= kMatchSpecLenStart + 2 : State Init Marker
137
static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
139
CLzmaProb *probs = p->probs;
141
unsigned state = p->state;
142
UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
143
unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
144
unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
145
unsigned lc = p->prop.lc;
148
SizeT dicBufSize = p->dicBufSize;
149
SizeT dicPos = p->dicPos;
151
UInt32 processedPos = p->processedPos;
152
UInt32 checkDicSize = p->checkDicSize;
155
const Byte *buf = p->buf;
156
UInt32 range = p->range;
157
UInt32 code = p->code;
164
unsigned posState = processedPos & pbMask;
166
prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
171
prob = probs + Literal;
172
if (checkDicSize != 0 || processedPos != 0)
173
prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) +
174
(dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc))));
176
if (state < kNumLitStates)
179
do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100);
183
unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
184
unsigned offs = 0x100;
191
bit = (matchByte & offs);
192
probLit = prob + offs + bit + symbol;
193
GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)
195
while (symbol < 0x100);
197
dic[dicPos++] = (Byte)symbol;
200
state = kLiteralNextStates[state];
201
/* if (state < 4) state = 0; else if (state < 10) state -= 3; else state -= 6; */
207
prob = probs + IsRep + state;
212
prob = probs + LenCoder;
217
if (checkDicSize == 0 && processedPos == 0)
218
return SZ_ERROR_DATA;
219
prob = probs + IsRepG0 + state;
223
prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
227
dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
230
state = state < kNumLitStates ? 9 : 11;
239
prob = probs + IsRepG1 + state;
248
prob = probs + IsRepG2 + state;
265
state = state < kNumLitStates ? 8 : 11;
266
prob = probs + RepLenCoder;
269
unsigned limit, offset;
270
CLzmaProb *probLen = prob + LenChoice;
274
probLen = prob + LenLow + (posState << kLenNumLowBits);
276
limit = (1 << kLenNumLowBits);
281
probLen = prob + LenChoice2;
285
probLen = prob + LenMid + (posState << kLenNumMidBits);
286
offset = kLenNumLowSymbols;
287
limit = (1 << kLenNumMidBits);
292
probLen = prob + LenHigh;
293
offset = kLenNumLowSymbols + kLenNumMidSymbols;
294
limit = (1 << kLenNumHighBits);
297
TREE_DECODE(probLen, limit, len);
301
if (state >= kNumStates)
304
prob = probs + PosSlot +
305
((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
306
TREE_6_DECODE(prob, distance);
307
if (distance >= kStartPosModelIndex)
309
unsigned posSlot = (unsigned)distance;
310
int numDirectBits = (int)(((distance >> 1) - 1));
311
distance = (2 | (distance & 1));
312
if (posSlot < kEndPosModelIndex)
314
distance <<= numDirectBits;
315
prob = probs + SpecPos + distance - posSlot - 1;
321
GET_BIT2(prob + i, i, ; , distance |= mask);
324
while (--numDirectBits != 0);
329
numDirectBits -= kNumAlignBits;
338
t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */
339
distance = (distance << 1) + (t + 1);
351
while (--numDirectBits != 0);
352
prob = probs + Align;
353
distance <<= kNumAlignBits;
356
GET_BIT2(prob + i, i, ; , distance |= 1);
357
GET_BIT2(prob + i, i, ; , distance |= 2);
358
GET_BIT2(prob + i, i, ; , distance |= 4);
359
GET_BIT2(prob + i, i, ; , distance |= 8);
361
if (distance == (UInt32)0xFFFFFFFF)
363
len += kMatchSpecLenStart;
373
if (checkDicSize == 0)
375
if (distance >= processedPos)
376
return SZ_ERROR_DATA;
378
else if (distance >= checkDicSize)
379
return SZ_ERROR_DATA;
380
state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
381
/* state = kLiteralNextStates[state]; */
387
return SZ_ERROR_DATA;
389
SizeT rem = limit - dicPos;
390
unsigned curLen = ((rem < len) ? (unsigned)rem : len);
391
SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0);
393
processedPos += curLen;
396
if (pos + curLen <= dicBufSize)
398
Byte *dest = dic + dicPos;
399
ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
400
const Byte *lim = dest + curLen;
403
*(dest) = (Byte)*(dest + src);
404
while (++dest != lim);
410
dic[dicPos++] = dic[pos];
411
if (++pos == dicBufSize)
414
while (--curLen != 0);
419
while (dicPos < limit && buf < bufLimit);
426
p->processedPos = processedPos;
436
static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
438
if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
441
SizeT dicPos = p->dicPos;
442
SizeT dicBufSize = p->dicBufSize;
443
unsigned len = p->remainLen;
444
UInt32 rep0 = p->reps[0];
445
if (limit - dicPos < len)
446
len = (unsigned)(limit - dicPos);
448
if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
449
p->checkDicSize = p->prop.dicSize;
451
p->processedPos += len;
455
dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
462
static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
466
SizeT limit2 = limit;
467
if (p->checkDicSize == 0)
469
UInt32 rem = p->prop.dicSize - p->processedPos;
470
if (limit - p->dicPos > rem)
471
limit2 = p->dicPos + rem;
473
RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit));
474
if (p->processedPos >= p->prop.dicSize)
475
p->checkDicSize = p->prop.dicSize;
476
LzmaDec_WriteRem(p, limit);
478
while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
480
if (p->remainLen > kMatchSpecLenStart)
482
p->remainLen = kMatchSpecLenStart;
489
DUMMY_ERROR, /* unexpected end of input stream */
495
static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
497
UInt32 range = p->range;
498
UInt32 code = p->code;
499
const Byte *bufLimit = buf + inSize;
500
CLzmaProb *probs = p->probs;
501
unsigned state = p->state;
508
unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
510
prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
515
/* if (bufLimit - buf >= 7) return DUMMY_LIT; */
517
prob = probs + Literal;
518
if (p->checkDicSize != 0 || p->processedPos != 0)
519
prob += (LZMA_LIT_SIZE *
520
((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
521
(p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
523
if (state < kNumLitStates)
526
do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);
530
unsigned matchByte = p->dic[p->dicPos - p->reps[0] +
531
((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];
532
unsigned offs = 0x100;
539
bit = (matchByte & offs);
540
probLit = prob + offs + bit + symbol;
541
GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit)
543
while (symbol < 0x100);
552
prob = probs + IsRep + state;
557
prob = probs + LenCoder;
564
prob = probs + IsRepG0 + state;
568
prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
583
prob = probs + IsRepG1 + state;
591
prob = probs + IsRepG2 + state;
603
prob = probs + RepLenCoder;
606
unsigned limit, offset;
607
CLzmaProb *probLen = prob + LenChoice;
608
IF_BIT_0_CHECK(probLen)
611
probLen = prob + LenLow + (posState << kLenNumLowBits);
613
limit = 1 << kLenNumLowBits;
618
probLen = prob + LenChoice2;
619
IF_BIT_0_CHECK(probLen)
622
probLen = prob + LenMid + (posState << kLenNumMidBits);
623
offset = kLenNumLowSymbols;
624
limit = 1 << kLenNumMidBits;
629
probLen = prob + LenHigh;
630
offset = kLenNumLowSymbols + kLenNumMidSymbols;
631
limit = 1 << kLenNumHighBits;
634
TREE_DECODE_CHECK(probLen, limit, len);
641
prob = probs + PosSlot +
642
((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
644
TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot);
645
if (posSlot >= kStartPosModelIndex)
647
int numDirectBits = ((posSlot >> 1) - 1);
649
/* if (bufLimit - buf >= 8) return DUMMY_MATCH; */
651
if (posSlot < kEndPosModelIndex)
653
prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1;
657
numDirectBits -= kNumAlignBits;
662
code -= range & (((code - range) >> 31) - 1);
663
/* if (code >= range) code -= range; */
665
while (--numDirectBits != 0);
666
prob = probs + Align;
667
numDirectBits = kNumAlignBits;
673
GET_BIT_CHECK(prob + i, i);
675
while (--numDirectBits != 0);
686
static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)
688
p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);
689
p->range = 0xFFFFFFFF;
693
void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
703
p->needInitState = 1;
706
p->needInitState = 1;
709
void LzmaDec_Init(CLzmaDec *p)
712
LzmaDec_InitDicAndState(p, True, True);
715
static void LzmaDec_InitStateReal(CLzmaDec *p)
717
UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));
719
CLzmaProb *probs = p->probs;
720
for (i = 0; i < numProbs; i++)
721
probs[i] = kBitModelTotal >> 1;
722
p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
724
p->needInitState = 0;
727
SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
728
ELzmaFinishMode finishMode, ELzmaStatus *status)
730
SizeT inSize = *srcLen;
732
LzmaDec_WriteRem(p, dicLimit);
734
*status = LZMA_STATUS_NOT_SPECIFIED;
736
while (p->remainLen != kMatchSpecLenStart)
740
if (p->needFlush != 0)
742
for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)
743
p->tempBuf[p->tempBufSize++] = *src++;
744
if (p->tempBufSize < RC_INIT_SIZE)
746
*status = LZMA_STATUS_NEEDS_MORE_INPUT;
749
if (p->tempBuf[0] != 0)
750
return SZ_ERROR_DATA;
752
LzmaDec_InitRc(p, p->tempBuf);
757
if (p->dicPos >= dicLimit)
759
if (p->remainLen == 0 && p->code == 0)
761
*status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK;
764
if (finishMode == LZMA_FINISH_ANY)
766
*status = LZMA_STATUS_NOT_FINISHED;
769
if (p->remainLen != 0)
771
*status = LZMA_STATUS_NOT_FINISHED;
772
return SZ_ERROR_DATA;
777
if (p->needInitState)
778
LzmaDec_InitStateReal(p);
780
if (p->tempBufSize == 0)
783
const Byte *bufLimit;
784
if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
786
int dummyRes = LzmaDec_TryDummy(p, src, inSize);
787
if (dummyRes == DUMMY_ERROR)
789
memcpy(p->tempBuf, src, inSize);
790
p->tempBufSize = (unsigned)inSize;
792
*status = LZMA_STATUS_NEEDS_MORE_INPUT;
795
if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
797
*status = LZMA_STATUS_NOT_FINISHED;
798
return SZ_ERROR_DATA;
803
bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;
805
if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
806
return SZ_ERROR_DATA;
807
processed = (SizeT)(p->buf - src);
808
(*srcLen) += processed;
814
unsigned rem = p->tempBufSize, lookAhead = 0;
815
while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize)
816
p->tempBuf[rem++] = src[lookAhead++];
817
p->tempBufSize = rem;
818
if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
820
int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem);
821
if (dummyRes == DUMMY_ERROR)
823
(*srcLen) += lookAhead;
824
*status = LZMA_STATUS_NEEDS_MORE_INPUT;
827
if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
829
*status = LZMA_STATUS_NOT_FINISHED;
830
return SZ_ERROR_DATA;
834
if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
835
return SZ_ERROR_DATA;
836
lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf));
837
(*srcLen) += lookAhead;
844
*status = LZMA_STATUS_FINISHED_WITH_MARK;
845
return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
848
SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
850
SizeT outSize = *destLen;
851
SizeT inSize = *srcLen;
852
*srcLen = *destLen = 0;
855
SizeT inSizeCur = inSize, outSizeCur, dicPos;
856
ELzmaFinishMode curFinishMode;
858
if (p->dicPos == p->dicBufSize)
861
if (outSize > p->dicBufSize - dicPos)
863
outSizeCur = p->dicBufSize;
864
curFinishMode = LZMA_FINISH_ANY;
868
outSizeCur = dicPos + outSize;
869
curFinishMode = finishMode;
872
res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);
875
*srcLen += inSizeCur;
876
outSizeCur = p->dicPos - dicPos;
877
memcpy(dest, p->dic + dicPos, outSizeCur);
879
outSize -= outSizeCur;
880
*destLen += outSizeCur;
883
if (outSizeCur == 0 || outSize == 0)
888
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
890
alloc->Free(alloc, p->probs);
894
static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)
896
alloc->Free(alloc, p->dic);
900
void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
902
LzmaDec_FreeProbs(p, alloc);
903
LzmaDec_FreeDict(p, alloc);
906
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
911
if (size < LZMA_PROPS_SIZE)
912
return SZ_ERROR_UNSUPPORTED;
914
dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
916
if (dicSize < LZMA_DIC_MIN)
917
dicSize = LZMA_DIC_MIN;
918
p->dicSize = dicSize;
921
if (d >= (9 * 5 * 5))
922
return SZ_ERROR_UNSUPPORTED;
932
static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)
934
UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
935
if (p->probs == 0 || numProbs != p->numProbs)
937
LzmaDec_FreeProbs(p, alloc);
938
p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));
939
p->numProbs = numProbs;
946
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
949
RINOK(LzmaProps_Decode(&propNew, props, propsSize));
950
RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
955
SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
959
RINOK(LzmaProps_Decode(&propNew, props, propsSize));
960
RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
961
dicBufSize = propNew.dicSize;
962
if (p->dic == 0 || dicBufSize != p->dicBufSize)
964
LzmaDec_FreeDict(p, alloc);
965
p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);
968
LzmaDec_FreeProbs(p, alloc);
972
p->dicBufSize = dicBufSize;
977
SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
978
const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
979
ELzmaStatus *status, ISzAlloc *alloc)
983
SizeT inSize = *srcLen;
984
SizeT outSize = *destLen;
985
*srcLen = *destLen = 0;
986
if (inSize < RC_INIT_SIZE)
987
return SZ_ERROR_INPUT_EOF;
989
LzmaDec_Construct(&p);
990
res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);
994
p.dicBufSize = outSize;
999
res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
1001
if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
1002
res = SZ_ERROR_INPUT_EOF;
1004
(*destLen) = p.dicPos;
1005
LzmaDec_FreeProbs(&p, alloc);