cannam@89: cannam@89: /*-------------------------------------------------------------*/ cannam@89: /*--- Decompression machinery ---*/ cannam@89: /*--- decompress.c ---*/ cannam@89: /*-------------------------------------------------------------*/ cannam@89: cannam@89: /* ------------------------------------------------------------------ cannam@89: This file is part of bzip2/libbzip2, a program and library for cannam@89: lossless, block-sorting data compression. cannam@89: cannam@89: bzip2/libbzip2 version 1.0.6 of 6 September 2010 cannam@89: Copyright (C) 1996-2010 Julian Seward cannam@89: cannam@89: Please read the WARNING, DISCLAIMER and PATENTS sections in the cannam@89: README file. cannam@89: cannam@89: This program is released under the terms of the license contained cannam@89: in the file LICENSE. cannam@89: ------------------------------------------------------------------ */ cannam@89: cannam@89: cannam@89: #include "bzlib_private.h" cannam@89: cannam@89: cannam@89: /*---------------------------------------------------*/ cannam@89: static cannam@89: void makeMaps_d ( DState* s ) cannam@89: { cannam@89: Int32 i; cannam@89: s->nInUse = 0; cannam@89: for (i = 0; i < 256; i++) cannam@89: if (s->inUse[i]) { cannam@89: s->seqToUnseq[s->nInUse] = i; cannam@89: s->nInUse++; cannam@89: } cannam@89: } cannam@89: cannam@89: cannam@89: /*---------------------------------------------------*/ cannam@89: #define RETURN(rrr) \ cannam@89: { retVal = rrr; goto save_state_and_return; }; cannam@89: cannam@89: #define GET_BITS(lll,vvv,nnn) \ cannam@89: case lll: s->state = lll; \ cannam@89: while (True) { \ cannam@89: if (s->bsLive >= nnn) { \ cannam@89: UInt32 v; \ cannam@89: v = (s->bsBuff >> \ cannam@89: (s->bsLive-nnn)) & ((1 << nnn)-1); \ cannam@89: s->bsLive -= nnn; \ cannam@89: vvv = v; \ cannam@89: break; \ cannam@89: } \ cannam@89: if (s->strm->avail_in == 0) RETURN(BZ_OK); \ cannam@89: s->bsBuff \ cannam@89: = (s->bsBuff << 8) | \ cannam@89: ((UInt32) \ cannam@89: (*((UChar*)(s->strm->next_in)))); \ cannam@89: s->bsLive += 8; \ cannam@89: s->strm->next_in++; \ cannam@89: s->strm->avail_in--; \ cannam@89: s->strm->total_in_lo32++; \ cannam@89: if (s->strm->total_in_lo32 == 0) \ cannam@89: s->strm->total_in_hi32++; \ cannam@89: } cannam@89: cannam@89: #define GET_UCHAR(lll,uuu) \ cannam@89: GET_BITS(lll,uuu,8) cannam@89: cannam@89: #define GET_BIT(lll,uuu) \ cannam@89: GET_BITS(lll,uuu,1) cannam@89: cannam@89: /*---------------------------------------------------*/ cannam@89: #define GET_MTF_VAL(label1,label2,lval) \ cannam@89: { \ cannam@89: if (groupPos == 0) { \ cannam@89: groupNo++; \ cannam@89: if (groupNo >= nSelectors) \ cannam@89: RETURN(BZ_DATA_ERROR); \ cannam@89: groupPos = BZ_G_SIZE; \ cannam@89: gSel = s->selector[groupNo]; \ cannam@89: gMinlen = s->minLens[gSel]; \ cannam@89: gLimit = &(s->limit[gSel][0]); \ cannam@89: gPerm = &(s->perm[gSel][0]); \ cannam@89: gBase = &(s->base[gSel][0]); \ cannam@89: } \ cannam@89: groupPos--; \ cannam@89: zn = gMinlen; \ cannam@89: GET_BITS(label1, zvec, zn); \ cannam@89: while (1) { \ cannam@89: if (zn > 20 /* the longest code */) \ cannam@89: RETURN(BZ_DATA_ERROR); \ cannam@89: if (zvec <= gLimit[zn]) break; \ cannam@89: zn++; \ cannam@89: GET_BIT(label2, zj); \ cannam@89: zvec = (zvec << 1) | zj; \ cannam@89: }; \ cannam@89: if (zvec - gBase[zn] < 0 \ cannam@89: || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \ cannam@89: RETURN(BZ_DATA_ERROR); \ cannam@89: lval = gPerm[zvec - gBase[zn]]; \ cannam@89: } cannam@89: cannam@89: cannam@89: /*---------------------------------------------------*/ cannam@89: Int32 BZ2_decompress ( DState* s ) cannam@89: { cannam@89: UChar uc; cannam@89: Int32 retVal; cannam@89: Int32 minLen, maxLen; cannam@89: bz_stream* strm = s->strm; cannam@89: cannam@89: /* stuff that needs to be saved/restored */ cannam@89: Int32 i; cannam@89: Int32 j; cannam@89: Int32 t; cannam@89: Int32 alphaSize; cannam@89: Int32 nGroups; cannam@89: Int32 nSelectors; cannam@89: Int32 EOB; cannam@89: Int32 groupNo; cannam@89: Int32 groupPos; cannam@89: Int32 nextSym; cannam@89: Int32 nblockMAX; cannam@89: Int32 nblock; cannam@89: Int32 es; cannam@89: Int32 N; cannam@89: Int32 curr; cannam@89: Int32 zt; cannam@89: Int32 zn; cannam@89: Int32 zvec; cannam@89: Int32 zj; cannam@89: Int32 gSel; cannam@89: Int32 gMinlen; cannam@89: Int32* gLimit; cannam@89: Int32* gBase; cannam@89: Int32* gPerm; cannam@89: cannam@89: if (s->state == BZ_X_MAGIC_1) { cannam@89: /*initialise the save area*/ cannam@89: s->save_i = 0; cannam@89: s->save_j = 0; cannam@89: s->save_t = 0; cannam@89: s->save_alphaSize = 0; cannam@89: s->save_nGroups = 0; cannam@89: s->save_nSelectors = 0; cannam@89: s->save_EOB = 0; cannam@89: s->save_groupNo = 0; cannam@89: s->save_groupPos = 0; cannam@89: s->save_nextSym = 0; cannam@89: s->save_nblockMAX = 0; cannam@89: s->save_nblock = 0; cannam@89: s->save_es = 0; cannam@89: s->save_N = 0; cannam@89: s->save_curr = 0; cannam@89: s->save_zt = 0; cannam@89: s->save_zn = 0; cannam@89: s->save_zvec = 0; cannam@89: s->save_zj = 0; cannam@89: s->save_gSel = 0; cannam@89: s->save_gMinlen = 0; cannam@89: s->save_gLimit = NULL; cannam@89: s->save_gBase = NULL; cannam@89: s->save_gPerm = NULL; cannam@89: } cannam@89: cannam@89: /*restore from the save area*/ cannam@89: i = s->save_i; cannam@89: j = s->save_j; cannam@89: t = s->save_t; cannam@89: alphaSize = s->save_alphaSize; cannam@89: nGroups = s->save_nGroups; cannam@89: nSelectors = s->save_nSelectors; cannam@89: EOB = s->save_EOB; cannam@89: groupNo = s->save_groupNo; cannam@89: groupPos = s->save_groupPos; cannam@89: nextSym = s->save_nextSym; cannam@89: nblockMAX = s->save_nblockMAX; cannam@89: nblock = s->save_nblock; cannam@89: es = s->save_es; cannam@89: N = s->save_N; cannam@89: curr = s->save_curr; cannam@89: zt = s->save_zt; cannam@89: zn = s->save_zn; cannam@89: zvec = s->save_zvec; cannam@89: zj = s->save_zj; cannam@89: gSel = s->save_gSel; cannam@89: gMinlen = s->save_gMinlen; cannam@89: gLimit = s->save_gLimit; cannam@89: gBase = s->save_gBase; cannam@89: gPerm = s->save_gPerm; cannam@89: cannam@89: retVal = BZ_OK; cannam@89: cannam@89: switch (s->state) { cannam@89: cannam@89: GET_UCHAR(BZ_X_MAGIC_1, uc); cannam@89: if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC); cannam@89: cannam@89: GET_UCHAR(BZ_X_MAGIC_2, uc); cannam@89: if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC); cannam@89: cannam@89: GET_UCHAR(BZ_X_MAGIC_3, uc) cannam@89: if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC); cannam@89: cannam@89: GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8) cannam@89: if (s->blockSize100k < (BZ_HDR_0 + 1) || cannam@89: s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC); cannam@89: s->blockSize100k -= BZ_HDR_0; cannam@89: cannam@89: if (s->smallDecompress) { cannam@89: s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) ); cannam@89: s->ll4 = BZALLOC( cannam@89: ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) cannam@89: ); cannam@89: if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR); cannam@89: } else { cannam@89: s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) ); cannam@89: if (s->tt == NULL) RETURN(BZ_MEM_ERROR); cannam@89: } cannam@89: cannam@89: GET_UCHAR(BZ_X_BLKHDR_1, uc); cannam@89: cannam@89: if (uc == 0x17) goto endhdr_2; cannam@89: if (uc != 0x31) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_BLKHDR_2, uc); cannam@89: if (uc != 0x41) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_BLKHDR_3, uc); cannam@89: if (uc != 0x59) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_BLKHDR_4, uc); cannam@89: if (uc != 0x26) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_BLKHDR_5, uc); cannam@89: if (uc != 0x53) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_BLKHDR_6, uc); cannam@89: if (uc != 0x59) RETURN(BZ_DATA_ERROR); cannam@89: cannam@89: s->currBlockNo++; cannam@89: if (s->verbosity >= 2) cannam@89: VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo ); cannam@89: cannam@89: s->storedBlockCRC = 0; cannam@89: GET_UCHAR(BZ_X_BCRC_1, uc); cannam@89: s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); cannam@89: GET_UCHAR(BZ_X_BCRC_2, uc); cannam@89: s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); cannam@89: GET_UCHAR(BZ_X_BCRC_3, uc); cannam@89: s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); cannam@89: GET_UCHAR(BZ_X_BCRC_4, uc); cannam@89: s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); cannam@89: cannam@89: GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1); cannam@89: cannam@89: s->origPtr = 0; cannam@89: GET_UCHAR(BZ_X_ORIGPTR_1, uc); cannam@89: s->origPtr = (s->origPtr << 8) | ((Int32)uc); cannam@89: GET_UCHAR(BZ_X_ORIGPTR_2, uc); cannam@89: s->origPtr = (s->origPtr << 8) | ((Int32)uc); cannam@89: GET_UCHAR(BZ_X_ORIGPTR_3, uc); cannam@89: s->origPtr = (s->origPtr << 8) | ((Int32)uc); cannam@89: cannam@89: if (s->origPtr < 0) cannam@89: RETURN(BZ_DATA_ERROR); cannam@89: if (s->origPtr > 10 + 100000*s->blockSize100k) cannam@89: RETURN(BZ_DATA_ERROR); cannam@89: cannam@89: /*--- Receive the mapping table ---*/ cannam@89: for (i = 0; i < 16; i++) { cannam@89: GET_BIT(BZ_X_MAPPING_1, uc); cannam@89: if (uc == 1) cannam@89: s->inUse16[i] = True; else cannam@89: s->inUse16[i] = False; cannam@89: } cannam@89: cannam@89: for (i = 0; i < 256; i++) s->inUse[i] = False; cannam@89: cannam@89: for (i = 0; i < 16; i++) cannam@89: if (s->inUse16[i]) cannam@89: for (j = 0; j < 16; j++) { cannam@89: GET_BIT(BZ_X_MAPPING_2, uc); cannam@89: if (uc == 1) s->inUse[i * 16 + j] = True; cannam@89: } cannam@89: makeMaps_d ( s ); cannam@89: if (s->nInUse == 0) RETURN(BZ_DATA_ERROR); cannam@89: alphaSize = s->nInUse+2; cannam@89: cannam@89: /*--- Now the selectors ---*/ cannam@89: GET_BITS(BZ_X_SELECTOR_1, nGroups, 3); cannam@89: if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR); cannam@89: GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15); cannam@89: if (nSelectors < 1) RETURN(BZ_DATA_ERROR); cannam@89: for (i = 0; i < nSelectors; i++) { cannam@89: j = 0; cannam@89: while (True) { cannam@89: GET_BIT(BZ_X_SELECTOR_3, uc); cannam@89: if (uc == 0) break; cannam@89: j++; cannam@89: if (j >= nGroups) RETURN(BZ_DATA_ERROR); cannam@89: } cannam@89: s->selectorMtf[i] = j; cannam@89: } cannam@89: cannam@89: /*--- Undo the MTF values for the selectors. ---*/ cannam@89: { cannam@89: UChar pos[BZ_N_GROUPS], tmp, v; cannam@89: for (v = 0; v < nGroups; v++) pos[v] = v; cannam@89: cannam@89: for (i = 0; i < nSelectors; i++) { cannam@89: v = s->selectorMtf[i]; cannam@89: tmp = pos[v]; cannam@89: while (v > 0) { pos[v] = pos[v-1]; v--; } cannam@89: pos[0] = tmp; cannam@89: s->selector[i] = tmp; cannam@89: } cannam@89: } cannam@89: cannam@89: /*--- Now the coding tables ---*/ cannam@89: for (t = 0; t < nGroups; t++) { cannam@89: GET_BITS(BZ_X_CODING_1, curr, 5); cannam@89: for (i = 0; i < alphaSize; i++) { cannam@89: while (True) { cannam@89: if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR); cannam@89: GET_BIT(BZ_X_CODING_2, uc); cannam@89: if (uc == 0) break; cannam@89: GET_BIT(BZ_X_CODING_3, uc); cannam@89: if (uc == 0) curr++; else curr--; cannam@89: } cannam@89: s->len[t][i] = curr; cannam@89: } cannam@89: } cannam@89: cannam@89: /*--- Create the Huffman decoding tables ---*/ cannam@89: for (t = 0; t < nGroups; t++) { cannam@89: minLen = 32; cannam@89: maxLen = 0; cannam@89: for (i = 0; i < alphaSize; i++) { cannam@89: if (s->len[t][i] > maxLen) maxLen = s->len[t][i]; cannam@89: if (s->len[t][i] < minLen) minLen = s->len[t][i]; cannam@89: } cannam@89: BZ2_hbCreateDecodeTables ( cannam@89: &(s->limit[t][0]), cannam@89: &(s->base[t][0]), cannam@89: &(s->perm[t][0]), cannam@89: &(s->len[t][0]), cannam@89: minLen, maxLen, alphaSize cannam@89: ); cannam@89: s->minLens[t] = minLen; cannam@89: } cannam@89: cannam@89: /*--- Now the MTF values ---*/ cannam@89: cannam@89: EOB = s->nInUse+1; cannam@89: nblockMAX = 100000 * s->blockSize100k; cannam@89: groupNo = -1; cannam@89: groupPos = 0; cannam@89: cannam@89: for (i = 0; i <= 255; i++) s->unzftab[i] = 0; cannam@89: cannam@89: /*-- MTF init --*/ cannam@89: { cannam@89: Int32 ii, jj, kk; cannam@89: kk = MTFA_SIZE-1; cannam@89: for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) { cannam@89: for (jj = MTFL_SIZE-1; jj >= 0; jj--) { cannam@89: s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj); cannam@89: kk--; cannam@89: } cannam@89: s->mtfbase[ii] = kk + 1; cannam@89: } cannam@89: } cannam@89: /*-- end MTF init --*/ cannam@89: cannam@89: nblock = 0; cannam@89: GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym); cannam@89: cannam@89: while (True) { cannam@89: cannam@89: if (nextSym == EOB) break; cannam@89: cannam@89: if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) { cannam@89: cannam@89: es = -1; cannam@89: N = 1; cannam@89: do { cannam@89: /* Check that N doesn't get too big, so that es doesn't cannam@89: go negative. The maximum value that can be cannam@89: RUNA/RUNB encoded is equal to the block size (post cannam@89: the initial RLE), viz, 900k, so bounding N at 2 cannam@89: million should guard against overflow without cannam@89: rejecting any legitimate inputs. */ cannam@89: if (N >= 2*1024*1024) RETURN(BZ_DATA_ERROR); cannam@89: if (nextSym == BZ_RUNA) es = es + (0+1) * N; else cannam@89: if (nextSym == BZ_RUNB) es = es + (1+1) * N; cannam@89: N = N * 2; cannam@89: GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym); cannam@89: } cannam@89: while (nextSym == BZ_RUNA || nextSym == BZ_RUNB); cannam@89: cannam@89: es++; cannam@89: uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ]; cannam@89: s->unzftab[uc] += es; cannam@89: cannam@89: if (s->smallDecompress) cannam@89: while (es > 0) { cannam@89: if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); cannam@89: s->ll16[nblock] = (UInt16)uc; cannam@89: nblock++; cannam@89: es--; cannam@89: } cannam@89: else cannam@89: while (es > 0) { cannam@89: if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); cannam@89: s->tt[nblock] = (UInt32)uc; cannam@89: nblock++; cannam@89: es--; cannam@89: }; cannam@89: cannam@89: continue; cannam@89: cannam@89: } else { cannam@89: cannam@89: if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); cannam@89: cannam@89: /*-- uc = MTF ( nextSym-1 ) --*/ cannam@89: { cannam@89: Int32 ii, jj, kk, pp, lno, off; cannam@89: UInt32 nn; cannam@89: nn = (UInt32)(nextSym - 1); cannam@89: cannam@89: if (nn < MTFL_SIZE) { cannam@89: /* avoid general-case expense */ cannam@89: pp = s->mtfbase[0]; cannam@89: uc = s->mtfa[pp+nn]; cannam@89: while (nn > 3) { cannam@89: Int32 z = pp+nn; cannam@89: s->mtfa[(z) ] = s->mtfa[(z)-1]; cannam@89: s->mtfa[(z)-1] = s->mtfa[(z)-2]; cannam@89: s->mtfa[(z)-2] = s->mtfa[(z)-3]; cannam@89: s->mtfa[(z)-3] = s->mtfa[(z)-4]; cannam@89: nn -= 4; cannam@89: } cannam@89: while (nn > 0) { cannam@89: s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; cannam@89: }; cannam@89: s->mtfa[pp] = uc; cannam@89: } else { cannam@89: /* general case */ cannam@89: lno = nn / MTFL_SIZE; cannam@89: off = nn % MTFL_SIZE; cannam@89: pp = s->mtfbase[lno] + off; cannam@89: uc = s->mtfa[pp]; cannam@89: while (pp > s->mtfbase[lno]) { cannam@89: s->mtfa[pp] = s->mtfa[pp-1]; pp--; cannam@89: }; cannam@89: s->mtfbase[lno]++; cannam@89: while (lno > 0) { cannam@89: s->mtfbase[lno]--; cannam@89: s->mtfa[s->mtfbase[lno]] cannam@89: = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1]; cannam@89: lno--; cannam@89: } cannam@89: s->mtfbase[0]--; cannam@89: s->mtfa[s->mtfbase[0]] = uc; cannam@89: if (s->mtfbase[0] == 0) { cannam@89: kk = MTFA_SIZE-1; cannam@89: for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) { cannam@89: for (jj = MTFL_SIZE-1; jj >= 0; jj--) { cannam@89: s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj]; cannam@89: kk--; cannam@89: } cannam@89: s->mtfbase[ii] = kk + 1; cannam@89: } cannam@89: } cannam@89: } cannam@89: } cannam@89: /*-- end uc = MTF ( nextSym-1 ) --*/ cannam@89: cannam@89: s->unzftab[s->seqToUnseq[uc]]++; cannam@89: if (s->smallDecompress) cannam@89: s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else cannam@89: s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]); cannam@89: nblock++; cannam@89: cannam@89: GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym); cannam@89: continue; cannam@89: } cannam@89: } cannam@89: cannam@89: /* Now we know what nblock is, we can do a better sanity cannam@89: check on s->origPtr. cannam@89: */ cannam@89: if (s->origPtr < 0 || s->origPtr >= nblock) cannam@89: RETURN(BZ_DATA_ERROR); cannam@89: cannam@89: /*-- Set up cftab to facilitate generation of T^(-1) --*/ cannam@89: /* Check: unzftab entries in range. */ cannam@89: for (i = 0; i <= 255; i++) { cannam@89: if (s->unzftab[i] < 0 || s->unzftab[i] > nblock) cannam@89: RETURN(BZ_DATA_ERROR); cannam@89: } cannam@89: /* Actually generate cftab. */ cannam@89: s->cftab[0] = 0; cannam@89: for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1]; cannam@89: for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1]; cannam@89: /* Check: cftab entries in range. */ cannam@89: for (i = 0; i <= 256; i++) { cannam@89: if (s->cftab[i] < 0 || s->cftab[i] > nblock) { cannam@89: /* s->cftab[i] can legitimately be == nblock */ cannam@89: RETURN(BZ_DATA_ERROR); cannam@89: } cannam@89: } cannam@89: /* Check: cftab entries non-descending. */ cannam@89: for (i = 1; i <= 256; i++) { cannam@89: if (s->cftab[i-1] > s->cftab[i]) { cannam@89: RETURN(BZ_DATA_ERROR); cannam@89: } cannam@89: } cannam@89: cannam@89: s->state_out_len = 0; cannam@89: s->state_out_ch = 0; cannam@89: BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); cannam@89: s->state = BZ_X_OUTPUT; cannam@89: if (s->verbosity >= 2) VPrintf0 ( "rt+rld" ); cannam@89: cannam@89: if (s->smallDecompress) { cannam@89: cannam@89: /*-- Make a copy of cftab, used in generation of T --*/ cannam@89: for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i]; cannam@89: cannam@89: /*-- compute the T vector --*/ cannam@89: for (i = 0; i < nblock; i++) { cannam@89: uc = (UChar)(s->ll16[i]); cannam@89: SET_LL(i, s->cftabCopy[uc]); cannam@89: s->cftabCopy[uc]++; cannam@89: } cannam@89: cannam@89: /*-- Compute T^(-1) by pointer reversal on T --*/ cannam@89: i = s->origPtr; cannam@89: j = GET_LL(i); cannam@89: do { cannam@89: Int32 tmp = GET_LL(j); cannam@89: SET_LL(j, i); cannam@89: i = j; cannam@89: j = tmp; cannam@89: } cannam@89: while (i != s->origPtr); cannam@89: cannam@89: s->tPos = s->origPtr; cannam@89: s->nblock_used = 0; cannam@89: if (s->blockRandomised) { cannam@89: BZ_RAND_INIT_MASK; cannam@89: BZ_GET_SMALL(s->k0); s->nblock_used++; cannam@89: BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; cannam@89: } else { cannam@89: BZ_GET_SMALL(s->k0); s->nblock_used++; cannam@89: } cannam@89: cannam@89: } else { cannam@89: cannam@89: /*-- compute the T^(-1) vector --*/ cannam@89: for (i = 0; i < nblock; i++) { cannam@89: uc = (UChar)(s->tt[i] & 0xff); cannam@89: s->tt[s->cftab[uc]] |= (i << 8); cannam@89: s->cftab[uc]++; cannam@89: } cannam@89: cannam@89: s->tPos = s->tt[s->origPtr] >> 8; cannam@89: s->nblock_used = 0; cannam@89: if (s->blockRandomised) { cannam@89: BZ_RAND_INIT_MASK; cannam@89: BZ_GET_FAST(s->k0); s->nblock_used++; cannam@89: BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; cannam@89: } else { cannam@89: BZ_GET_FAST(s->k0); s->nblock_used++; cannam@89: } cannam@89: cannam@89: } cannam@89: cannam@89: RETURN(BZ_OK); cannam@89: cannam@89: cannam@89: cannam@89: endhdr_2: cannam@89: cannam@89: GET_UCHAR(BZ_X_ENDHDR_2, uc); cannam@89: if (uc != 0x72) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_ENDHDR_3, uc); cannam@89: if (uc != 0x45) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_ENDHDR_4, uc); cannam@89: if (uc != 0x38) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_ENDHDR_5, uc); cannam@89: if (uc != 0x50) RETURN(BZ_DATA_ERROR); cannam@89: GET_UCHAR(BZ_X_ENDHDR_6, uc); cannam@89: if (uc != 0x90) RETURN(BZ_DATA_ERROR); cannam@89: cannam@89: s->storedCombinedCRC = 0; cannam@89: GET_UCHAR(BZ_X_CCRC_1, uc); cannam@89: s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); cannam@89: GET_UCHAR(BZ_X_CCRC_2, uc); cannam@89: s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); cannam@89: GET_UCHAR(BZ_X_CCRC_3, uc); cannam@89: s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); cannam@89: GET_UCHAR(BZ_X_CCRC_4, uc); cannam@89: s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); cannam@89: cannam@89: s->state = BZ_X_IDLE; cannam@89: RETURN(BZ_STREAM_END); cannam@89: cannam@89: default: AssertH ( False, 4001 ); cannam@89: } cannam@89: cannam@89: AssertH ( False, 4002 ); cannam@89: cannam@89: save_state_and_return: cannam@89: cannam@89: s->save_i = i; cannam@89: s->save_j = j; cannam@89: s->save_t = t; cannam@89: s->save_alphaSize = alphaSize; cannam@89: s->save_nGroups = nGroups; cannam@89: s->save_nSelectors = nSelectors; cannam@89: s->save_EOB = EOB; cannam@89: s->save_groupNo = groupNo; cannam@89: s->save_groupPos = groupPos; cannam@89: s->save_nextSym = nextSym; cannam@89: s->save_nblockMAX = nblockMAX; cannam@89: s->save_nblock = nblock; cannam@89: s->save_es = es; cannam@89: s->save_N = N; cannam@89: s->save_curr = curr; cannam@89: s->save_zt = zt; cannam@89: s->save_zn = zn; cannam@89: s->save_zvec = zvec; cannam@89: s->save_zj = zj; cannam@89: s->save_gSel = gSel; cannam@89: s->save_gMinlen = gMinlen; cannam@89: s->save_gLimit = gLimit; cannam@89: s->save_gBase = gBase; cannam@89: s->save_gPerm = gPerm; cannam@89: cannam@89: return retVal; cannam@89: } cannam@89: cannam@89: cannam@89: /*-------------------------------------------------------------*/ cannam@89: /*--- end decompress.c ---*/ cannam@89: /*-------------------------------------------------------------*/