← Back to branch summary

~ubuntu-branches/ubuntu/maverick/u-boot-omap3/maverick

« back to all changes in this revision

Viewing changes to lib_generic/bzlib_decompress.c

  • Committer: Bazaar Package Importer
  • Author(s): Oliver Grawert
  • Date: 2010-03-22 15:06:23 UTC
  • Revision ID: james.westby@ubuntu.com-20100322150623-i21g8rgiyl5dohag
Tags: upstream-2010.3git20100315
Import upstream version 2010.3git20100315

Show diffs side-by-side

added added

removed removed

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