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