1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/modules/libbz2/src/decompress.c Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,626 @@
1.4 +
1.5 +/*-------------------------------------------------------------*/
1.6 +/*--- Decompression machinery ---*/
1.7 +/*--- decompress.c ---*/
1.8 +/*-------------------------------------------------------------*/
1.9 +
1.10 +/* ------------------------------------------------------------------
1.11 + This file is part of bzip2/libbzip2, a program and library for
1.12 + lossless, block-sorting data compression.
1.13 +
1.14 + bzip2/libbzip2 version 1.0.4 of 20 December 2006
1.15 + Copyright (C) 1996-2006 Julian Seward <jseward@bzip.org>
1.16 +
1.17 + Please read the WARNING, DISCLAIMER and PATENTS sections in the
1.18 + README file.
1.19 +
1.20 + This program is released under the terms of the license contained
1.21 + in the file LICENSE.
1.22 + ------------------------------------------------------------------ */
1.23 +
1.24 +
1.25 +#include "bzlib_private.h"
1.26 +
1.27 +
1.28 +/*---------------------------------------------------*/
1.29 +static
1.30 +void makeMaps_d ( DState* s )
1.31 +{
1.32 + Int32 i;
1.33 + s->nInUse = 0;
1.34 + for (i = 0; i < 256; i++)
1.35 + if (s->inUse[i]) {
1.36 + s->seqToUnseq[s->nInUse] = i;
1.37 + s->nInUse++;
1.38 + }
1.39 +}
1.40 +
1.41 +
1.42 +/*---------------------------------------------------*/
1.43 +#define RETURN(rrr) \
1.44 + { retVal = rrr; goto save_state_and_return; };
1.45 +
1.46 +#define GET_BITS(lll,vvv,nnn) \
1.47 + case lll: s->state = lll; \
1.48 + while (True) { \
1.49 + if (s->bsLive >= nnn) { \
1.50 + UInt32 v; \
1.51 + v = (s->bsBuff >> \
1.52 + (s->bsLive-nnn)) & ((1 << nnn)-1); \
1.53 + s->bsLive -= nnn; \
1.54 + vvv = v; \
1.55 + break; \
1.56 + } \
1.57 + if (s->strm->avail_in == 0) RETURN(BZ_OK); \
1.58 + s->bsBuff \
1.59 + = (s->bsBuff << 8) | \
1.60 + ((UInt32) \
1.61 + (*((UChar*)(s->strm->next_in)))); \
1.62 + s->bsLive += 8; \
1.63 + s->strm->next_in++; \
1.64 + s->strm->avail_in--; \
1.65 + s->strm->total_in_lo32++; \
1.66 + if (s->strm->total_in_lo32 == 0) \
1.67 + s->strm->total_in_hi32++; \
1.68 + }
1.69 +
1.70 +#define GET_UCHAR(lll,uuu) \
1.71 + GET_BITS(lll,uuu,8)
1.72 +
1.73 +#define GET_BIT(lll,uuu) \
1.74 + GET_BITS(lll,uuu,1)
1.75 +
1.76 +/*---------------------------------------------------*/
1.77 +#define GET_MTF_VAL(label1,label2,lval) \
1.78 +{ \
1.79 + if (groupPos == 0) { \
1.80 + groupNo++; \
1.81 + if (groupNo >= nSelectors) \
1.82 + RETURN(BZ_DATA_ERROR); \
1.83 + groupPos = BZ_G_SIZE; \
1.84 + gSel = s->selector[groupNo]; \
1.85 + gMinlen = s->minLens[gSel]; \
1.86 + gLimit = &(s->limit[gSel][0]); \
1.87 + gPerm = &(s->perm[gSel][0]); \
1.88 + gBase = &(s->base[gSel][0]); \
1.89 + } \
1.90 + groupPos--; \
1.91 + zn = gMinlen; \
1.92 + GET_BITS(label1, zvec, zn); \
1.93 + while (1) { \
1.94 + if (zn > 20 /* the longest code */) \
1.95 + RETURN(BZ_DATA_ERROR); \
1.96 + if (zvec <= gLimit[zn]) break; \
1.97 + zn++; \
1.98 + GET_BIT(label2, zj); \
1.99 + zvec = (zvec << 1) | zj; \
1.100 + }; \
1.101 + if (zvec - gBase[zn] < 0 \
1.102 + || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \
1.103 + RETURN(BZ_DATA_ERROR); \
1.104 + lval = gPerm[zvec - gBase[zn]]; \
1.105 +}
1.106 +
1.107 +
1.108 +/*---------------------------------------------------*/
1.109 +Int32 BZ2_decompress ( DState* s )
1.110 +{
1.111 + UChar uc;
1.112 + Int32 retVal;
1.113 + Int32 minLen, maxLen;
1.114 + bz_stream* strm = s->strm;
1.115 +
1.116 + /* stuff that needs to be saved/restored */
1.117 + Int32 i;
1.118 + Int32 j;
1.119 + Int32 t;
1.120 + Int32 alphaSize;
1.121 + Int32 nGroups;
1.122 + Int32 nSelectors;
1.123 + Int32 EOB;
1.124 + Int32 groupNo;
1.125 + Int32 groupPos;
1.126 + Int32 nextSym;
1.127 + Int32 nblockMAX;
1.128 + Int32 nblock;
1.129 + Int32 es;
1.130 + Int32 N;
1.131 + Int32 curr;
1.132 + Int32 zt;
1.133 + Int32 zn;
1.134 + Int32 zvec;
1.135 + Int32 zj;
1.136 + Int32 gSel;
1.137 + Int32 gMinlen;
1.138 + Int32* gLimit;
1.139 + Int32* gBase;
1.140 + Int32* gPerm;
1.141 +
1.142 + if (s->state == BZ_X_MAGIC_1) {
1.143 + /*initialise the save area*/
1.144 + s->save_i = 0;
1.145 + s->save_j = 0;
1.146 + s->save_t = 0;
1.147 + s->save_alphaSize = 0;
1.148 + s->save_nGroups = 0;
1.149 + s->save_nSelectors = 0;
1.150 + s->save_EOB = 0;
1.151 + s->save_groupNo = 0;
1.152 + s->save_groupPos = 0;
1.153 + s->save_nextSym = 0;
1.154 + s->save_nblockMAX = 0;
1.155 + s->save_nblock = 0;
1.156 + s->save_es = 0;
1.157 + s->save_N = 0;
1.158 + s->save_curr = 0;
1.159 + s->save_zt = 0;
1.160 + s->save_zn = 0;
1.161 + s->save_zvec = 0;
1.162 + s->save_zj = 0;
1.163 + s->save_gSel = 0;
1.164 + s->save_gMinlen = 0;
1.165 + s->save_gLimit = NULL;
1.166 + s->save_gBase = NULL;
1.167 + s->save_gPerm = NULL;
1.168 + }
1.169 +
1.170 + /*restore from the save area*/
1.171 + i = s->save_i;
1.172 + j = s->save_j;
1.173 + t = s->save_t;
1.174 + alphaSize = s->save_alphaSize;
1.175 + nGroups = s->save_nGroups;
1.176 + nSelectors = s->save_nSelectors;
1.177 + EOB = s->save_EOB;
1.178 + groupNo = s->save_groupNo;
1.179 + groupPos = s->save_groupPos;
1.180 + nextSym = s->save_nextSym;
1.181 + nblockMAX = s->save_nblockMAX;
1.182 + nblock = s->save_nblock;
1.183 + es = s->save_es;
1.184 + N = s->save_N;
1.185 + curr = s->save_curr;
1.186 + zt = s->save_zt;
1.187 + zn = s->save_zn;
1.188 + zvec = s->save_zvec;
1.189 + zj = s->save_zj;
1.190 + gSel = s->save_gSel;
1.191 + gMinlen = s->save_gMinlen;
1.192 + gLimit = s->save_gLimit;
1.193 + gBase = s->save_gBase;
1.194 + gPerm = s->save_gPerm;
1.195 +
1.196 + retVal = BZ_OK;
1.197 +
1.198 + switch (s->state) {
1.199 +
1.200 + GET_UCHAR(BZ_X_MAGIC_1, uc);
1.201 + if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
1.202 +
1.203 + GET_UCHAR(BZ_X_MAGIC_2, uc);
1.204 + if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
1.205 +
1.206 + GET_UCHAR(BZ_X_MAGIC_3, uc)
1.207 + if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
1.208 +
1.209 + GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
1.210 + if (s->blockSize100k < (BZ_HDR_0 + 1) ||
1.211 + s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
1.212 + s->blockSize100k -= BZ_HDR_0;
1.213 +
1.214 + if (s->smallDecompress) {
1.215 + s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
1.216 + s->ll4 = BZALLOC(
1.217 + ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
1.218 + );
1.219 + if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
1.220 + } else {
1.221 + s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
1.222 + if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
1.223 + }
1.224 +
1.225 + GET_UCHAR(BZ_X_BLKHDR_1, uc);
1.226 +
1.227 + if (uc == 0x17) goto endhdr_2;
1.228 + if (uc != 0x31) RETURN(BZ_DATA_ERROR);
1.229 + GET_UCHAR(BZ_X_BLKHDR_2, uc);
1.230 + if (uc != 0x41) RETURN(BZ_DATA_ERROR);
1.231 + GET_UCHAR(BZ_X_BLKHDR_3, uc);
1.232 + if (uc != 0x59) RETURN(BZ_DATA_ERROR);
1.233 + GET_UCHAR(BZ_X_BLKHDR_4, uc);
1.234 + if (uc != 0x26) RETURN(BZ_DATA_ERROR);
1.235 + GET_UCHAR(BZ_X_BLKHDR_5, uc);
1.236 + if (uc != 0x53) RETURN(BZ_DATA_ERROR);
1.237 + GET_UCHAR(BZ_X_BLKHDR_6, uc);
1.238 + if (uc != 0x59) RETURN(BZ_DATA_ERROR);
1.239 +
1.240 + s->currBlockNo++;
1.241 + if (s->verbosity >= 2)
1.242 + VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo );
1.243 +
1.244 + s->storedBlockCRC = 0;
1.245 + GET_UCHAR(BZ_X_BCRC_1, uc);
1.246 + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1.247 + GET_UCHAR(BZ_X_BCRC_2, uc);
1.248 + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1.249 + GET_UCHAR(BZ_X_BCRC_3, uc);
1.250 + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1.251 + GET_UCHAR(BZ_X_BCRC_4, uc);
1.252 + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1.253 +
1.254 + GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
1.255 +
1.256 + s->origPtr = 0;
1.257 + GET_UCHAR(BZ_X_ORIGPTR_1, uc);
1.258 + s->origPtr = (s->origPtr << 8) | ((Int32)uc);
1.259 + GET_UCHAR(BZ_X_ORIGPTR_2, uc);
1.260 + s->origPtr = (s->origPtr << 8) | ((Int32)uc);
1.261 + GET_UCHAR(BZ_X_ORIGPTR_3, uc);
1.262 + s->origPtr = (s->origPtr << 8) | ((Int32)uc);
1.263 +
1.264 + if (s->origPtr < 0)
1.265 + RETURN(BZ_DATA_ERROR);
1.266 + if (s->origPtr > 10 + 100000*s->blockSize100k)
1.267 + RETURN(BZ_DATA_ERROR);
1.268 +
1.269 + /*--- Receive the mapping table ---*/
1.270 + for (i = 0; i < 16; i++) {
1.271 + GET_BIT(BZ_X_MAPPING_1, uc);
1.272 + if (uc == 1)
1.273 + s->inUse16[i] = True; else
1.274 + s->inUse16[i] = False;
1.275 + }
1.276 +
1.277 + for (i = 0; i < 256; i++) s->inUse[i] = False;
1.278 +
1.279 + for (i = 0; i < 16; i++)
1.280 + if (s->inUse16[i])
1.281 + for (j = 0; j < 16; j++) {
1.282 + GET_BIT(BZ_X_MAPPING_2, uc);
1.283 + if (uc == 1) s->inUse[i * 16 + j] = True;
1.284 + }
1.285 + makeMaps_d ( s );
1.286 + if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
1.287 + alphaSize = s->nInUse+2;
1.288 +
1.289 + /*--- Now the selectors ---*/
1.290 + GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
1.291 + if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
1.292 + GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
1.293 + if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
1.294 + for (i = 0; i < nSelectors; i++) {
1.295 + j = 0;
1.296 + while (True) {
1.297 + GET_BIT(BZ_X_SELECTOR_3, uc);
1.298 + if (uc == 0) break;
1.299 + j++;
1.300 + if (j >= nGroups) RETURN(BZ_DATA_ERROR);
1.301 + }
1.302 + s->selectorMtf[i] = j;
1.303 + }
1.304 +
1.305 + /*--- Undo the MTF values for the selectors. ---*/
1.306 + {
1.307 + UChar pos[BZ_N_GROUPS], tmp, v;
1.308 + for (v = 0; v < nGroups; v++) pos[v] = v;
1.309 +
1.310 + for (i = 0; i < nSelectors; i++) {
1.311 + v = s->selectorMtf[i];
1.312 + tmp = pos[v];
1.313 + while (v > 0) { pos[v] = pos[v-1]; v--; }
1.314 + pos[0] = tmp;
1.315 + s->selector[i] = tmp;
1.316 + }
1.317 + }
1.318 +
1.319 + /*--- Now the coding tables ---*/
1.320 + for (t = 0; t < nGroups; t++) {
1.321 + GET_BITS(BZ_X_CODING_1, curr, 5);
1.322 + for (i = 0; i < alphaSize; i++) {
1.323 + while (True) {
1.324 + if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
1.325 + GET_BIT(BZ_X_CODING_2, uc);
1.326 + if (uc == 0) break;
1.327 + GET_BIT(BZ_X_CODING_3, uc);
1.328 + if (uc == 0) curr++; else curr--;
1.329 + }
1.330 + s->len[t][i] = curr;
1.331 + }
1.332 + }
1.333 +
1.334 + /*--- Create the Huffman decoding tables ---*/
1.335 + for (t = 0; t < nGroups; t++) {
1.336 + minLen = 32;
1.337 + maxLen = 0;
1.338 + for (i = 0; i < alphaSize; i++) {
1.339 + if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
1.340 + if (s->len[t][i] < minLen) minLen = s->len[t][i];
1.341 + }
1.342 + BZ2_hbCreateDecodeTables (
1.343 + &(s->limit[t][0]),
1.344 + &(s->base[t][0]),
1.345 + &(s->perm[t][0]),
1.346 + &(s->len[t][0]),
1.347 + minLen, maxLen, alphaSize
1.348 + );
1.349 + s->minLens[t] = minLen;
1.350 + }
1.351 +
1.352 + /*--- Now the MTF values ---*/
1.353 +
1.354 + EOB = s->nInUse+1;
1.355 + nblockMAX = 100000 * s->blockSize100k;
1.356 + groupNo = -1;
1.357 + groupPos = 0;
1.358 +
1.359 + for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
1.360 +
1.361 + /*-- MTF init --*/
1.362 + {
1.363 + Int32 ii, jj, kk;
1.364 + kk = MTFA_SIZE-1;
1.365 + for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
1.366 + for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
1.367 + s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
1.368 + kk--;
1.369 + }
1.370 + s->mtfbase[ii] = kk + 1;
1.371 + }
1.372 + }
1.373 + /*-- end MTF init --*/
1.374 +
1.375 + nblock = 0;
1.376 + GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
1.377 +
1.378 + while (True) {
1.379 +
1.380 + if (nextSym == EOB) break;
1.381 +
1.382 + if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
1.383 +
1.384 + es = -1;
1.385 + N = 1;
1.386 + do {
1.387 + if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
1.388 + if (nextSym == BZ_RUNB) es = es + (1+1) * N;
1.389 + N = N * 2;
1.390 + GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
1.391 + }
1.392 + while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
1.393 +
1.394 + es++;
1.395 + uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
1.396 + s->unzftab[uc] += es;
1.397 +
1.398 + if (s->smallDecompress)
1.399 + while (es > 0) {
1.400 + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
1.401 + s->ll16[nblock] = (UInt16)uc;
1.402 + nblock++;
1.403 + es--;
1.404 + }
1.405 + else
1.406 + while (es > 0) {
1.407 + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
1.408 + s->tt[nblock] = (UInt32)uc;
1.409 + nblock++;
1.410 + es--;
1.411 + };
1.412 +
1.413 + continue;
1.414 +
1.415 + } else {
1.416 +
1.417 + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
1.418 +
1.419 + /*-- uc = MTF ( nextSym-1 ) --*/
1.420 + {
1.421 + Int32 ii, jj, kk, pp, lno, off;
1.422 + UInt32 nn;
1.423 + nn = (UInt32)(nextSym - 1);
1.424 +
1.425 + if (nn < MTFL_SIZE) {
1.426 + /* avoid general-case expense */
1.427 + pp = s->mtfbase[0];
1.428 + uc = s->mtfa[pp+nn];
1.429 + while (nn > 3) {
1.430 + Int32 z = pp+nn;
1.431 + s->mtfa[(z) ] = s->mtfa[(z)-1];
1.432 + s->mtfa[(z)-1] = s->mtfa[(z)-2];
1.433 + s->mtfa[(z)-2] = s->mtfa[(z)-3];
1.434 + s->mtfa[(z)-3] = s->mtfa[(z)-4];
1.435 + nn -= 4;
1.436 + }
1.437 + while (nn > 0) {
1.438 + s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
1.439 + };
1.440 + s->mtfa[pp] = uc;
1.441 + } else {
1.442 + /* general case */
1.443 + lno = nn / MTFL_SIZE;
1.444 + off = nn % MTFL_SIZE;
1.445 + pp = s->mtfbase[lno] + off;
1.446 + uc = s->mtfa[pp];
1.447 + while (pp > s->mtfbase[lno]) {
1.448 + s->mtfa[pp] = s->mtfa[pp-1]; pp--;
1.449 + };
1.450 + s->mtfbase[lno]++;
1.451 + while (lno > 0) {
1.452 + s->mtfbase[lno]--;
1.453 + s->mtfa[s->mtfbase[lno]]
1.454 + = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
1.455 + lno--;
1.456 + }
1.457 + s->mtfbase[0]--;
1.458 + s->mtfa[s->mtfbase[0]] = uc;
1.459 + if (s->mtfbase[0] == 0) {
1.460 + kk = MTFA_SIZE-1;
1.461 + for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
1.462 + for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
1.463 + s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
1.464 + kk--;
1.465 + }
1.466 + s->mtfbase[ii] = kk + 1;
1.467 + }
1.468 + }
1.469 + }
1.470 + }
1.471 + /*-- end uc = MTF ( nextSym-1 ) --*/
1.472 +
1.473 + s->unzftab[s->seqToUnseq[uc]]++;
1.474 + if (s->smallDecompress)
1.475 + s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
1.476 + s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]);
1.477 + nblock++;
1.478 +
1.479 + GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
1.480 + continue;
1.481 + }
1.482 + }
1.483 +
1.484 + /* Now we know what nblock is, we can do a better sanity
1.485 + check on s->origPtr.
1.486 + */
1.487 + if (s->origPtr < 0 || s->origPtr >= nblock)
1.488 + RETURN(BZ_DATA_ERROR);
1.489 +
1.490 + /*-- Set up cftab to facilitate generation of T^(-1) --*/
1.491 + s->cftab[0] = 0;
1.492 + for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
1.493 + for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
1.494 + for (i = 0; i <= 256; i++) {
1.495 + if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
1.496 + /* s->cftab[i] can legitimately be == nblock */
1.497 + RETURN(BZ_DATA_ERROR);
1.498 + }
1.499 + }
1.500 +
1.501 + s->state_out_len = 0;
1.502 + s->state_out_ch = 0;
1.503 + BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
1.504 + s->state = BZ_X_OUTPUT;
1.505 + if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
1.506 +
1.507 + if (s->smallDecompress) {
1.508 +
1.509 + /*-- Make a copy of cftab, used in generation of T --*/
1.510 + for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
1.511 +
1.512 + /*-- compute the T vector --*/
1.513 + for (i = 0; i < nblock; i++) {
1.514 + uc = (UChar)(s->ll16[i]);
1.515 + SET_LL(i, s->cftabCopy[uc]);
1.516 + s->cftabCopy[uc]++;
1.517 + }
1.518 +
1.519 + /*-- Compute T^(-1) by pointer reversal on T --*/
1.520 + i = s->origPtr;
1.521 + j = GET_LL(i);
1.522 + do {
1.523 + Int32 tmp = GET_LL(j);
1.524 + SET_LL(j, i);
1.525 + i = j;
1.526 + j = tmp;
1.527 + }
1.528 + while (i != s->origPtr);
1.529 +
1.530 + s->tPos = s->origPtr;
1.531 + s->nblock_used = 0;
1.532 + if (s->blockRandomised) {
1.533 + BZ_RAND_INIT_MASK;
1.534 + BZ_GET_SMALL(s->k0); s->nblock_used++;
1.535 + BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
1.536 + } else {
1.537 + BZ_GET_SMALL(s->k0); s->nblock_used++;
1.538 + }
1.539 +
1.540 + } else {
1.541 +
1.542 + /*-- compute the T^(-1) vector --*/
1.543 + for (i = 0; i < nblock; i++) {
1.544 + uc = (UChar)(s->tt[i] & 0xff);
1.545 + s->tt[s->cftab[uc]] |= (i << 8);
1.546 + s->cftab[uc]++;
1.547 + }
1.548 +
1.549 + s->tPos = s->tt[s->origPtr] >> 8;
1.550 + s->nblock_used = 0;
1.551 + if (s->blockRandomised) {
1.552 + BZ_RAND_INIT_MASK;
1.553 + BZ_GET_FAST(s->k0); s->nblock_used++;
1.554 + BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
1.555 + } else {
1.556 + BZ_GET_FAST(s->k0); s->nblock_used++;
1.557 + }
1.558 +
1.559 + }
1.560 +
1.561 + RETURN(BZ_OK);
1.562 +
1.563 +
1.564 +
1.565 + endhdr_2:
1.566 +
1.567 + GET_UCHAR(BZ_X_ENDHDR_2, uc);
1.568 + if (uc != 0x72) RETURN(BZ_DATA_ERROR);
1.569 + GET_UCHAR(BZ_X_ENDHDR_3, uc);
1.570 + if (uc != 0x45) RETURN(BZ_DATA_ERROR);
1.571 + GET_UCHAR(BZ_X_ENDHDR_4, uc);
1.572 + if (uc != 0x38) RETURN(BZ_DATA_ERROR);
1.573 + GET_UCHAR(BZ_X_ENDHDR_5, uc);
1.574 + if (uc != 0x50) RETURN(BZ_DATA_ERROR);
1.575 + GET_UCHAR(BZ_X_ENDHDR_6, uc);
1.576 + if (uc != 0x90) RETURN(BZ_DATA_ERROR);
1.577 +
1.578 + s->storedCombinedCRC = 0;
1.579 + GET_UCHAR(BZ_X_CCRC_1, uc);
1.580 + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1.581 + GET_UCHAR(BZ_X_CCRC_2, uc);
1.582 + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1.583 + GET_UCHAR(BZ_X_CCRC_3, uc);
1.584 + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1.585 + GET_UCHAR(BZ_X_CCRC_4, uc);
1.586 + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1.587 +
1.588 + s->state = BZ_X_IDLE;
1.589 + RETURN(BZ_STREAM_END);
1.590 +
1.591 + default: AssertH ( False, 4001 );
1.592 + }
1.593 +
1.594 + AssertH ( False, 4002 );
1.595 +
1.596 + save_state_and_return:
1.597 +
1.598 + s->save_i = i;
1.599 + s->save_j = j;
1.600 + s->save_t = t;
1.601 + s->save_alphaSize = alphaSize;
1.602 + s->save_nGroups = nGroups;
1.603 + s->save_nSelectors = nSelectors;
1.604 + s->save_EOB = EOB;
1.605 + s->save_groupNo = groupNo;
1.606 + s->save_groupPos = groupPos;
1.607 + s->save_nextSym = nextSym;
1.608 + s->save_nblockMAX = nblockMAX;
1.609 + s->save_nblock = nblock;
1.610 + s->save_es = es;
1.611 + s->save_N = N;
1.612 + s->save_curr = curr;
1.613 + s->save_zt = zt;
1.614 + s->save_zn = zn;
1.615 + s->save_zvec = zvec;
1.616 + s->save_zj = zj;
1.617 + s->save_gSel = gSel;
1.618 + s->save_gMinlen = gMinlen;
1.619 + s->save_gLimit = gLimit;
1.620 + s->save_gBase = gBase;
1.621 + s->save_gPerm = gPerm;
1.622 +
1.623 + return retVal;
1.624 +}
1.625 +
1.626 +
1.627 +/*-------------------------------------------------------------*/
1.628 +/*--- end decompress.c ---*/
1.629 +/*-------------------------------------------------------------*/
