1 /*
2 Copyright (c) 2005-2021 Intel Corporation
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 /*-------------------------------------------------------------*/
18 /*--- Decompression machinery ---*/
19 /*--- decompress.cpp ---*/
20 /*-------------------------------------------------------------*/
21
22 /* ------------------------------------------------------------------
23 The original source for this example:
24 This file is part of bzip2/libbzip2, a program and library for
25 lossless, block-sorting data compression.
26
27 bzip2/libbzip2 version 1.0.6 of 6 September 2010
28 Copyright (C) 1996-2010 Julian Seward <[email protected]>
29
30 This program, "bzip2", the associated library "libbzip2", and all
31 documentation, are copyright (C) 1996-2010 Julian R Seward. All
32 rights reserved.
33
34 Redistribution and use in source and binary forms, with or without
35 modification, are permitted provided that the following conditions
36 are met:
37
38 1. Redistributions of source code must retain the above copyright
39 notice, this list of conditions and the following disclaimer.
40
41 2. The origin of this software must not be misrepresented; you must
42 not claim that you wrote the original software. If you use this
43 software in a product, an acknowledgment in the product
44 documentation would be appreciated but is not required.
45
46 3. Altered source versions must be plainly marked as such, and must
47 not be misrepresented as being the original software.
48
49 4. The name of the author may not be used to endorse or promote
50 products derived from this software without specific prior written
51 permission.
52
53 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
54 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
55 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
57 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
59 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
60 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
61 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
62 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
63 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64
65 Julian Seward, [email protected]
66 bzip2/libbzip2 version 1.0.6 of 6 September 2010
67 ------------------------------------------------------------------ */
68
69 #include "bzlib_private.hpp"
70
71 /*---------------------------------------------------*/
makeMaps_d(DState * s)72 static void makeMaps_d(DState* s) {
73 Int32 i;
74 s->nInUse = 0;
75 for (i = 0; i < 256; i++)
76 if (s->inUse[i]) {
77 s->seqToUnseq[s->nInUse] = i;
78 s->nInUse++;
79 }
80 }
81
82 /*---------------------------------------------------*/
83 #define RETURN(rrr) \
84 { \
85 retVal = rrr; \
86 goto save_state_and_return; \
87 };
88
89 #define GET_BITS(lll, vvv, nnn) \
90 case lll: \
91 s->state = lll; \
92 while (True) { \
93 if (s->bsLive >= nnn) { \
94 UInt32 v; \
95 v = (s->bsBuff >> (s->bsLive - nnn)) & ((1 << nnn) - 1); \
96 s->bsLive -= nnn; \
97 vvv = v; \
98 break; \
99 } \
100 if (s->strm->avail_in == 0) \
101 RETURN(BZ_OK); \
102 s->bsBuff = (s->bsBuff << 8) | ((UInt32)(*((UChar*)(s->strm->next_in)))); \
103 s->bsLive += 8; \
104 s->strm->next_in++; \
105 s->strm->avail_in--; \
106 s->strm->total_in_lo32++; \
107 if (s->strm->total_in_lo32 == 0) \
108 s->strm->total_in_hi32++; \
109 }
110
111 #define GET_UCHAR(lll, uuu) GET_BITS(lll, uuu, 8)
112
113 #define GET_BIT(lll, uuu) GET_BITS(lll, uuu, 1)
114
115 /*---------------------------------------------------*/
116 #define GET_MTF_VAL(label1, label2, lval) \
117 { \
118 if (groupPos == 0) { \
119 groupNo++; \
120 if (groupNo >= nSelectors) \
121 RETURN(BZ_DATA_ERROR); \
122 groupPos = BZ_G_SIZE; \
123 gSel = s->selector[groupNo]; \
124 gMinlen = s->minLens[gSel]; \
125 gLimit = &(s->limit[gSel][0]); \
126 gPerm = &(s->perm[gSel][0]); \
127 gBase = &(s->base[gSel][0]); \
128 } \
129 groupPos--; \
130 zn = gMinlen; \
131 GET_BITS(label1, zvec, zn); \
132 while (1) { \
133 if (zn > 20 /* the longest code */) \
134 RETURN(BZ_DATA_ERROR); \
135 if (zvec <= gLimit[zn]) \
136 break; \
137 zn++; \
138 GET_BIT(label2, zj); \
139 zvec = (zvec << 1) | zj; \
140 }; \
141 if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \
142 RETURN(BZ_DATA_ERROR); \
143 lval = gPerm[zvec - gBase[zn]]; \
144 }
145
146 /*---------------------------------------------------*/
BZ2_decompress(DState * s)147 Int32 BZ2_decompress(DState* s) {
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 = nullptr;
203 s->save_gBase = nullptr;
204 s->save_gPerm = nullptr;
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 GET_UCHAR(BZ_X_MAGIC_1, uc);
237 if (uc != BZ_HDR_B)
238 RETURN(BZ_DATA_ERROR_MAGIC);
239
240 GET_UCHAR(BZ_X_MAGIC_2, uc);
241 if (uc != BZ_HDR_Z)
242 RETURN(BZ_DATA_ERROR_MAGIC);
243
244 GET_UCHAR(BZ_X_MAGIC_3, uc)
245 if (uc != BZ_HDR_h)
246 RETURN(BZ_DATA_ERROR_MAGIC);
247
248 GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
249 if (s->blockSize100k < (BZ_HDR_0 + 1) || s->blockSize100k > (BZ_HDR_0 + 9))
250 RETURN(BZ_DATA_ERROR_MAGIC);
251 s->blockSize100k -= BZ_HDR_0;
252
253 if (s->smallDecompress) {
254 s->ll16 = (UInt16*)BZALLOC(s->blockSize100k * 100000 * sizeof(UInt16));
255 s->ll4 = (UChar*)BZALLOC(((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar));
256 if (s->ll16 == nullptr || s->ll4 == nullptr)
257 RETURN(BZ_MEM_ERROR);
258 }
259 else {
260 s->tt = (UInt32*)BZALLOC(s->blockSize100k * 100000 * sizeof(Int32));
261 if (s->tt == nullptr)
262 RETURN(BZ_MEM_ERROR);
263 }
264
265 GET_UCHAR(BZ_X_BLKHDR_1, uc);
266
267 if (uc == 0x17)
268 goto endhdr_2;
269 if (uc != 0x31)
270 RETURN(BZ_DATA_ERROR);
271 GET_UCHAR(BZ_X_BLKHDR_2, uc);
272 if (uc != 0x41)
273 RETURN(BZ_DATA_ERROR);
274 GET_UCHAR(BZ_X_BLKHDR_3, uc);
275 if (uc != 0x59)
276 RETURN(BZ_DATA_ERROR);
277 GET_UCHAR(BZ_X_BLKHDR_4, uc);
278 if (uc != 0x26)
279 RETURN(BZ_DATA_ERROR);
280 GET_UCHAR(BZ_X_BLKHDR_5, uc);
281 if (uc != 0x53)
282 RETURN(BZ_DATA_ERROR);
283 GET_UCHAR(BZ_X_BLKHDR_6, uc);
284 if (uc != 0x59)
285 RETURN(BZ_DATA_ERROR);
286
287 s->currBlockNo++;
288 if (s->verbosity >= 2)
289 VPrintf1("\n [%d: huff+mtf ", s->currBlockNo);
290
291 s->storedBlockCRC = 0;
292 GET_UCHAR(BZ_X_BCRC_1, uc);
293 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
294 GET_UCHAR(BZ_X_BCRC_2, uc);
295 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
296 GET_UCHAR(BZ_X_BCRC_3, uc);
297 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
298 GET_UCHAR(BZ_X_BCRC_4, uc);
299 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
300
301 GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
302
303 s->origPtr = 0;
304 GET_UCHAR(BZ_X_ORIGPTR_1, uc);
305 s->origPtr = (s->origPtr << 8) | ((Int32)uc);
306 GET_UCHAR(BZ_X_ORIGPTR_2, uc);
307 s->origPtr = (s->origPtr << 8) | ((Int32)uc);
308 GET_UCHAR(BZ_X_ORIGPTR_3, uc);
309 s->origPtr = (s->origPtr << 8) | ((Int32)uc);
310
311 if (s->origPtr < 0)
312 RETURN(BZ_DATA_ERROR);
313 if (s->origPtr > 10 + 100000 * s->blockSize100k)
314 RETURN(BZ_DATA_ERROR);
315
316 /*--- Receive the mapping table ---*/
317 for (i = 0; i < 16; i++) {
318 GET_BIT(BZ_X_MAPPING_1, uc);
319 if (uc == 1)
320 s->inUse16[i] = True;
321 else
322 s->inUse16[i] = False;
323 }
324
325 for (i = 0; i < 256; i++)
326 s->inUse[i] = False;
327
328 for (i = 0; i < 16; i++)
329 if (s->inUse16[i])
330 for (j = 0; j < 16; j++) {
331 GET_BIT(BZ_X_MAPPING_2, uc);
332 if (uc == 1)
333 s->inUse[i * 16 + j] = True;
334 }
335 makeMaps_d(s);
336 if (s->nInUse == 0)
337 RETURN(BZ_DATA_ERROR);
338 alphaSize = s->nInUse + 2;
339
340 /*--- Now the selectors ---*/
341 GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
342 if (nGroups < 2 || nGroups > 6)
343 RETURN(BZ_DATA_ERROR);
344 GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
345 if (nSelectors < 1)
346 RETURN(BZ_DATA_ERROR);
347 for (i = 0; i < nSelectors; i++) {
348 j = 0;
349 while (True) {
350 GET_BIT(BZ_X_SELECTOR_3, uc);
351 if (uc == 0)
352 break;
353 j++;
354 if (j >= nGroups)
355 RETURN(BZ_DATA_ERROR);
356 }
357 s->selectorMtf[i] = j;
358 }
359
360 /*--- Undo the MTF values for the selectors. ---*/
361 {
362 UChar pos[BZ_N_GROUPS], tmp, v;
363 for (i = 0; i < nGroups; i++)
364 pos[i] = i;
365
366 for (i = 0; i < nSelectors; i++) {
367 v = s->selectorMtf[i];
368 tmp = pos[v];
369 while (v > 0) {
370 pos[v] = pos[v - 1];
371 v--;
372 }
373 pos[0] = tmp;
374 s->selector[i] = tmp;
375 }
376 }
377
378 /*--- Now the coding tables ---*/
379 for (j = 0; j < nGroups; j++) {
380 GET_BITS(BZ_X_CODING_1, curr, 5);
381 for (i = 0; i < alphaSize; i++) {
382 while (True) {
383 if (curr < 1 || curr > 20)
384 RETURN(BZ_DATA_ERROR);
385 GET_BIT(BZ_X_CODING_2, uc);
386 if (uc == 0)
387 break;
388 GET_BIT(BZ_X_CODING_3, uc);
389 if (uc == 0)
390 curr++;
391 else
392 curr--;
393 }
394 s->len[j][i] = curr;
395 }
396 }
397
398 /*--- Create the Huffman decoding tables ---*/
399 for (j = 0; j < nGroups; j++) {
400 minLen = 32;
401 maxLen = 0;
402 for (i = 0; i < alphaSize; i++) {
403 if (s->len[j][i] > maxLen)
404 maxLen = s->len[j][i];
405 if (s->len[j][i] < minLen)
406 minLen = s->len[j][i];
407 }
408 BZ2_hbCreateDecodeTables(&(s->limit[j][0]),
409 &(s->base[j][0]),
410 &(s->perm[j][0]),
411 &(s->len[j][0]),
412 minLen,
413 maxLen,
414 alphaSize);
415 s->minLens[j] = minLen;
416 }
417
418 /*--- Now the MTF values ---*/
419
420 EOB = s->nInUse + 1;
421 nblockMAX = 100000 * s->blockSize100k;
422 groupNo = -1;
423 groupPos = 0;
424
425 for (i = 0; i <= 255; i++)
426 s->unzftab[i] = 0;
427
428 /*-- MTF init --*/
429 {
430 Int32 l, j, k;
431 k = MTFA_SIZE - 1;
432 for (l = 256 / MTFL_SIZE - 1; l >= 0; l--) {
433 for (j = MTFL_SIZE - 1; j >= 0; j--) {
434 s->mtfa[k] = (UChar)(l * MTFL_SIZE + j);
435 k--;
436 }
437 s->mtfbase[l] = k + 1;
438 }
439 }
440 /*-- end MTF init --*/
441
442 nblock = 0;
443 GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
444
445 while (True) {
446 if (nextSym == EOB)
447 break;
448
449 if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
450 es = -1;
451 N = 1;
452 do {
453 /* Check that N doesn't get too big, so that es doesn't
454 go negative. The maximum value that can be
455 RUNA/RUNB encoded is equal to the block size (post
456 the initial RLE), viz, 900k, so bounding N at 2
457 million should guard against overflow without
458 rejecting any legitimate inputs. */
459 if (N >= 2 * 1024 * 1024)
460 RETURN(BZ_DATA_ERROR);
461 if (nextSym == BZ_RUNA)
462 es = es + (0 + 1) * N;
463 else if (nextSym == BZ_RUNB)
464 es = es + (1 + 1) * N;
465 N = N * 2;
466 GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
467 } while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
468
469 es++;
470 uc = s->seqToUnseq[s->mtfa[s->mtfbase[0]]];
471 s->unzftab[uc] += es;
472
473 if (s->smallDecompress)
474 while (es > 0) {
475 if (nblock >= nblockMAX)
476 RETURN(BZ_DATA_ERROR);
477 s->ll16[nblock] = (UInt16)uc;
478 nblock++;
479 es--;
480 }
481 else
482 while (es > 0) {
483 if (nblock >= nblockMAX)
484 RETURN(BZ_DATA_ERROR);
485 s->tt[nblock] = (UInt32)uc;
486 nblock++;
487 es--;
488 };
489
490 continue;
491 }
492 else {
493 if (nblock >= nblockMAX)
494 RETURN(BZ_DATA_ERROR);
495
496 /*-- uc = MTF ( nextSym-1 ) --*/
497 {
498 Int32 i, j, k, l, lno, off;
499 UInt32 nn;
500 nn = (UInt32)(nextSym - 1);
501
502 if (nn < MTFL_SIZE) {
503 /* avoid general-case expense */
504 l = s->mtfbase[0];
505 uc = s->mtfa[l + nn];
506 while (nn > 3) {
507 Int32 z = l + nn;
508 s->mtfa[(z)] = s->mtfa[(z)-1];
509 s->mtfa[(z)-1] = s->mtfa[(z)-2];
510 s->mtfa[(z)-2] = s->mtfa[(z)-3];
511 s->mtfa[(z)-3] = s->mtfa[(z)-4];
512 nn -= 4;
513 }
514 while (nn > 0) {
515 s->mtfa[(l + nn)] = s->mtfa[(l + nn) - 1];
516 nn--;
517 };
518 s->mtfa[l] = uc;
519 }
520 else {
521 /* general case */
522 lno = nn / MTFL_SIZE;
523 off = nn % MTFL_SIZE;
524 l = s->mtfbase[lno] + off;
525 uc = s->mtfa[l];
526 while (l > s->mtfbase[lno]) {
527 s->mtfa[l] = s->mtfa[l - 1];
528 l--;
529 };
530 s->mtfbase[lno]++;
531 while (lno > 0) {
532 s->mtfbase[lno]--;
533 s->mtfa[s->mtfbase[lno]] = s->mtfa[s->mtfbase[lno - 1] + MTFL_SIZE - 1];
534 lno--;
535 }
536 s->mtfbase[0]--;
537 s->mtfa[s->mtfbase[0]] = uc;
538 if (s->mtfbase[0] == 0) {
539 k = MTFA_SIZE - 1;
540 for (i = 256 / MTFL_SIZE - 1; i >= 0; i--) {
541 for (j = MTFL_SIZE - 1; j >= 0; j--) {
542 s->mtfa[k] = s->mtfa[s->mtfbase[i] + j];
543 k--;
544 }
545 s->mtfbase[i] = k + 1;
546 }
547 }
548 }
549 }
550 /*-- end uc = MTF ( nextSym-1 ) --*/
551
552 s->unzftab[s->seqToUnseq[uc]]++;
553 if (s->smallDecompress)
554 s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]);
555 else
556 s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]);
557 nblock++;
558
559 GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
560 continue;
561 }
562 }
563
564 /* Now we know what nblock is, we can do a better sanity
565 check on s->origPtr.
566 */
567 if (s->origPtr < 0 || s->origPtr >= nblock)
568 RETURN(BZ_DATA_ERROR);
569
570 /*-- Set up cftab to facilitate generation of T^(-1) --*/
571 /* Check: unzftab entries in range. */
572 for (i = 0; i <= 255; i++) {
573 if (s->unzftab[i] < 0 || s->unzftab[i] > nblock)
574 RETURN(BZ_DATA_ERROR);
575 }
576 /* Actually generate cftab. */
577 s->cftab[0] = 0;
578 for (i = 1; i <= 256; i++)
579 s->cftab[i] = s->unzftab[i - 1];
580 for (i = 1; i <= 256; i++)
581 s->cftab[i] += s->cftab[i - 1];
582 /* Check: cftab entries in range. */
583 for (i = 0; i <= 256; i++) {
584 if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
585 /* s->cftab[i] can legitimately be == nblock */
586 RETURN(BZ_DATA_ERROR);
587 }
588 }
589 /* Check: cftab entries non-descending. */
590 for (i = 1; i <= 256; i++) {
591 if (s->cftab[i - 1] > s->cftab[i]) {
592 RETURN(BZ_DATA_ERROR);
593 }
594 }
595
596 s->state_out_len = 0;
597 s->state_out_ch = 0;
598 BZ_INITIALISE_CRC(s->calculatedBlockCRC);
599 s->state = BZ_X_OUTPUT;
600 if (s->verbosity >= 2)
601 VPrintf0("rt+rld");
602
603 if (s->smallDecompress) {
604 /*-- Make a copy of cftab, used in generation of T --*/
605 for (i = 0; i <= 256; i++)
606 s->cftabCopy[i] = s->cftab[i];
607
608 /*-- compute the T vector --*/
609 for (i = 0; i < nblock; i++) {
610 uc = (UChar)(s->ll16[i]);
611 SET_LL(i, s->cftabCopy[uc]);
612 s->cftabCopy[uc]++;
613 }
614
615 /*-- Compute T^(-1) by pointer reversal on T --*/
616 i = s->origPtr;
617 j = GET_LL(i);
618 do {
619 Int32 tmp = GET_LL(j);
620 SET_LL(j, i);
621 i = j;
622 j = tmp;
623 } while (i != s->origPtr);
624
625 s->tPos = s->origPtr;
626 s->nblock_used = 0;
627 if (s->blockRandomised) {
628 BZ_RAND_INIT_MASK;
629 BZ_GET_SMALL(s->k0);
630 s->nblock_used++;
631 BZ_RAND_UPD_MASK;
632 s->k0 ^= BZ_RAND_MASK;
633 }
634 else {
635 BZ_GET_SMALL(s->k0);
636 s->nblock_used++;
637 }
638 }
639 else {
640 /*-- compute the T^(-1) vector --*/
641 for (i = 0; i < nblock; i++) {
642 uc = (UChar)(s->tt[i] & 0xff);
643 s->tt[s->cftab[uc]] |= (i << 8);
644 s->cftab[uc]++;
645 }
646
647 s->tPos = s->tt[s->origPtr] >> 8;
648 s->nblock_used = 0;
649 if (s->blockRandomised) {
650 BZ_RAND_INIT_MASK;
651 BZ_GET_FAST(s->k0);
652 s->nblock_used++;
653 BZ_RAND_UPD_MASK;
654 s->k0 ^= BZ_RAND_MASK;
655 }
656 else {
657 BZ_GET_FAST(s->k0);
658 s->nblock_used++;
659 }
660 }
661
662 RETURN(BZ_OK);
663
664 endhdr_2:
665
666 GET_UCHAR(BZ_X_ENDHDR_2, uc);
667 if (uc != 0x72)
668 RETURN(BZ_DATA_ERROR);
669 GET_UCHAR(BZ_X_ENDHDR_3, uc);
670 if (uc != 0x45)
671 RETURN(BZ_DATA_ERROR);
672 GET_UCHAR(BZ_X_ENDHDR_4, uc);
673 if (uc != 0x38)
674 RETURN(BZ_DATA_ERROR);
675 GET_UCHAR(BZ_X_ENDHDR_5, uc);
676 if (uc != 0x50)
677 RETURN(BZ_DATA_ERROR);
678 GET_UCHAR(BZ_X_ENDHDR_6, uc);
679 if (uc != 0x90)
680 RETURN(BZ_DATA_ERROR);
681
682 s->storedCombinedCRC = 0;
683 GET_UCHAR(BZ_X_CCRC_1, uc);
684 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
685 GET_UCHAR(BZ_X_CCRC_2, uc);
686 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
687 GET_UCHAR(BZ_X_CCRC_3, uc);
688 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
689 GET_UCHAR(BZ_X_CCRC_4, uc);
690 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
691
692 s->state = BZ_X_IDLE;
693 RETURN(BZ_STREAM_END);
694
695 default: AssertH(False, 4001);
696 }
697
698 AssertH(False, 4002);
699
700 save_state_and_return:
701
702 s->save_i = i;
703 s->save_j = j;
704 s->save_t = t;
705 s->save_alphaSize = alphaSize;
706 s->save_nGroups = nGroups;
707 s->save_nSelectors = nSelectors;
708 s->save_EOB = EOB;
709 s->save_groupNo = groupNo;
710 s->save_groupPos = groupPos;
711 s->save_nextSym = nextSym;
712 s->save_nblockMAX = nblockMAX;
713 s->save_nblock = nblock;
714 s->save_es = es;
715 s->save_N = N;
716 s->save_curr = curr;
717 s->save_zt = zt;
718 s->save_zn = zn;
719 s->save_zvec = zvec;
720 s->save_zj = zj;
721 s->save_gSel = gSel;
722 s->save_gMinlen = gMinlen;
723 s->save_gLimit = gLimit;
724 s->save_gBase = gBase;
725 s->save_gPerm = gPerm;
726
727 return retVal;
728 }
729
730 /*-------------------------------------------------------------*/
731 /*--- end decompress.c ---*/
732 /*-------------------------------------------------------------*/
733