ce188d4d |
1 | /* 7zDec.c -- Decoding from 7z folder\r |
2 | 2015-11-18 : Igor Pavlov : Public domain */\r |
3 | \r |
4 | #include "Precomp.h"\r |
5 | \r |
6 | #include <string.h>\r |
7 | \r |
8 | /* #define _7ZIP_PPMD_SUPPPORT */\r |
9 | \r |
10 | #include "7z.h"\r |
11 | #include "7zCrc.h"\r |
12 | \r |
13 | #include "Bcj2.h"\r |
14 | #include "Bra.h"\r |
15 | #include "CpuArch.h"\r |
16 | #include "Delta.h"\r |
17 | #include "LzmaDec.h"\r |
18 | #include "Lzma2Dec.h"\r |
19 | #ifdef _7ZIP_PPMD_SUPPPORT\r |
20 | #include "Ppmd7.h"\r |
21 | #endif\r |
22 | \r |
23 | #define k_Copy 0\r |
24 | #define k_Delta 3\r |
25 | #define k_LZMA2 0x21\r |
26 | #define k_LZMA 0x30101\r |
27 | #define k_BCJ 0x3030103\r |
28 | #define k_BCJ2 0x303011B\r |
29 | #define k_PPC 0x3030205\r |
30 | #define k_IA64 0x3030401\r |
31 | #define k_ARM 0x3030501\r |
32 | #define k_ARMT 0x3030701\r |
33 | #define k_SPARC 0x3030805\r |
34 | \r |
35 | \r |
36 | #ifdef _7ZIP_PPMD_SUPPPORT\r |
37 | \r |
38 | #define k_PPMD 0x30401\r |
39 | \r |
40 | typedef struct\r |
41 | {\r |
42 | IByteIn p;\r |
43 | const Byte *cur;\r |
44 | const Byte *end;\r |
45 | const Byte *begin;\r |
46 | UInt64 processed;\r |
47 | Bool extra;\r |
48 | SRes res;\r |
49 | ILookInStream *inStream;\r |
50 | } CByteInToLook;\r |
51 | \r |
52 | static Byte ReadByte(void *pp)\r |
53 | {\r |
54 | CByteInToLook *p = (CByteInToLook *)pp;\r |
55 | if (p->cur != p->end)\r |
56 | return *p->cur++;\r |
57 | if (p->res == SZ_OK)\r |
58 | {\r |
59 | size_t size = p->cur - p->begin;\r |
60 | p->processed += size;\r |
61 | p->res = p->inStream->Skip(p->inStream, size);\r |
62 | size = (1 << 25);\r |
63 | p->res = p->inStream->Look(p->inStream, (const void **)&p->begin, &size);\r |
64 | p->cur = p->begin;\r |
65 | p->end = p->begin + size;\r |
66 | if (size != 0)\r |
67 | return *p->cur++;;\r |
68 | }\r |
69 | p->extra = True;\r |
70 | return 0;\r |
71 | }\r |
72 | \r |
73 | static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,\r |
74 | Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)\r |
75 | {\r |
76 | CPpmd7 ppmd;\r |
77 | CByteInToLook s;\r |
78 | SRes res = SZ_OK;\r |
79 | \r |
80 | s.p.Read = ReadByte;\r |
81 | s.inStream = inStream;\r |
82 | s.begin = s.end = s.cur = NULL;\r |
83 | s.extra = False;\r |
84 | s.res = SZ_OK;\r |
85 | s.processed = 0;\r |
86 | \r |
87 | if (propsSize != 5)\r |
88 | return SZ_ERROR_UNSUPPORTED;\r |
89 | \r |
90 | {\r |
91 | unsigned order = props[0];\r |
92 | UInt32 memSize = GetUi32(props + 1);\r |
93 | if (order < PPMD7_MIN_ORDER ||\r |
94 | order > PPMD7_MAX_ORDER ||\r |
95 | memSize < PPMD7_MIN_MEM_SIZE ||\r |
96 | memSize > PPMD7_MAX_MEM_SIZE)\r |
97 | return SZ_ERROR_UNSUPPORTED;\r |
98 | Ppmd7_Construct(&ppmd);\r |
99 | if (!Ppmd7_Alloc(&ppmd, memSize, allocMain))\r |
100 | return SZ_ERROR_MEM;\r |
101 | Ppmd7_Init(&ppmd, order);\r |
102 | }\r |
103 | {\r |
104 | CPpmd7z_RangeDec rc;\r |
105 | Ppmd7z_RangeDec_CreateVTable(&rc);\r |
106 | rc.Stream = &s.p;\r |
107 | if (!Ppmd7z_RangeDec_Init(&rc))\r |
108 | res = SZ_ERROR_DATA;\r |
109 | else if (s.extra)\r |
110 | res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);\r |
111 | else\r |
112 | {\r |
113 | SizeT i;\r |
114 | for (i = 0; i < outSize; i++)\r |
115 | {\r |
116 | int sym = Ppmd7_DecodeSymbol(&ppmd, &rc.p);\r |
117 | if (s.extra || sym < 0)\r |
118 | break;\r |
119 | outBuffer[i] = (Byte)sym;\r |
120 | }\r |
121 | if (i != outSize)\r |
122 | res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);\r |
123 | else if (s.processed + (s.cur - s.begin) != inSize || !Ppmd7z_RangeDec_IsFinishedOK(&rc))\r |
124 | res = SZ_ERROR_DATA;\r |
125 | }\r |
126 | }\r |
127 | Ppmd7_Free(&ppmd, allocMain);\r |
128 | return res;\r |
129 | }\r |
130 | \r |
131 | #endif\r |
132 | \r |
133 | \r |
134 | static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,\r |
135 | Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)\r |
136 | {\r |
137 | CLzmaDec state;\r |
138 | SRes res = SZ_OK;\r |
139 | \r |
140 | LzmaDec_Construct(&state);\r |
141 | RINOK(LzmaDec_AllocateProbs(&state, props, propsSize, allocMain));\r |
142 | state.dic = outBuffer;\r |
143 | state.dicBufSize = outSize;\r |
144 | LzmaDec_Init(&state);\r |
145 | \r |
146 | for (;;)\r |
147 | {\r |
148 | const void *inBuf = NULL;\r |
149 | size_t lookahead = (1 << 18);\r |
150 | if (lookahead > inSize)\r |
151 | lookahead = (size_t)inSize;\r |
152 | res = inStream->Look(inStream, &inBuf, &lookahead);\r |
153 | if (res != SZ_OK)\r |
154 | break;\r |
155 | \r |
156 | {\r |
157 | SizeT inProcessed = (SizeT)lookahead, dicPos = state.dicPos;\r |
158 | ELzmaStatus status;\r |
159 | res = LzmaDec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);\r |
160 | lookahead -= inProcessed;\r |
161 | inSize -= inProcessed;\r |
162 | if (res != SZ_OK)\r |
163 | break;\r |
164 | \r |
165 | if (status == LZMA_STATUS_FINISHED_WITH_MARK)\r |
166 | {\r |
167 | if (outSize != state.dicPos || inSize != 0)\r |
168 | res = SZ_ERROR_DATA;\r |
169 | break;\r |
170 | }\r |
171 | \r |
172 | if (outSize == state.dicPos && inSize == 0 && status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)\r |
173 | break;\r |
174 | \r |
175 | if (inProcessed == 0 && dicPos == state.dicPos)\r |
176 | {\r |
177 | res = SZ_ERROR_DATA;\r |
178 | break;\r |
179 | }\r |
180 | \r |
181 | res = inStream->Skip((void *)inStream, inProcessed);\r |
182 | if (res != SZ_OK)\r |
183 | break;\r |
184 | }\r |
185 | }\r |
186 | \r |
187 | LzmaDec_FreeProbs(&state, allocMain);\r |
188 | return res;\r |
189 | }\r |
190 | \r |
191 | \r |
192 | #ifndef _7Z_NO_METHOD_LZMA2\r |
193 | \r |
194 | static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,\r |
195 | Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)\r |
196 | {\r |
197 | CLzma2Dec state;\r |
198 | SRes res = SZ_OK;\r |
199 | \r |
200 | Lzma2Dec_Construct(&state);\r |
201 | if (propsSize != 1)\r |
202 | return SZ_ERROR_DATA;\r |
203 | RINOK(Lzma2Dec_AllocateProbs(&state, props[0], allocMain));\r |
204 | state.decoder.dic = outBuffer;\r |
205 | state.decoder.dicBufSize = outSize;\r |
206 | Lzma2Dec_Init(&state);\r |
207 | \r |
208 | for (;;)\r |
209 | {\r |
210 | const void *inBuf = NULL;\r |
211 | size_t lookahead = (1 << 18);\r |
212 | if (lookahead > inSize)\r |
213 | lookahead = (size_t)inSize;\r |
214 | res = inStream->Look(inStream, &inBuf, &lookahead);\r |
215 | if (res != SZ_OK)\r |
216 | break;\r |
217 | \r |
218 | {\r |
219 | SizeT inProcessed = (SizeT)lookahead, dicPos = state.decoder.dicPos;\r |
220 | ELzmaStatus status;\r |
221 | res = Lzma2Dec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);\r |
222 | lookahead -= inProcessed;\r |
223 | inSize -= inProcessed;\r |
224 | if (res != SZ_OK)\r |
225 | break;\r |
226 | \r |
227 | if (status == LZMA_STATUS_FINISHED_WITH_MARK)\r |
228 | {\r |
229 | if (outSize != state.decoder.dicPos || inSize != 0)\r |
230 | res = SZ_ERROR_DATA;\r |
231 | break;\r |
232 | }\r |
233 | \r |
234 | if (inProcessed == 0 && dicPos == state.decoder.dicPos)\r |
235 | {\r |
236 | res = SZ_ERROR_DATA;\r |
237 | break;\r |
238 | }\r |
239 | \r |
240 | res = inStream->Skip((void *)inStream, inProcessed);\r |
241 | if (res != SZ_OK)\r |
242 | break;\r |
243 | }\r |
244 | }\r |
245 | \r |
246 | Lzma2Dec_FreeProbs(&state, allocMain);\r |
247 | return res;\r |
248 | }\r |
249 | \r |
250 | #endif\r |
251 | \r |
252 | \r |
253 | static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer)\r |
254 | {\r |
255 | while (inSize > 0)\r |
256 | {\r |
257 | const void *inBuf;\r |
258 | size_t curSize = (1 << 18);\r |
259 | if (curSize > inSize)\r |
260 | curSize = (size_t)inSize;\r |
261 | RINOK(inStream->Look(inStream, &inBuf, &curSize));\r |
262 | if (curSize == 0)\r |
263 | return SZ_ERROR_INPUT_EOF;\r |
264 | memcpy(outBuffer, inBuf, curSize);\r |
265 | outBuffer += curSize;\r |
266 | inSize -= curSize;\r |
267 | RINOK(inStream->Skip((void *)inStream, curSize));\r |
268 | }\r |
269 | return SZ_OK;\r |
270 | }\r |
271 | \r |
272 | static Bool IS_MAIN_METHOD(UInt32 m)\r |
273 | {\r |
274 | switch (m)\r |
275 | {\r |
276 | case k_Copy:\r |
277 | case k_LZMA:\r |
278 | #ifndef _7Z_NO_METHOD_LZMA2\r |
279 | case k_LZMA2:\r |
280 | #endif\r |
281 | #ifdef _7ZIP_PPMD_SUPPPORT\r |
282 | case k_PPMD:\r |
283 | #endif\r |
284 | return True;\r |
285 | }\r |
286 | return False;\r |
287 | }\r |
288 | \r |
289 | static Bool IS_SUPPORTED_CODER(const CSzCoderInfo *c)\r |
290 | {\r |
291 | return\r |
292 | c->NumStreams == 1\r |
293 | /* && c->MethodID <= (UInt32)0xFFFFFFFF */\r |
294 | && IS_MAIN_METHOD((UInt32)c->MethodID);\r |
295 | }\r |
296 | \r |
297 | #define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumStreams == 4)\r |
298 | \r |
299 | static SRes CheckSupportedFolder(const CSzFolder *f)\r |
300 | {\r |
301 | if (f->NumCoders < 1 || f->NumCoders > 4)\r |
302 | return SZ_ERROR_UNSUPPORTED;\r |
303 | if (!IS_SUPPORTED_CODER(&f->Coders[0]))\r |
304 | return SZ_ERROR_UNSUPPORTED;\r |
305 | if (f->NumCoders == 1)\r |
306 | {\r |
307 | if (f->NumPackStreams != 1 || f->PackStreams[0] != 0 || f->NumBonds != 0)\r |
308 | return SZ_ERROR_UNSUPPORTED;\r |
309 | return SZ_OK;\r |
310 | }\r |
311 | \r |
312 | \r |
313 | #ifndef _7Z_NO_METHODS_FILTERS\r |
314 | \r |
315 | if (f->NumCoders == 2)\r |
316 | {\r |
317 | const CSzCoderInfo *c = &f->Coders[1];\r |
318 | if (\r |
319 | /* c->MethodID > (UInt32)0xFFFFFFFF || */\r |
320 | c->NumStreams != 1\r |
321 | || f->NumPackStreams != 1\r |
322 | || f->PackStreams[0] != 0\r |
323 | || f->NumBonds != 1\r |
324 | || f->Bonds[0].InIndex != 1\r |
325 | || f->Bonds[0].OutIndex != 0)\r |
326 | return SZ_ERROR_UNSUPPORTED;\r |
327 | switch ((UInt32)c->MethodID)\r |
328 | {\r |
329 | case k_Delta:\r |
330 | case k_BCJ:\r |
331 | case k_PPC:\r |
332 | case k_IA64:\r |
333 | case k_SPARC:\r |
334 | case k_ARM:\r |
335 | case k_ARMT:\r |
336 | break;\r |
337 | default:\r |
338 | return SZ_ERROR_UNSUPPORTED;\r |
339 | }\r |
340 | return SZ_OK;\r |
341 | }\r |
342 | \r |
343 | #endif\r |
344 | \r |
345 | \r |
346 | if (f->NumCoders == 4)\r |
347 | {\r |
348 | if (!IS_SUPPORTED_CODER(&f->Coders[1])\r |
349 | || !IS_SUPPORTED_CODER(&f->Coders[2])\r |
350 | || !IS_BCJ2(&f->Coders[3]))\r |
351 | return SZ_ERROR_UNSUPPORTED;\r |
352 | if (f->NumPackStreams != 4\r |
353 | || f->PackStreams[0] != 2\r |
354 | || f->PackStreams[1] != 6\r |
355 | || f->PackStreams[2] != 1\r |
356 | || f->PackStreams[3] != 0\r |
357 | || f->NumBonds != 3\r |
358 | || f->Bonds[0].InIndex != 5 || f->Bonds[0].OutIndex != 0\r |
359 | || f->Bonds[1].InIndex != 4 || f->Bonds[1].OutIndex != 1\r |
360 | || f->Bonds[2].InIndex != 3 || f->Bonds[2].OutIndex != 2)\r |
361 | return SZ_ERROR_UNSUPPORTED;\r |
362 | return SZ_OK;\r |
363 | }\r |
364 | \r |
365 | return SZ_ERROR_UNSUPPORTED;\r |
366 | }\r |
367 | \r |
368 | #define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break;\r |
369 | \r |
370 | static SRes SzFolder_Decode2(const CSzFolder *folder,\r |
371 | const Byte *propsData,\r |
372 | const UInt64 *unpackSizes,\r |
373 | const UInt64 *packPositions,\r |
374 | ILookInStream *inStream, UInt64 startPos,\r |
375 | Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain,\r |
376 | Byte *tempBuf[])\r |
377 | {\r |
378 | UInt32 ci;\r |
379 | SizeT tempSizes[3] = { 0, 0, 0};\r |
380 | SizeT tempSize3 = 0;\r |
381 | Byte *tempBuf3 = 0;\r |
382 | \r |
383 | RINOK(CheckSupportedFolder(folder));\r |
384 | \r |
385 | for (ci = 0; ci < folder->NumCoders; ci++)\r |
386 | {\r |
387 | const CSzCoderInfo *coder = &folder->Coders[ci];\r |
388 | \r |
389 | if (IS_MAIN_METHOD((UInt32)coder->MethodID))\r |
390 | {\r |
391 | UInt32 si = 0;\r |
392 | UInt64 offset;\r |
393 | UInt64 inSize;\r |
394 | Byte *outBufCur = outBuffer;\r |
395 | SizeT outSizeCur = outSize;\r |
396 | if (folder->NumCoders == 4)\r |
397 | {\r |
398 | UInt32 indices[] = { 3, 2, 0 };\r |
399 | UInt64 unpackSize = unpackSizes[ci];\r |
400 | si = indices[ci];\r |
401 | if (ci < 2)\r |
402 | {\r |
403 | Byte *temp;\r |
404 | outSizeCur = (SizeT)unpackSize;\r |
405 | if (outSizeCur != unpackSize)\r |
406 | return SZ_ERROR_MEM;\r |
407 | temp = (Byte *)IAlloc_Alloc(allocMain, outSizeCur);\r |
408 | if (!temp && outSizeCur != 0)\r |
409 | return SZ_ERROR_MEM;\r |
410 | outBufCur = tempBuf[1 - ci] = temp;\r |
411 | tempSizes[1 - ci] = outSizeCur;\r |
412 | }\r |
413 | else if (ci == 2)\r |
414 | {\r |
415 | if (unpackSize > outSize) /* check it */\r |
416 | return SZ_ERROR_PARAM;\r |
417 | tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize);\r |
418 | tempSize3 = outSizeCur = (SizeT)unpackSize;\r |
419 | }\r |
420 | else\r |
421 | return SZ_ERROR_UNSUPPORTED;\r |
422 | }\r |
423 | offset = packPositions[si];\r |
424 | inSize = packPositions[si + 1] - offset;\r |
425 | RINOK(LookInStream_SeekTo(inStream, startPos + offset));\r |
426 | \r |
427 | if (coder->MethodID == k_Copy)\r |
428 | {\r |
429 | if (inSize != outSizeCur) /* check it */\r |
430 | return SZ_ERROR_DATA;\r |
431 | RINOK(SzDecodeCopy(inSize, inStream, outBufCur));\r |
432 | }\r |
433 | else if (coder->MethodID == k_LZMA)\r |
434 | {\r |
435 | RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));\r |
436 | }\r |
437 | #ifndef _7Z_NO_METHOD_LZMA2\r |
438 | else if (coder->MethodID == k_LZMA2)\r |
439 | {\r |
440 | RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));\r |
441 | }\r |
442 | #endif\r |
443 | #ifdef _7ZIP_PPMD_SUPPPORT\r |
444 | else if (coder->MethodID == k_PPMD)\r |
445 | {\r |
446 | RINOK(SzDecodePpmd(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));\r |
447 | }\r |
448 | #endif\r |
449 | else\r |
450 | return SZ_ERROR_UNSUPPORTED;\r |
451 | }\r |
452 | else if (coder->MethodID == k_BCJ2)\r |
453 | {\r |
454 | UInt64 offset = packPositions[1];\r |
455 | UInt64 s3Size = packPositions[2] - offset;\r |
456 | \r |
457 | if (ci != 3)\r |
458 | return SZ_ERROR_UNSUPPORTED;\r |
459 | \r |
460 | tempSizes[2] = (SizeT)s3Size;\r |
461 | if (tempSizes[2] != s3Size)\r |
462 | return SZ_ERROR_MEM;\r |
463 | tempBuf[2] = (Byte *)IAlloc_Alloc(allocMain, tempSizes[2]);\r |
464 | if (!tempBuf[2] && tempSizes[2] != 0)\r |
465 | return SZ_ERROR_MEM;\r |
466 | \r |
467 | RINOK(LookInStream_SeekTo(inStream, startPos + offset));\r |
468 | RINOK(SzDecodeCopy(s3Size, inStream, tempBuf[2]));\r |
469 | \r |
470 | if ((tempSizes[0] & 3) != 0 ||\r |
471 | (tempSizes[1] & 3) != 0 ||\r |
472 | tempSize3 + tempSizes[0] + tempSizes[1] != outSize)\r |
473 | return SZ_ERROR_DATA;\r |
474 | \r |
475 | {\r |
476 | CBcj2Dec p;\r |
477 | \r |
478 | p.bufs[0] = tempBuf3; p.lims[0] = tempBuf3 + tempSize3;\r |
479 | p.bufs[1] = tempBuf[0]; p.lims[1] = tempBuf[0] + tempSizes[0];\r |
480 | p.bufs[2] = tempBuf[1]; p.lims[2] = tempBuf[1] + tempSizes[1];\r |
481 | p.bufs[3] = tempBuf[2]; p.lims[3] = tempBuf[2] + tempSizes[2];\r |
482 | \r |
483 | p.dest = outBuffer;\r |
484 | p.destLim = outBuffer + outSize;\r |
485 | \r |
486 | Bcj2Dec_Init(&p);\r |
487 | RINOK(Bcj2Dec_Decode(&p));\r |
488 | \r |
489 | {\r |
490 | unsigned i;\r |
491 | for (i = 0; i < 4; i++)\r |
492 | if (p.bufs[i] != p.lims[i])\r |
493 | return SZ_ERROR_DATA;\r |
494 | \r |
495 | if (!Bcj2Dec_IsFinished(&p))\r |
496 | return SZ_ERROR_DATA;\r |
497 | \r |
498 | if (p.dest != p.destLim\r |
499 | || p.state != BCJ2_STREAM_MAIN)\r |
500 | return SZ_ERROR_DATA;\r |
501 | }\r |
502 | }\r |
503 | }\r |
504 | #ifndef _7Z_NO_METHODS_FILTERS\r |
505 | else if (ci == 1)\r |
506 | {\r |
507 | if (coder->MethodID == k_Delta)\r |
508 | {\r |
509 | if (coder->PropsSize != 1)\r |
510 | return SZ_ERROR_UNSUPPORTED;\r |
511 | {\r |
512 | Byte state[DELTA_STATE_SIZE];\r |
513 | Delta_Init(state);\r |
514 | Delta_Decode(state, (unsigned)(propsData[coder->PropsOffset]) + 1, outBuffer, outSize);\r |
515 | }\r |
516 | }\r |
517 | else\r |
518 | {\r |
519 | if (coder->PropsSize != 0)\r |
520 | return SZ_ERROR_UNSUPPORTED;\r |
521 | switch (coder->MethodID)\r |
522 | {\r |
523 | case k_BCJ:\r |
524 | {\r |
525 | UInt32 state;\r |
526 | x86_Convert_Init(state);\r |
527 | x86_Convert(outBuffer, outSize, 0, &state, 0);\r |
528 | break;\r |
529 | }\r |
530 | CASE_BRA_CONV(PPC)\r |
531 | CASE_BRA_CONV(IA64)\r |
532 | CASE_BRA_CONV(SPARC)\r |
533 | CASE_BRA_CONV(ARM)\r |
534 | CASE_BRA_CONV(ARMT)\r |
535 | default:\r |
536 | return SZ_ERROR_UNSUPPORTED;\r |
537 | }\r |
538 | }\r |
539 | }\r |
540 | #endif\r |
541 | else\r |
542 | return SZ_ERROR_UNSUPPORTED;\r |
543 | }\r |
544 | \r |
545 | return SZ_OK;\r |
546 | }\r |
547 | \r |
548 | \r |
549 | SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,\r |
550 | ILookInStream *inStream, UInt64 startPos,\r |
551 | Byte *outBuffer, size_t outSize,\r |
552 | ISzAlloc *allocMain)\r |
553 | {\r |
554 | SRes res;\r |
555 | CSzFolder folder;\r |
556 | CSzData sd;\r |
557 | \r |
558 | const Byte *data = p->CodersData + p->FoCodersOffsets[folderIndex];\r |
559 | sd.Data = data;\r |
560 | sd.Size = p->FoCodersOffsets[folderIndex + 1] - p->FoCodersOffsets[folderIndex];\r |
561 | \r |
562 | res = SzGetNextFolderItem(&folder, &sd);\r |
563 | \r |
564 | if (res != SZ_OK)\r |
565 | return res;\r |
566 | \r |
567 | if (sd.Size != 0\r |
568 | || folder.UnpackStream != p->FoToMainUnpackSizeIndex[folderIndex]\r |
569 | || outSize != SzAr_GetFolderUnpackSize(p, folderIndex))\r |
570 | return SZ_ERROR_FAIL;\r |
571 | {\r |
572 | unsigned i;\r |
573 | Byte *tempBuf[3] = { 0, 0, 0};\r |
574 | \r |
575 | res = SzFolder_Decode2(&folder, data,\r |
576 | &p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex]],\r |
577 | p->PackPositions + p->FoStartPackStreamIndex[folderIndex],\r |
578 | inStream, startPos,\r |
579 | outBuffer, (SizeT)outSize, allocMain, tempBuf);\r |
580 | \r |
581 | for (i = 0; i < 3; i++)\r |
582 | IAlloc_Free(allocMain, tempBuf[i]);\r |
583 | \r |
584 | if (res == SZ_OK)\r |
585 | if (SzBitWithVals_Check(&p->FolderCRCs, folderIndex))\r |
586 | if (CrcCalc(outBuffer, outSize) != p->FolderCRCs.Vals[folderIndex])\r |
587 | res = SZ_ERROR_CRC;\r |
588 | \r |
589 | return res;\r |
590 | }\r |
591 | }\r |