ce188d4d |
1 | /* Lzma2Dec.c -- LZMA2 Decoder\r |
2 | 2015-11-09 : Igor Pavlov : Public domain */\r |
3 | \r |
4 | /* #define SHOW_DEBUG_INFO */\r |
5 | \r |
6 | #include "Precomp.h"\r |
7 | \r |
8 | #ifdef SHOW_DEBUG_INFO\r |
9 | #include <stdio.h>\r |
10 | #endif\r |
11 | \r |
12 | #include <string.h>\r |
13 | \r |
14 | #include "Lzma2Dec.h"\r |
15 | \r |
16 | /*\r |
17 | 00000000 - EOS\r |
18 | 00000001 U U - Uncompressed Reset Dic\r |
19 | 00000010 U U - Uncompressed No Reset\r |
20 | 100uuuuu U U P P - LZMA no reset\r |
21 | 101uuuuu U U P P - LZMA reset state\r |
22 | 110uuuuu U U P P S - LZMA reset state + new prop\r |
23 | 111uuuuu U U P P S - LZMA reset state + new prop + reset dic\r |
24 | \r |
25 | u, U - Unpack Size\r |
26 | P - Pack Size\r |
27 | S - Props\r |
28 | */\r |
29 | \r |
30 | #define LZMA2_CONTROL_LZMA (1 << 7)\r |
31 | #define LZMA2_CONTROL_COPY_NO_RESET 2\r |
32 | #define LZMA2_CONTROL_COPY_RESET_DIC 1\r |
33 | #define LZMA2_CONTROL_EOF 0\r |
34 | \r |
35 | #define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & LZMA2_CONTROL_LZMA) == 0)\r |
36 | \r |
37 | #define LZMA2_GET_LZMA_MODE(p) (((p)->control >> 5) & 3)\r |
38 | #define LZMA2_IS_THERE_PROP(mode) ((mode) >= 2)\r |
39 | \r |
40 | #define LZMA2_LCLP_MAX 4\r |
41 | #define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))\r |
42 | \r |
43 | #ifdef SHOW_DEBUG_INFO\r |
44 | #define PRF(x) x\r |
45 | #else\r |
46 | #define PRF(x)\r |
47 | #endif\r |
48 | \r |
49 | typedef enum\r |
50 | {\r |
51 | LZMA2_STATE_CONTROL,\r |
52 | LZMA2_STATE_UNPACK0,\r |
53 | LZMA2_STATE_UNPACK1,\r |
54 | LZMA2_STATE_PACK0,\r |
55 | LZMA2_STATE_PACK1,\r |
56 | LZMA2_STATE_PROP,\r |
57 | LZMA2_STATE_DATA,\r |
58 | LZMA2_STATE_DATA_CONT,\r |
59 | LZMA2_STATE_FINISHED,\r |
60 | LZMA2_STATE_ERROR\r |
61 | } ELzma2State;\r |
62 | \r |
63 | static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)\r |
64 | {\r |
65 | UInt32 dicSize;\r |
66 | if (prop > 40)\r |
67 | return SZ_ERROR_UNSUPPORTED;\r |
68 | dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);\r |
69 | props[0] = (Byte)LZMA2_LCLP_MAX;\r |
70 | props[1] = (Byte)(dicSize);\r |
71 | props[2] = (Byte)(dicSize >> 8);\r |
72 | props[3] = (Byte)(dicSize >> 16);\r |
73 | props[4] = (Byte)(dicSize >> 24);\r |
74 | return SZ_OK;\r |
75 | }\r |
76 | \r |
77 | SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc)\r |
78 | {\r |
79 | Byte props[LZMA_PROPS_SIZE];\r |
80 | RINOK(Lzma2Dec_GetOldProps(prop, props));\r |
81 | return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc);\r |
82 | }\r |
83 | \r |
84 | SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc)\r |
85 | {\r |
86 | Byte props[LZMA_PROPS_SIZE];\r |
87 | RINOK(Lzma2Dec_GetOldProps(prop, props));\r |
88 | return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);\r |
89 | }\r |
90 | \r |
91 | void Lzma2Dec_Init(CLzma2Dec *p)\r |
92 | {\r |
93 | p->state = LZMA2_STATE_CONTROL;\r |
94 | p->needInitDic = True;\r |
95 | p->needInitState = True;\r |
96 | p->needInitProp = True;\r |
97 | LzmaDec_Init(&p->decoder);\r |
98 | }\r |
99 | \r |
100 | static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)\r |
101 | {\r |
102 | switch (p->state)\r |
103 | {\r |
104 | case LZMA2_STATE_CONTROL:\r |
105 | p->control = b;\r |
106 | PRF(printf("\n %4X ", (unsigned)p->decoder.dicPos));\r |
107 | PRF(printf(" %2X", (unsigned)b));\r |
108 | if (p->control == 0)\r |
109 | return LZMA2_STATE_FINISHED;\r |
110 | if (LZMA2_IS_UNCOMPRESSED_STATE(p))\r |
111 | {\r |
112 | if ((p->control & 0x7F) > 2)\r |
113 | return LZMA2_STATE_ERROR;\r |
114 | p->unpackSize = 0;\r |
115 | }\r |
116 | else\r |
117 | p->unpackSize = (UInt32)(p->control & 0x1F) << 16;\r |
118 | return LZMA2_STATE_UNPACK0;\r |
119 | \r |
120 | case LZMA2_STATE_UNPACK0:\r |
121 | p->unpackSize |= (UInt32)b << 8;\r |
122 | return LZMA2_STATE_UNPACK1;\r |
123 | \r |
124 | case LZMA2_STATE_UNPACK1:\r |
125 | p->unpackSize |= (UInt32)b;\r |
126 | p->unpackSize++;\r |
127 | PRF(printf(" %8u", (unsigned)p->unpackSize));\r |
128 | return (LZMA2_IS_UNCOMPRESSED_STATE(p)) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0;\r |
129 | \r |
130 | case LZMA2_STATE_PACK0:\r |
131 | p->packSize = (UInt32)b << 8;\r |
132 | return LZMA2_STATE_PACK1;\r |
133 | \r |
134 | case LZMA2_STATE_PACK1:\r |
135 | p->packSize |= (UInt32)b;\r |
136 | p->packSize++;\r |
137 | PRF(printf(" %8u", (unsigned)p->packSize));\r |
138 | return LZMA2_IS_THERE_PROP(LZMA2_GET_LZMA_MODE(p)) ? LZMA2_STATE_PROP:\r |
139 | (p->needInitProp ? LZMA2_STATE_ERROR : LZMA2_STATE_DATA);\r |
140 | \r |
141 | case LZMA2_STATE_PROP:\r |
142 | {\r |
143 | unsigned lc, lp;\r |
144 | if (b >= (9 * 5 * 5))\r |
145 | return LZMA2_STATE_ERROR;\r |
146 | lc = b % 9;\r |
147 | b /= 9;\r |
148 | p->decoder.prop.pb = b / 5;\r |
149 | lp = b % 5;\r |
150 | if (lc + lp > LZMA2_LCLP_MAX)\r |
151 | return LZMA2_STATE_ERROR;\r |
152 | p->decoder.prop.lc = lc;\r |
153 | p->decoder.prop.lp = lp;\r |
154 | p->needInitProp = False;\r |
155 | return LZMA2_STATE_DATA;\r |
156 | }\r |
157 | }\r |
158 | return LZMA2_STATE_ERROR;\r |
159 | }\r |
160 | \r |
161 | static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size)\r |
162 | {\r |
163 | memcpy(p->dic + p->dicPos, src, size);\r |
164 | p->dicPos += size;\r |
165 | if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)\r |
166 | p->checkDicSize = p->prop.dicSize;\r |
167 | p->processedPos += (UInt32)size;\r |
168 | }\r |
169 | \r |
170 | void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState);\r |
171 | \r |
172 | SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,\r |
173 | const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)\r |
174 | {\r |
175 | SizeT inSize = *srcLen;\r |
176 | *srcLen = 0;\r |
177 | *status = LZMA_STATUS_NOT_SPECIFIED;\r |
178 | \r |
179 | while (p->state != LZMA2_STATE_FINISHED)\r |
180 | {\r |
181 | SizeT dicPos = p->decoder.dicPos;\r |
182 | \r |
183 | if (p->state == LZMA2_STATE_ERROR)\r |
184 | return SZ_ERROR_DATA;\r |
185 | \r |
186 | if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY)\r |
187 | {\r |
188 | *status = LZMA_STATUS_NOT_FINISHED;\r |
189 | return SZ_OK;\r |
190 | }\r |
191 | \r |
192 | if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)\r |
193 | {\r |
194 | if (*srcLen == inSize)\r |
195 | {\r |
196 | *status = LZMA_STATUS_NEEDS_MORE_INPUT;\r |
197 | return SZ_OK;\r |
198 | }\r |
199 | (*srcLen)++;\r |
200 | p->state = Lzma2Dec_UpdateState(p, *src++);\r |
201 | \r |
202 | if (dicPos == dicLimit && p->state != LZMA2_STATE_FINISHED)\r |
203 | {\r |
204 | p->state = LZMA2_STATE_ERROR;\r |
205 | return SZ_ERROR_DATA;\r |
206 | }\r |
207 | continue;\r |
208 | }\r |
209 | \r |
210 | {\r |
211 | SizeT destSizeCur = dicLimit - dicPos;\r |
212 | SizeT srcSizeCur = inSize - *srcLen;\r |
213 | ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY;\r |
214 | \r |
215 | if (p->unpackSize <= destSizeCur)\r |
216 | {\r |
217 | destSizeCur = (SizeT)p->unpackSize;\r |
218 | curFinishMode = LZMA_FINISH_END;\r |
219 | }\r |
220 | \r |
221 | if (LZMA2_IS_UNCOMPRESSED_STATE(p))\r |
222 | {\r |
223 | if (*srcLen == inSize)\r |
224 | {\r |
225 | *status = LZMA_STATUS_NEEDS_MORE_INPUT;\r |
226 | return SZ_OK;\r |
227 | }\r |
228 | \r |
229 | if (p->state == LZMA2_STATE_DATA)\r |
230 | {\r |
231 | Bool initDic = (p->control == LZMA2_CONTROL_COPY_RESET_DIC);\r |
232 | if (initDic)\r |
233 | p->needInitProp = p->needInitState = True;\r |
234 | else if (p->needInitDic)\r |
235 | {\r |
236 | p->state = LZMA2_STATE_ERROR;\r |
237 | return SZ_ERROR_DATA;\r |
238 | }\r |
239 | p->needInitDic = False;\r |
240 | LzmaDec_InitDicAndState(&p->decoder, initDic, False);\r |
241 | }\r |
242 | \r |
243 | if (srcSizeCur > destSizeCur)\r |
244 | srcSizeCur = destSizeCur;\r |
245 | \r |
246 | if (srcSizeCur == 0)\r |
247 | {\r |
248 | p->state = LZMA2_STATE_ERROR;\r |
249 | return SZ_ERROR_DATA;\r |
250 | }\r |
251 | \r |
252 | LzmaDec_UpdateWithUncompressed(&p->decoder, src, srcSizeCur);\r |
253 | \r |
254 | src += srcSizeCur;\r |
255 | *srcLen += srcSizeCur;\r |
256 | p->unpackSize -= (UInt32)srcSizeCur;\r |
257 | p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;\r |
258 | }\r |
259 | else\r |
260 | {\r |
261 | SizeT outSizeProcessed;\r |
262 | SRes res;\r |
263 | \r |
264 | if (p->state == LZMA2_STATE_DATA)\r |
265 | {\r |
266 | unsigned mode = LZMA2_GET_LZMA_MODE(p);\r |
267 | Bool initDic = (mode == 3);\r |
268 | Bool initState = (mode != 0);\r |
269 | if ((!initDic && p->needInitDic) || (!initState && p->needInitState))\r |
270 | {\r |
271 | p->state = LZMA2_STATE_ERROR;\r |
272 | return SZ_ERROR_DATA;\r |
273 | }\r |
274 | \r |
275 | LzmaDec_InitDicAndState(&p->decoder, initDic, initState);\r |
276 | p->needInitDic = False;\r |
277 | p->needInitState = False;\r |
278 | p->state = LZMA2_STATE_DATA_CONT;\r |
279 | }\r |
280 | \r |
281 | if (srcSizeCur > p->packSize)\r |
282 | srcSizeCur = (SizeT)p->packSize;\r |
283 | \r |
284 | res = LzmaDec_DecodeToDic(&p->decoder, dicPos + destSizeCur, src, &srcSizeCur, curFinishMode, status);\r |
285 | \r |
286 | src += srcSizeCur;\r |
287 | *srcLen += srcSizeCur;\r |
288 | p->packSize -= (UInt32)srcSizeCur;\r |
289 | \r |
290 | outSizeProcessed = p->decoder.dicPos - dicPos;\r |
291 | p->unpackSize -= (UInt32)outSizeProcessed;\r |
292 | \r |
293 | RINOK(res);\r |
294 | if (*status == LZMA_STATUS_NEEDS_MORE_INPUT)\r |
295 | return res;\r |
296 | \r |
297 | if (srcSizeCur == 0 && outSizeProcessed == 0)\r |
298 | {\r |
299 | if (*status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK\r |
300 | || p->unpackSize != 0\r |
301 | || p->packSize != 0)\r |
302 | {\r |
303 | p->state = LZMA2_STATE_ERROR;\r |
304 | return SZ_ERROR_DATA;\r |
305 | }\r |
306 | p->state = LZMA2_STATE_CONTROL;\r |
307 | }\r |
308 | \r |
309 | if (*status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)\r |
310 | *status = LZMA_STATUS_NOT_FINISHED;\r |
311 | }\r |
312 | }\r |
313 | }\r |
314 | \r |
315 | *status = LZMA_STATUS_FINISHED_WITH_MARK;\r |
316 | return SZ_OK;\r |
317 | }\r |
318 | \r |
319 | SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)\r |
320 | {\r |
321 | SizeT outSize = *destLen, inSize = *srcLen;\r |
322 | *srcLen = *destLen = 0;\r |
323 | for (;;)\r |
324 | {\r |
325 | SizeT srcSizeCur = inSize, outSizeCur, dicPos;\r |
326 | ELzmaFinishMode curFinishMode;\r |
327 | SRes res;\r |
328 | if (p->decoder.dicPos == p->decoder.dicBufSize)\r |
329 | p->decoder.dicPos = 0;\r |
330 | dicPos = p->decoder.dicPos;\r |
331 | if (outSize > p->decoder.dicBufSize - dicPos)\r |
332 | {\r |
333 | outSizeCur = p->decoder.dicBufSize;\r |
334 | curFinishMode = LZMA_FINISH_ANY;\r |
335 | }\r |
336 | else\r |
337 | {\r |
338 | outSizeCur = dicPos + outSize;\r |
339 | curFinishMode = finishMode;\r |
340 | }\r |
341 | \r |
342 | res = Lzma2Dec_DecodeToDic(p, outSizeCur, src, &srcSizeCur, curFinishMode, status);\r |
343 | src += srcSizeCur;\r |
344 | inSize -= srcSizeCur;\r |
345 | *srcLen += srcSizeCur;\r |
346 | outSizeCur = p->decoder.dicPos - dicPos;\r |
347 | memcpy(dest, p->decoder.dic + dicPos, outSizeCur);\r |
348 | dest += outSizeCur;\r |
349 | outSize -= outSizeCur;\r |
350 | *destLen += outSizeCur;\r |
351 | if (res != 0)\r |
352 | return res;\r |
353 | if (outSizeCur == 0 || outSize == 0)\r |
354 | return SZ_OK;\r |
355 | }\r |
356 | }\r |
357 | \r |
358 | SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\r |
359 | Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc)\r |
360 | {\r |
361 | CLzma2Dec p;\r |
362 | SRes res;\r |
363 | SizeT outSize = *destLen, inSize = *srcLen;\r |
364 | *destLen = *srcLen = 0;\r |
365 | *status = LZMA_STATUS_NOT_SPECIFIED;\r |
366 | Lzma2Dec_Construct(&p);\r |
367 | RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc));\r |
368 | p.decoder.dic = dest;\r |
369 | p.decoder.dicBufSize = outSize;\r |
370 | Lzma2Dec_Init(&p);\r |
371 | *srcLen = inSize;\r |
372 | res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);\r |
373 | *destLen = p.decoder.dicPos;\r |
374 | if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)\r |
375 | res = SZ_ERROR_INPUT_EOF;\r |
376 | Lzma2Dec_FreeProbs(&p, alloc);\r |
377 | return res;\r |
378 | }\r |