Subversion Repositories nw_plus

Rev

Blame | Last modification | View Log | RSS feed

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