[J-u-boot.git] / lib_generic / bzlib_decompress.c

#include <config.h>
#include <common.h>
#include <watchdog.h>
#ifdef CONFIG_BZIP2

/*-------------------------------------------------------------*/
/*--- Decompression machinery                               ---*/
/*---                                          decompress.c ---*/
/*-------------------------------------------------------------*/

/*--
  This file is a part of bzip2 and/or libbzip2, a program and
  library for lossless, block-sorting data compression.

  Copyright (C) 1996-2002 Julian R Seward.  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:

  1. Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.

  2. The origin of this software must not be misrepresented; you must
     not claim that you wrote the original software.  If you use this
     software in a product, an acknowledgment in the product
     documentation would be appreciated but is not required.

  3. Altered source versions must be plainly marked as such, and must
     not be misrepresented as being the original software.

  4. The name of the author may not be used to endorse or promote
     products derived from this software without specific prior written
     permission.

  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  Julian Seward, Cambridge, UK.
  [email protected]
  bzip2/libbzip2 version 1.0 of 21 March 2000

  This program is based on (at least) the work of:
     Mike Burrows
     David Wheeler
     Peter Fenwick
     Alistair Moffat
     Radford Neal
     Ian H. Witten
     Robert Sedgewick
     Jon L. Bentley

  For more information on these sources, see the manual.
--*/


#include "bzlib_private.h"


/*---------------------------------------------------*/
static
void makeMaps_d ( DState* s )
{
   Int32 i;
   s->nInUse = 0;
   for (i = 0; i < 256; i++)
      if (s->inUse[i]) {
	 s->seqToUnseq[s->nInUse] = i;
	 s->nInUse++;
      }
}


/*---------------------------------------------------*/
#define RETURN(rrr)                               \
   { retVal = rrr; goto save_state_and_return; };

#define GET_BITS(lll,vvv,nnn)                     \
   case lll: s->state = lll;                      \
   while (True) {                                 \
      if (s->bsLive >= nnn) {                     \
	 UInt32 v;                                \
	 v = (s->bsBuff >>                        \
	     (s->bsLive-nnn)) & ((1 << nnn)-1);   \
	 s->bsLive -= nnn;                        \
	 vvv = v;                                 \
	 break;                                   \
      }                                           \
      if (s->strm->avail_in == 0) RETURN(BZ_OK);  \
      s->bsBuff                                   \
	 = (s->bsBuff << 8) |                     \
	   ((UInt32)                              \
	      (*((UChar*)(s->strm->next_in))));   \
      s->bsLive += 8;                             \
      s->strm->next_in++;                         \
      s->strm->avail_in--;                        \
      s->strm->total_in_lo32++;                   \
      if (s->strm->total_in_lo32 == 0)            \
	 s->strm->total_in_hi32++;                \
   }

#define GET_UCHAR(lll,uuu)                        \
   GET_BITS(lll,uuu,8)

#define GET_BIT(lll,uuu)                          \
   GET_BITS(lll,uuu,1)

/*---------------------------------------------------*/
#define GET_MTF_VAL(label1,label2,lval)           \
{                                                 \
   if (groupPos == 0) {                           \
      groupNo++;                                  \
      if (groupNo >= nSelectors)                  \
	 RETURN(BZ_DATA_ERROR);                   \
      groupPos = BZ_G_SIZE;                       \
      gSel = s->selector[groupNo];                \
      gMinlen = s->minLens[gSel];                 \
      gLimit = &(s->limit[gSel][0]);              \
      gPerm = &(s->perm[gSel][0]);                \
      gBase = &(s->base[gSel][0]);                \
   }                                              \
   groupPos--;                                    \
   zn = gMinlen;                                  \
   GET_BITS(label1, zvec, zn);                    \
   while (1) {                                    \
      if (zn > 20 /* the longest code */)         \
	 RETURN(BZ_DATA_ERROR);                   \
      if (zvec <= gLimit[zn]) break;              \
      zn++;                                       \
      GET_BIT(label2, zj);                        \
      zvec = (zvec << 1) | zj;                    \
   };                                             \
   if (zvec - gBase[zn] < 0                       \
       || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE)  \
      RETURN(BZ_DATA_ERROR);                      \
   lval = gPerm[zvec - gBase[zn]];                \
}


/*---------------------------------------------------*/
Int32 BZ2_decompress ( DState* s )
{
   UChar      uc;
   Int32      retVal;
   Int32      minLen, maxLen;
   bz_stream* strm = s->strm;

   /* stuff that needs to be saved/restored */
   Int32  i;
   Int32  j;
   Int32  t;
   Int32  alphaSize;
   Int32  nGroups;
   Int32  nSelectors;
   Int32  EOB;
   Int32  groupNo;
   Int32  groupPos;
   Int32  nextSym;
   Int32  nblockMAX;
   Int32  nblock;
   Int32  es;
   Int32  N;
   Int32  curr;
   Int32  zt;
   Int32  zn;
   Int32  zvec;
   Int32  zj;
   Int32  gSel;
   Int32  gMinlen;
   Int32* gLimit;
   Int32* gBase;
   Int32* gPerm;

   if (s->state == BZ_X_MAGIC_1) {
      /*initialise the save area*/
      s->save_i           = 0;
      s->save_j           = 0;
      s->save_t           = 0;
      s->save_alphaSize   = 0;
      s->save_nGroups     = 0;
      s->save_nSelectors  = 0;
      s->save_EOB         = 0;
      s->save_groupNo     = 0;
      s->save_groupPos    = 0;
      s->save_nextSym     = 0;
      s->save_nblockMAX   = 0;
      s->save_nblock      = 0;
      s->save_es          = 0;
      s->save_N           = 0;
      s->save_curr        = 0;
      s->save_zt          = 0;
      s->save_zn          = 0;
      s->save_zvec        = 0;
      s->save_zj          = 0;
      s->save_gSel        = 0;
      s->save_gMinlen     = 0;
      s->save_gLimit      = NULL;
      s->save_gBase       = NULL;
      s->save_gPerm       = NULL;
   }

   /*restore from the save area*/
   i           = s->save_i;
   j           = s->save_j;
   t           = s->save_t;
   alphaSize   = s->save_alphaSize;
   nGroups     = s->save_nGroups;
   nSelectors  = s->save_nSelectors;
   EOB         = s->save_EOB;
   groupNo     = s->save_groupNo;
   groupPos    = s->save_groupPos;
   nextSym     = s->save_nextSym;
   nblockMAX   = s->save_nblockMAX;
   nblock      = s->save_nblock;
   es          = s->save_es;
   N           = s->save_N;
   curr        = s->save_curr;
   zt          = s->save_zt;
   zn          = s->save_zn;
   zvec        = s->save_zvec;
   zj          = s->save_zj;
   gSel        = s->save_gSel;
   gMinlen     = s->save_gMinlen;
   gLimit      = s->save_gLimit;
   gBase       = s->save_gBase;
   gPerm       = s->save_gPerm;

   retVal = BZ_OK;

   switch (s->state) {

      GET_UCHAR(BZ_X_MAGIC_1, uc);
      if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);

      GET_UCHAR(BZ_X_MAGIC_2, uc);
      if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);

      GET_UCHAR(BZ_X_MAGIC_3, uc)
      if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);

      GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
      if (s->blockSize100k < (BZ_HDR_0 + 1) ||
	  s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
      s->blockSize100k -= BZ_HDR_0;

      if (s->smallDecompress) {
	 s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
	 s->ll4  = BZALLOC(
		      ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
		   );
	 if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
      } else {
	 s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
	 if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
      }

      GET_UCHAR(BZ_X_BLKHDR_1, uc);

      if (uc == 0x17) goto endhdr_2;
      if (uc != 0x31) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_2, uc);
      if (uc != 0x41) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_3, uc);
      if (uc != 0x59) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_4, uc);
      if (uc != 0x26) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_5, uc);
      if (uc != 0x53) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_6, uc);
      if (uc != 0x59) RETURN(BZ_DATA_ERROR);

      s->currBlockNo++;
      if (s->verbosity >= 2)
	 VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );

      s->storedBlockCRC = 0;
      GET_UCHAR(BZ_X_BCRC_1, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_BCRC_2, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_BCRC_3, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_BCRC_4, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);

      GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);

      s->origPtr = 0;
      GET_UCHAR(BZ_X_ORIGPTR_1, uc);
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);
      GET_UCHAR(BZ_X_ORIGPTR_2, uc);
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);
      GET_UCHAR(BZ_X_ORIGPTR_3, uc);
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);

      if (s->origPtr < 0)
	 RETURN(BZ_DATA_ERROR);
      if (s->origPtr > 10 + 100000*s->blockSize100k)
	 RETURN(BZ_DATA_ERROR);

      /*--- Receive the mapping table ---*/
      for (i = 0; i < 16; i++) {
	 GET_BIT(BZ_X_MAPPING_1, uc);
	 if (uc == 1)
	    s->inUse16[i] = True; else
	    s->inUse16[i] = False;
      }

      for (i = 0; i < 256; i++) s->inUse[i] = False;

      for (i = 0; i < 16; i++)
	 if (s->inUse16[i])
	    for (j = 0; j < 16; j++) {
	       GET_BIT(BZ_X_MAPPING_2, uc);
	       if (uc == 1) s->inUse[i * 16 + j] = True;
	    }
      makeMaps_d ( s );
      if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
      alphaSize = s->nInUse+2;

      /*--- Now the selectors ---*/
      GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
      if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
      GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
      if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
      for (i = 0; i < nSelectors; i++) {
	 j = 0;
	 while (True) {
	    GET_BIT(BZ_X_SELECTOR_3, uc);
	    if (uc == 0) break;
	    j++;
	    if (j >= nGroups) RETURN(BZ_DATA_ERROR);
	 }
	 s->selectorMtf[i] = j;
      }

      /*--- Undo the MTF values for the selectors. ---*/
      {
	 UChar pos[BZ_N_GROUPS], tmp, v;
	 for (v = 0; v < nGroups; v++) pos[v] = v;

	 for (i = 0; i < nSelectors; i++) {
	    v = s->selectorMtf[i];
	    tmp = pos[v];
	    while (v > 0) { pos[v] = pos[v-1]; v--; }
	    pos[0] = tmp;
	    s->selector[i] = tmp;
	 }
      }

      /*--- Now the coding tables ---*/
      for (t = 0; t < nGroups; t++) {
	 GET_BITS(BZ_X_CODING_1, curr, 5);
	 for (i = 0; i < alphaSize; i++) {
	    while (True) {
	       if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
	       GET_BIT(BZ_X_CODING_2, uc);
	       if (uc == 0) break;
	       GET_BIT(BZ_X_CODING_3, uc);
	       if (uc == 0) curr++; else curr--;
	    }
	    s->len[t][i] = curr;
	 }
      }

      /*--- Create the Huffman decoding tables ---*/
      for (t = 0; t < nGroups; t++) {
	 minLen = 32;
	 maxLen = 0;
	 for (i = 0; i < alphaSize; i++) {
	    if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
	    if (s->len[t][i] < minLen) minLen = s->len[t][i];
	 }
	 BZ2_hbCreateDecodeTables (
	    &(s->limit[t][0]),
	    &(s->base[t][0]),
	    &(s->perm[t][0]),
	    &(s->len[t][0]),
	    minLen, maxLen, alphaSize
	 );
	 s->minLens[t] = minLen;
      }

      /*--- Now the MTF values ---*/

      EOB      = s->nInUse+1;
      nblockMAX = 100000 * s->blockSize100k;
      groupNo  = -1;
      groupPos = 0;

      for (i = 0; i <= 255; i++) s->unzftab[i] = 0;

      /*-- MTF init --*/
      {
	 Int32 ii, jj, kk;
	 kk = MTFA_SIZE-1;
	 for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
	    for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
	       s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
	       kk--;
	    }
	    s->mtfbase[ii] = kk + 1;
	 }
      }
      /*-- end MTF init --*/

      nblock = 0;
      GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);

      while (True) {

#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
	WATCHDOG_RESET();
#endif
	 if (nextSym == EOB) break;

	 if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {

	    es = -1;
	    N = 1;
	    do {
	       if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
	       if (nextSym == BZ_RUNB) es = es + (1+1) * N;
	       N = N * 2;
	       GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
	    }
	       while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);

	    es++;
	    uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
	    s->unzftab[uc] += es;

	    if (s->smallDecompress)
	       while (es > 0) {
		  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
		  s->ll16[nblock] = (UInt16)uc;
		  nblock++;
		  es--;
	       }
	    else
	       while (es > 0) {
		  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
		  s->tt[nblock] = (UInt32)uc;
		  nblock++;
		  es--;
	       };

	    continue;

	 } else {

	    if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);

	    /*-- uc = MTF ( nextSym-1 ) --*/
	    {
	       Int32 ii, jj, kk, pp, lno, off;
	       UInt32 nn;
	       nn = (UInt32)(nextSym - 1);

	       if (nn < MTFL_SIZE) {
		  /* avoid general-case expense */
		  pp = s->mtfbase[0];
		  uc = s->mtfa[pp+nn];
		  while (nn > 3) {
		     Int32 z = pp+nn;
		     s->mtfa[(z)  ] = s->mtfa[(z)-1];
		     s->mtfa[(z)-1] = s->mtfa[(z)-2];
		     s->mtfa[(z)-2] = s->mtfa[(z)-3];
		     s->mtfa[(z)-3] = s->mtfa[(z)-4];
		     nn -= 4;
		  }
		  while (nn > 0) {
		     s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
		  };
		  s->mtfa[pp] = uc;
	       } else {
		  /* general case */
		  lno = nn / MTFL_SIZE;
		  off = nn % MTFL_SIZE;
		  pp = s->mtfbase[lno] + off;
		  uc = s->mtfa[pp];
		  while (pp > s->mtfbase[lno]) {
		     s->mtfa[pp] = s->mtfa[pp-1]; pp--;
		  };
		  s->mtfbase[lno]++;
		  while (lno > 0) {
		     s->mtfbase[lno]--;
		     s->mtfa[s->mtfbase[lno]]
			= s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
		     lno--;
		  }
		  s->mtfbase[0]--;
		  s->mtfa[s->mtfbase[0]] = uc;
		  if (s->mtfbase[0] == 0) {
		     kk = MTFA_SIZE-1;
		     for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
			WATCHDOG_RESET();
#endif
			for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
			   s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
			   kk--;
			}
			s->mtfbase[ii] = kk + 1;
		     }
		  }
	       }
	    }
	    /*-- end uc = MTF ( nextSym-1 ) --*/

	    s->unzftab[s->seqToUnseq[uc]]++;
	    if (s->smallDecompress)
	       s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
	       s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
	    nblock++;

	    GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
	    continue;
	 }
      }

      /* Now we know what nblock is, we can do a better sanity
	 check on s->origPtr.
      */
      if (s->origPtr < 0 || s->origPtr >= nblock)
	 RETURN(BZ_DATA_ERROR);

      s->state_out_len = 0;
      s->state_out_ch  = 0;
      BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
      s->state = BZ_X_OUTPUT;
      if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );

      /*-- Set up cftab to facilitate generation of T^(-1) --*/
      s->cftab[0] = 0;
      for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
      for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];

      if (s->smallDecompress) {

	 /*-- Make a copy of cftab, used in generation of T --*/
	 for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];

	 /*-- compute the T vector --*/
	 for (i = 0; i < nblock; i++) {
	    uc = (UChar)(s->ll16[i]);
	    SET_LL(i, s->cftabCopy[uc]);
	    s->cftabCopy[uc]++;
	 }

	 /*-- Compute T^(-1) by pointer reversal on T --*/
	 i = s->origPtr;
	 j = GET_LL(i);
	 do {
	    Int32 tmp = GET_LL(j);
	    SET_LL(j, i);
	    i = j;
	    j = tmp;
	 }
	    while (i != s->origPtr);

#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
	WATCHDOG_RESET();
#endif
	 s->tPos = s->origPtr;
	 s->nblock_used = 0;
	 if (s->blockRandomised) {
	    BZ_RAND_INIT_MASK;
	    BZ_GET_SMALL(s->k0); s->nblock_used++;
	    BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
	 } else {
	    BZ_GET_SMALL(s->k0); s->nblock_used++;
	 }

      } else {

#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
	WATCHDOG_RESET();
#endif
	 /*-- compute the T^(-1) vector --*/
	 for (i = 0; i < nblock; i++) {
	    uc = (UChar)(s->tt[i] & 0xff);
	    s->tt[s->cftab[uc]] |= (i << 8);
	    s->cftab[uc]++;
	 }

	 s->tPos = s->tt[s->origPtr] >> 8;
	 s->nblock_used = 0;
	 if (s->blockRandomised) {
	    BZ_RAND_INIT_MASK;
	    BZ_GET_FAST(s->k0); s->nblock_used++;
	    BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
	 } else {
	    BZ_GET_FAST(s->k0); s->nblock_used++;
	 }

      }

      RETURN(BZ_OK);


    endhdr_2:

      GET_UCHAR(BZ_X_ENDHDR_2, uc);
      if (uc != 0x72) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_3, uc);
      if (uc != 0x45) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_4, uc);
      if (uc != 0x38) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_5, uc);
      if (uc != 0x50) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_6, uc);
      if (uc != 0x90) RETURN(BZ_DATA_ERROR);

      s->storedCombinedCRC = 0;
      GET_UCHAR(BZ_X_CCRC_1, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_CCRC_2, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_CCRC_3, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_CCRC_4, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);

      s->state = BZ_X_IDLE;
      RETURN(BZ_STREAM_END);

      default: AssertH ( False, 4001 );
   }

   AssertH ( False, 4002 );

   save_state_and_return:

   s->save_i           = i;
   s->save_j           = j;
   s->save_t           = t;
   s->save_alphaSize   = alphaSize;
   s->save_nGroups     = nGroups;
   s->save_nSelectors  = nSelectors;
   s->save_EOB         = EOB;
   s->save_groupNo     = groupNo;
   s->save_groupPos    = groupPos;
   s->save_nextSym     = nextSym;
   s->save_nblockMAX   = nblockMAX;
   s->save_nblock      = nblock;
   s->save_es          = es;
   s->save_N           = N;
   s->save_curr        = curr;
   s->save_zt          = zt;
   s->save_zn          = zn;
   s->save_zvec        = zvec;
   s->save_zj          = zj;
   s->save_gSel        = gSel;
   s->save_gMinlen     = gMinlen;
   s->save_gLimit      = gLimit;
   s->save_gBase       = gBase;
   s->save_gPerm       = gPerm;

   return retVal;
}


/*-------------------------------------------------------------*/
/*--- end                                      decompress.c ---*/
/*-------------------------------------------------------------*/

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