]>
Commit | Line | Data |
---|---|---|
ef6bacff RC |
1 | |
2 | /*-------------------------------------------------------------*/ | |
3 | /*--- Decompression machinery ---*/ | |
4 | /*--- decompress.c ---*/ | |
5 | /*-------------------------------------------------------------*/ | |
6 | ||
7 | /*-- | |
8 | This file is a part of bzip2 and/or libbzip2, a program and | |
9 | library for lossless, block-sorting data compression. | |
10 | ||
ba95a000 | 11 | Copyright (C) 1996-2002 Julian R Seward. All rights reserved. |
ef6bacff RC |
12 | |
13 | Redistribution and use in source and binary forms, with or without | |
14 | modification, are permitted provided that the following conditions | |
15 | are met: | |
16 | ||
17 | 1. Redistributions of source code must retain the above copyright | |
18 | notice, this list of conditions and the following disclaimer. | |
19 | ||
20 | 2. The origin of this software must not be misrepresented; you must | |
21 | not claim that you wrote the original software. If you use this | |
22 | software in a product, an acknowledgment in the product | |
23 | documentation would be appreciated but is not required. | |
24 | ||
25 | 3. Altered source versions must be plainly marked as such, and must | |
26 | not be misrepresented as being the original software. | |
27 | ||
28 | 4. The name of the author may not be used to endorse or promote | |
29 | products derived from this software without specific prior written | |
30 | permission. | |
31 | ||
32 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS | |
33 | OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
34 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
35 | ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY | |
36 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
37 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE | |
38 | GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
39 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
40 | WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
41 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
42 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
43 | ||
44 | Julian Seward, Cambridge, UK. | |
45 | jseward@acm.org | |
46 | bzip2/libbzip2 version 1.0 of 21 March 2000 | |
47 | ||
48 | This program is based on (at least) the work of: | |
49 | Mike Burrows | |
50 | David Wheeler | |
51 | Peter Fenwick | |
52 | Alistair Moffat | |
53 | Radford Neal | |
54 | Ian H. Witten | |
55 | Robert Sedgewick | |
56 | Jon L. Bentley | |
57 | ||
58 | For more information on these sources, see the manual. | |
59 | --*/ | |
60 | ||
61 | ||
62 | #include "bzlib_private.h" | |
63 | ||
64 | ||
65 | /*---------------------------------------------------*/ | |
66 | static | |
67 | void makeMaps_d ( DState* s ) | |
68 | { | |
69 | Int32 i; | |
70 | s->nInUse = 0; | |
71 | for (i = 0; i < 256; i++) | |
72 | if (s->inUse[i]) { | |
73 | s->seqToUnseq[s->nInUse] = i; | |
74 | s->nInUse++; | |
75 | } | |
76 | } | |
77 | ||
78 | ||
79 | /*---------------------------------------------------*/ | |
80 | #define RETURN(rrr) \ | |
81 | { retVal = rrr; goto save_state_and_return; }; | |
82 | ||
83 | #define GET_BITS(lll,vvv,nnn) \ | |
84 | case lll: s->state = lll; \ | |
85 | while (True) { \ | |
86 | if (s->bsLive >= nnn) { \ | |
87 | UInt32 v; \ | |
88 | v = (s->bsBuff >> \ | |
89 | (s->bsLive-nnn)) & ((1 << nnn)-1); \ | |
90 | s->bsLive -= nnn; \ | |
91 | vvv = v; \ | |
92 | break; \ | |
93 | } \ | |
94 | if (s->strm->avail_in == 0) RETURN(BZ_OK); \ | |
95 | s->bsBuff \ | |
96 | = (s->bsBuff << 8) | \ | |
97 | ((UInt32) \ | |
98 | (*((UChar*)(s->strm->next_in)))); \ | |
99 | s->bsLive += 8; \ | |
100 | s->strm->next_in++; \ | |
101 | s->strm->avail_in--; \ | |
102 | s->strm->total_in_lo32++; \ | |
103 | if (s->strm->total_in_lo32 == 0) \ | |
104 | s->strm->total_in_hi32++; \ | |
105 | } | |
106 | ||
107 | #define GET_UCHAR(lll,uuu) \ | |
108 | GET_BITS(lll,uuu,8) | |
109 | ||
110 | #define GET_BIT(lll,uuu) \ | |
111 | GET_BITS(lll,uuu,1) | |
112 | ||
113 | /*---------------------------------------------------*/ | |
114 | #define GET_MTF_VAL(label1,label2,lval) \ | |
115 | { \ | |
116 | if (groupPos == 0) { \ | |
117 | groupNo++; \ | |
118 | if (groupNo >= nSelectors) \ | |
119 | RETURN(BZ_DATA_ERROR); \ | |
120 | groupPos = BZ_G_SIZE; \ | |
121 | gSel = s->selector[groupNo]; \ | |
122 | gMinlen = s->minLens[gSel]; \ | |
123 | gLimit = &(s->limit[gSel][0]); \ | |
124 | gPerm = &(s->perm[gSel][0]); \ | |
125 | gBase = &(s->base[gSel][0]); \ | |
126 | } \ | |
127 | groupPos--; \ | |
128 | zn = gMinlen; \ | |
129 | GET_BITS(label1, zvec, zn); \ | |
130 | while (1) { \ | |
131 | if (zn > 20 /* the longest code */) \ | |
132 | RETURN(BZ_DATA_ERROR); \ | |
133 | if (zvec <= gLimit[zn]) break; \ | |
134 | zn++; \ | |
135 | GET_BIT(label2, zj); \ | |
136 | zvec = (zvec << 1) | zj; \ | |
137 | }; \ | |
138 | if (zvec - gBase[zn] < 0 \ | |
139 | || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \ | |
140 | RETURN(BZ_DATA_ERROR); \ | |
141 | lval = gPerm[zvec - gBase[zn]]; \ | |
142 | } | |
143 | ||
144 | ||
145 | /*---------------------------------------------------*/ | |
146 | Int32 BZ2_decompress ( DState* s ) | |
147 | { | |
148 | UChar uc; | |
149 | Int32 retVal; | |
150 | Int32 minLen, maxLen; | |
151 | bz_stream* strm = s->strm; | |
152 | ||
153 | /* stuff that needs to be saved/restored */ | |
154 | Int32 i; | |
155 | Int32 j; | |
156 | Int32 t; | |
157 | Int32 alphaSize; | |
158 | Int32 nGroups; | |
159 | Int32 nSelectors; | |
160 | Int32 EOB; | |
161 | Int32 groupNo; | |
162 | Int32 groupPos; | |
163 | Int32 nextSym; | |
164 | Int32 nblockMAX; | |
165 | Int32 nblock; | |
166 | Int32 es; | |
167 | Int32 N; | |
168 | Int32 curr; | |
169 | Int32 zt; | |
170 | Int32 zn; | |
171 | Int32 zvec; | |
172 | Int32 zj; | |
173 | Int32 gSel; | |
174 | Int32 gMinlen; | |
175 | Int32* gLimit; | |
176 | Int32* gBase; | |
177 | Int32* gPerm; | |
178 | ||
179 | if (s->state == BZ_X_MAGIC_1) { | |
180 | /*initialise the save area*/ | |
181 | s->save_i = 0; | |
182 | s->save_j = 0; | |
183 | s->save_t = 0; | |
184 | s->save_alphaSize = 0; | |
185 | s->save_nGroups = 0; | |
186 | s->save_nSelectors = 0; | |
187 | s->save_EOB = 0; | |
188 | s->save_groupNo = 0; | |
189 | s->save_groupPos = 0; | |
190 | s->save_nextSym = 0; | |
191 | s->save_nblockMAX = 0; | |
192 | s->save_nblock = 0; | |
193 | s->save_es = 0; | |
194 | s->save_N = 0; | |
195 | s->save_curr = 0; | |
196 | s->save_zt = 0; | |
197 | s->save_zn = 0; | |
198 | s->save_zvec = 0; | |
199 | s->save_zj = 0; | |
200 | s->save_gSel = 0; | |
201 | s->save_gMinlen = 0; | |
202 | s->save_gLimit = NULL; | |
203 | s->save_gBase = NULL; | |
204 | s->save_gPerm = NULL; | |
205 | } | |
206 | ||
207 | /*restore from the save area*/ | |
208 | i = s->save_i; | |
209 | j = s->save_j; | |
210 | t = s->save_t; | |
211 | alphaSize = s->save_alphaSize; | |
212 | nGroups = s->save_nGroups; | |
213 | nSelectors = s->save_nSelectors; | |
214 | EOB = s->save_EOB; | |
215 | groupNo = s->save_groupNo; | |
216 | groupPos = s->save_groupPos; | |
217 | nextSym = s->save_nextSym; | |
218 | nblockMAX = s->save_nblockMAX; | |
219 | nblock = s->save_nblock; | |
220 | es = s->save_es; | |
221 | N = s->save_N; | |
222 | curr = s->save_curr; | |
223 | zt = s->save_zt; | |
224 | zn = s->save_zn; | |
225 | zvec = s->save_zvec; | |
226 | zj = s->save_zj; | |
227 | gSel = s->save_gSel; | |
228 | gMinlen = s->save_gMinlen; | |
229 | gLimit = s->save_gLimit; | |
230 | gBase = s->save_gBase; | |
231 | gPerm = s->save_gPerm; | |
232 | ||
233 | retVal = BZ_OK; | |
234 | ||
235 | switch (s->state) { | |
236 | ||
237 | GET_UCHAR(BZ_X_MAGIC_1, uc); | |
ba95a000 | 238 | if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC); |
ef6bacff RC |
239 | |
240 | GET_UCHAR(BZ_X_MAGIC_2, uc); | |
ba95a000 | 241 | if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC); |
ef6bacff RC |
242 | |
243 | GET_UCHAR(BZ_X_MAGIC_3, uc) | |
ba95a000 | 244 | if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC); |
ef6bacff RC |
245 | |
246 | GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8) | |
ba95a000 RC |
247 | if (s->blockSize100k < (BZ_HDR_0 + 1) || |
248 | s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC); | |
249 | s->blockSize100k -= BZ_HDR_0; | |
ef6bacff RC |
250 | |
251 | if (s->smallDecompress) { | |
252 | s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) ); | |
253 | s->ll4 = BZALLOC( | |
254 | ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) | |
255 | ); | |
256 | if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR); | |
257 | } else { | |
258 | s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) ); | |
259 | if (s->tt == NULL) RETURN(BZ_MEM_ERROR); | |
260 | } | |
261 | ||
262 | GET_UCHAR(BZ_X_BLKHDR_1, uc); | |
263 | ||
264 | if (uc == 0x17) goto endhdr_2; | |
265 | if (uc != 0x31) RETURN(BZ_DATA_ERROR); | |
266 | GET_UCHAR(BZ_X_BLKHDR_2, uc); | |
267 | if (uc != 0x41) RETURN(BZ_DATA_ERROR); | |
268 | GET_UCHAR(BZ_X_BLKHDR_3, uc); | |
269 | if (uc != 0x59) RETURN(BZ_DATA_ERROR); | |
270 | GET_UCHAR(BZ_X_BLKHDR_4, uc); | |
271 | if (uc != 0x26) RETURN(BZ_DATA_ERROR); | |
272 | GET_UCHAR(BZ_X_BLKHDR_5, uc); | |
273 | if (uc != 0x53) RETURN(BZ_DATA_ERROR); | |
274 | GET_UCHAR(BZ_X_BLKHDR_6, uc); | |
275 | if (uc != 0x59) RETURN(BZ_DATA_ERROR); | |
276 | ||
277 | s->currBlockNo++; | |
278 | if (s->verbosity >= 2) | |
279 | VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo ); | |
280 | ||
281 | s->storedBlockCRC = 0; | |
282 | GET_UCHAR(BZ_X_BCRC_1, uc); | |
283 | s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); | |
284 | GET_UCHAR(BZ_X_BCRC_2, uc); | |
285 | s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); | |
286 | GET_UCHAR(BZ_X_BCRC_3, uc); | |
287 | s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); | |
288 | GET_UCHAR(BZ_X_BCRC_4, uc); | |
289 | s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); | |
290 | ||
291 | GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1); | |
292 | ||
293 | s->origPtr = 0; | |
294 | GET_UCHAR(BZ_X_ORIGPTR_1, uc); | |
295 | s->origPtr = (s->origPtr << 8) | ((Int32)uc); | |
296 | GET_UCHAR(BZ_X_ORIGPTR_2, uc); | |
297 | s->origPtr = (s->origPtr << 8) | ((Int32)uc); | |
298 | GET_UCHAR(BZ_X_ORIGPTR_3, uc); | |
299 | s->origPtr = (s->origPtr << 8) | ((Int32)uc); | |
300 | ||
301 | if (s->origPtr < 0) | |
302 | RETURN(BZ_DATA_ERROR); | |
303 | if (s->origPtr > 10 + 100000*s->blockSize100k) | |
304 | RETURN(BZ_DATA_ERROR); | |
305 | ||
306 | /*--- Receive the mapping table ---*/ | |
307 | for (i = 0; i < 16; i++) { | |
308 | GET_BIT(BZ_X_MAPPING_1, uc); | |
309 | if (uc == 1) | |
310 | s->inUse16[i] = True; else | |
311 | s->inUse16[i] = False; | |
312 | } | |
313 | ||
314 | for (i = 0; i < 256; i++) s->inUse[i] = False; | |
315 | ||
316 | for (i = 0; i < 16; i++) | |
317 | if (s->inUse16[i]) | |
318 | for (j = 0; j < 16; j++) { | |
319 | GET_BIT(BZ_X_MAPPING_2, uc); | |
320 | if (uc == 1) s->inUse[i * 16 + j] = True; | |
321 | } | |
322 | makeMaps_d ( s ); | |
323 | if (s->nInUse == 0) RETURN(BZ_DATA_ERROR); | |
324 | alphaSize = s->nInUse+2; | |
325 | ||
326 | /*--- Now the selectors ---*/ | |
327 | GET_BITS(BZ_X_SELECTOR_1, nGroups, 3); | |
328 | if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR); | |
329 | GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15); | |
330 | if (nSelectors < 1) RETURN(BZ_DATA_ERROR); | |
331 | for (i = 0; i < nSelectors; i++) { | |
332 | j = 0; | |
333 | while (True) { | |
334 | GET_BIT(BZ_X_SELECTOR_3, uc); | |
335 | if (uc == 0) break; | |
336 | j++; | |
337 | if (j >= nGroups) RETURN(BZ_DATA_ERROR); | |
338 | } | |
339 | s->selectorMtf[i] = j; | |
340 | } | |
341 | ||
342 | /*--- Undo the MTF values for the selectors. ---*/ | |
343 | { | |
344 | UChar pos[BZ_N_GROUPS], tmp, v; | |
345 | for (v = 0; v < nGroups; v++) pos[v] = v; | |
346 | ||
347 | for (i = 0; i < nSelectors; i++) { | |
348 | v = s->selectorMtf[i]; | |
349 | tmp = pos[v]; | |
350 | while (v > 0) { pos[v] = pos[v-1]; v--; } | |
351 | pos[0] = tmp; | |
352 | s->selector[i] = tmp; | |
353 | } | |
354 | } | |
355 | ||
356 | /*--- Now the coding tables ---*/ | |
357 | for (t = 0; t < nGroups; t++) { | |
358 | GET_BITS(BZ_X_CODING_1, curr, 5); | |
359 | for (i = 0; i < alphaSize; i++) { | |
360 | while (True) { | |
361 | if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR); | |
362 | GET_BIT(BZ_X_CODING_2, uc); | |
363 | if (uc == 0) break; | |
364 | GET_BIT(BZ_X_CODING_3, uc); | |
365 | if (uc == 0) curr++; else curr--; | |
366 | } | |
367 | s->len[t][i] = curr; | |
368 | } | |
369 | } | |
370 | ||
371 | /*--- Create the Huffman decoding tables ---*/ | |
372 | for (t = 0; t < nGroups; t++) { | |
373 | minLen = 32; | |
374 | maxLen = 0; | |
375 | for (i = 0; i < alphaSize; i++) { | |
376 | if (s->len[t][i] > maxLen) maxLen = s->len[t][i]; | |
377 | if (s->len[t][i] < minLen) minLen = s->len[t][i]; | |
378 | } | |
379 | BZ2_hbCreateDecodeTables ( | |
380 | &(s->limit[t][0]), | |
381 | &(s->base[t][0]), | |
382 | &(s->perm[t][0]), | |
383 | &(s->len[t][0]), | |
384 | minLen, maxLen, alphaSize | |
385 | ); | |
386 | s->minLens[t] = minLen; | |
387 | } | |
388 | ||
389 | /*--- Now the MTF values ---*/ | |
390 | ||
391 | EOB = s->nInUse+1; | |
392 | nblockMAX = 100000 * s->blockSize100k; | |
393 | groupNo = -1; | |
394 | groupPos = 0; | |
395 | ||
396 | for (i = 0; i <= 255; i++) s->unzftab[i] = 0; | |
397 | ||
398 | /*-- MTF init --*/ | |
399 | { | |
400 | Int32 ii, jj, kk; | |
401 | kk = MTFA_SIZE-1; | |
402 | for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) { | |
403 | for (jj = MTFL_SIZE-1; jj >= 0; jj--) { | |
404 | s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj); | |
405 | kk--; | |
406 | } | |
407 | s->mtfbase[ii] = kk + 1; | |
408 | } | |
409 | } | |
410 | /*-- end MTF init --*/ | |
411 | ||
412 | nblock = 0; | |
413 | GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym); | |
414 | ||
415 | while (True) { | |
416 | ||
417 | if (nextSym == EOB) break; | |
418 | ||
419 | if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) { | |
420 | ||
421 | es = -1; | |
422 | N = 1; | |
423 | do { | |
424 | if (nextSym == BZ_RUNA) es = es + (0+1) * N; else | |
425 | if (nextSym == BZ_RUNB) es = es + (1+1) * N; | |
426 | N = N * 2; | |
427 | GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym); | |
428 | } | |
429 | while (nextSym == BZ_RUNA || nextSym == BZ_RUNB); | |
430 | ||
431 | es++; | |
432 | uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ]; | |
433 | s->unzftab[uc] += es; | |
434 | ||
435 | if (s->smallDecompress) | |
436 | while (es > 0) { | |
437 | if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); | |
438 | s->ll16[nblock] = (UInt16)uc; | |
439 | nblock++; | |
440 | es--; | |
441 | } | |
442 | else | |
443 | while (es > 0) { | |
444 | if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); | |
445 | s->tt[nblock] = (UInt32)uc; | |
446 | nblock++; | |
447 | es--; | |
448 | }; | |
449 | ||
450 | continue; | |
451 | ||
452 | } else { | |
453 | ||
454 | if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); | |
455 | ||
456 | /*-- uc = MTF ( nextSym-1 ) --*/ | |
457 | { | |
458 | Int32 ii, jj, kk, pp, lno, off; | |
459 | UInt32 nn; | |
460 | nn = (UInt32)(nextSym - 1); | |
461 | ||
462 | if (nn < MTFL_SIZE) { | |
463 | /* avoid general-case expense */ | |
464 | pp = s->mtfbase[0]; | |
465 | uc = s->mtfa[pp+nn]; | |
466 | while (nn > 3) { | |
467 | Int32 z = pp+nn; | |
468 | s->mtfa[(z) ] = s->mtfa[(z)-1]; | |
469 | s->mtfa[(z)-1] = s->mtfa[(z)-2]; | |
470 | s->mtfa[(z)-2] = s->mtfa[(z)-3]; | |
471 | s->mtfa[(z)-3] = s->mtfa[(z)-4]; | |
472 | nn -= 4; | |
473 | } | |
474 | while (nn > 0) { | |
475 | s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; | |
476 | }; | |
477 | s->mtfa[pp] = uc; | |
478 | } else { | |
479 | /* general case */ | |
480 | lno = nn / MTFL_SIZE; | |
481 | off = nn % MTFL_SIZE; | |
482 | pp = s->mtfbase[lno] + off; | |
483 | uc = s->mtfa[pp]; | |
484 | while (pp > s->mtfbase[lno]) { | |
485 | s->mtfa[pp] = s->mtfa[pp-1]; pp--; | |
486 | }; | |
487 | s->mtfbase[lno]++; | |
488 | while (lno > 0) { | |
489 | s->mtfbase[lno]--; | |
490 | s->mtfa[s->mtfbase[lno]] | |
491 | = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1]; | |
492 | lno--; | |
493 | } | |
494 | s->mtfbase[0]--; | |
495 | s->mtfa[s->mtfbase[0]] = uc; | |
496 | if (s->mtfbase[0] == 0) { | |
497 | kk = MTFA_SIZE-1; | |
498 | for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) { | |
499 | for (jj = MTFL_SIZE-1; jj >= 0; jj--) { | |
500 | s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj]; | |
501 | kk--; | |
502 | } | |
503 | s->mtfbase[ii] = kk + 1; | |
504 | } | |
505 | } | |
506 | } | |
507 | } | |
508 | /*-- end uc = MTF ( nextSym-1 ) --*/ | |
509 | ||
510 | s->unzftab[s->seqToUnseq[uc]]++; | |
511 | if (s->smallDecompress) | |
512 | s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else | |
513 | s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]); | |
514 | nblock++; | |
515 | ||
516 | GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym); | |
517 | continue; | |
518 | } | |
519 | } | |
520 | ||
521 | /* Now we know what nblock is, we can do a better sanity | |
522 | check on s->origPtr. | |
523 | */ | |
524 | if (s->origPtr < 0 || s->origPtr >= nblock) | |
525 | RETURN(BZ_DATA_ERROR); | |
526 | ||
527 | s->state_out_len = 0; | |
528 | s->state_out_ch = 0; | |
529 | BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); | |
530 | s->state = BZ_X_OUTPUT; | |
531 | if (s->verbosity >= 2) VPrintf0 ( "rt+rld" ); | |
532 | ||
533 | /*-- Set up cftab to facilitate generation of T^(-1) --*/ | |
534 | s->cftab[0] = 0; | |
535 | for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1]; | |
536 | for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1]; | |
537 | ||
538 | if (s->smallDecompress) { | |
539 | ||
540 | /*-- Make a copy of cftab, used in generation of T --*/ | |
541 | for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i]; | |
542 | ||
543 | /*-- compute the T vector --*/ | |
544 | for (i = 0; i < nblock; i++) { | |
545 | uc = (UChar)(s->ll16[i]); | |
546 | SET_LL(i, s->cftabCopy[uc]); | |
547 | s->cftabCopy[uc]++; | |
548 | } | |
549 | ||
550 | /*-- Compute T^(-1) by pointer reversal on T --*/ | |
551 | i = s->origPtr; | |
552 | j = GET_LL(i); | |
553 | do { | |
554 | Int32 tmp = GET_LL(j); | |
555 | SET_LL(j, i); | |
556 | i = j; | |
557 | j = tmp; | |
558 | } | |
559 | while (i != s->origPtr); | |
560 | ||
561 | s->tPos = s->origPtr; | |
562 | s->nblock_used = 0; | |
563 | if (s->blockRandomised) { | |
564 | BZ_RAND_INIT_MASK; | |
565 | BZ_GET_SMALL(s->k0); s->nblock_used++; | |
566 | BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; | |
567 | } else { | |
568 | BZ_GET_SMALL(s->k0); s->nblock_used++; | |
569 | } | |
570 | ||
571 | } else { | |
572 | ||
573 | /*-- compute the T^(-1) vector --*/ | |
574 | for (i = 0; i < nblock; i++) { | |
575 | uc = (UChar)(s->tt[i] & 0xff); | |
576 | s->tt[s->cftab[uc]] |= (i << 8); | |
577 | s->cftab[uc]++; | |
578 | } | |
579 | ||
580 | s->tPos = s->tt[s->origPtr] >> 8; | |
581 | s->nblock_used = 0; | |
582 | if (s->blockRandomised) { | |
583 | BZ_RAND_INIT_MASK; | |
584 | BZ_GET_FAST(s->k0); s->nblock_used++; | |
585 | BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; | |
586 | } else { | |
587 | BZ_GET_FAST(s->k0); s->nblock_used++; | |
588 | } | |
589 | ||
590 | } | |
591 | ||
592 | RETURN(BZ_OK); | |
593 | ||
594 | ||
595 | ||
596 | endhdr_2: | |
597 | ||
598 | GET_UCHAR(BZ_X_ENDHDR_2, uc); | |
599 | if (uc != 0x72) RETURN(BZ_DATA_ERROR); | |
600 | GET_UCHAR(BZ_X_ENDHDR_3, uc); | |
601 | if (uc != 0x45) RETURN(BZ_DATA_ERROR); | |
602 | GET_UCHAR(BZ_X_ENDHDR_4, uc); | |
603 | if (uc != 0x38) RETURN(BZ_DATA_ERROR); | |
604 | GET_UCHAR(BZ_X_ENDHDR_5, uc); | |
605 | if (uc != 0x50) RETURN(BZ_DATA_ERROR); | |
606 | GET_UCHAR(BZ_X_ENDHDR_6, uc); | |
607 | if (uc != 0x90) RETURN(BZ_DATA_ERROR); | |
608 | ||
609 | s->storedCombinedCRC = 0; | |
610 | GET_UCHAR(BZ_X_CCRC_1, uc); | |
611 | s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); | |
612 | GET_UCHAR(BZ_X_CCRC_2, uc); | |
613 | s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); | |
614 | GET_UCHAR(BZ_X_CCRC_3, uc); | |
615 | s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); | |
616 | GET_UCHAR(BZ_X_CCRC_4, uc); | |
617 | s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); | |
618 | ||
619 | s->state = BZ_X_IDLE; | |
620 | RETURN(BZ_STREAM_END); | |
621 | ||
622 | default: AssertH ( False, 4001 ); | |
623 | } | |
624 | ||
625 | AssertH ( False, 4002 ); | |
626 | ||
627 | save_state_and_return: | |
628 | ||
629 | s->save_i = i; | |
630 | s->save_j = j; | |
631 | s->save_t = t; | |
632 | s->save_alphaSize = alphaSize; | |
633 | s->save_nGroups = nGroups; | |
634 | s->save_nSelectors = nSelectors; | |
635 | s->save_EOB = EOB; | |
636 | s->save_groupNo = groupNo; | |
637 | s->save_groupPos = groupPos; | |
638 | s->save_nextSym = nextSym; | |
639 | s->save_nblockMAX = nblockMAX; | |
640 | s->save_nblock = nblock; | |
641 | s->save_es = es; | |
642 | s->save_N = N; | |
643 | s->save_curr = curr; | |
644 | s->save_zt = zt; | |
645 | s->save_zn = zn; | |
646 | s->save_zvec = zvec; | |
647 | s->save_zj = zj; | |
648 | s->save_gSel = gSel; | |
649 | s->save_gMinlen = gMinlen; | |
650 | s->save_gLimit = gLimit; | |
651 | s->save_gBase = gBase; | |
652 | s->save_gPerm = gPerm; | |
653 | ||
654 | return retVal; | |
655 | } | |
656 | ||
657 | ||
658 | /*-------------------------------------------------------------*/ | |
659 | /*--- end decompress.c ---*/ | |
660 | /*-------------------------------------------------------------*/ |