]> git.ipfire.org Git - people/ms/u-boot.git/blob - lib_generic/bzlib_decompress.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of git+ssh://10.10.0.7/home/wd/git/u-boot/master
[people/ms/u-boot.git] / lib_generic / bzlib_decompress.c
1 #include <config.h>
2 #include <common.h>
3 #include <watchdog.h>
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 jseward@acm.org
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]) {
77 s->seqToUnseq[s->nInUse] = i;
78 s->nInUse++;
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) { \
91 UInt32 v; \
92 v = (s->bsBuff >> \
93 (s->bsLive-nnn)) & ((1 << nnn)-1); \
94 s->bsLive -= nnn; \
95 vvv = v; \
96 break; \
97 } \
98 if (s->strm->avail_in == 0) RETURN(BZ_OK); \
99 s->bsBuff \
100 = (s->bsBuff << 8) | \
101 ((UInt32) \
102 (*((UChar*)(s->strm->next_in)))); \
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) \
108 s->strm->total_in_hi32++; \
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) \
123 RETURN(BZ_DATA_ERROR); \
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 */) \
136 RETURN(BZ_DATA_ERROR); \
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) ||
252 s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
253 s->blockSize100k -= BZ_HDR_0;
254
255 if (s->smallDecompress) {
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);
261 } else {
262 s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
263 if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
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)
283 VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo );
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)
306 RETURN(BZ_DATA_ERROR);
307 if (s->origPtr > 10 + 100000*s->blockSize100k)
308 RETURN(BZ_DATA_ERROR);
309
310 /*--- Receive the mapping table ---*/
311 for (i = 0; i < 16; i++) {
312 GET_BIT(BZ_X_MAPPING_1, uc);
313 if (uc == 1)
314 s->inUse16[i] = True; else
315 s->inUse16[i] = False;
316 }
317
318 for (i = 0; i < 256; i++) s->inUse[i] = False;
319
320 for (i = 0; i < 16; i++)
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 }
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++) {
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;
344 }
345
346 /*--- Undo the MTF values for the selectors. ---*/
347 {
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 }
358 }
359
360 /*--- Now the coding tables ---*/
361 for (t = 0; t < nGroups; t++) {
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 }
373 }
374
375 /*--- Create the Huffman decoding tables ---*/
376 for (t = 0; t < nGroups; t++) {
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;
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 {
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 }
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
421 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
422 WATCHDOG_RESET();
423 #endif
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--) {
506 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
507 WATCHDOG_RESET();
508 #endif
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 }
529 }
530
531 /* Now we know what nblock is, we can do a better sanity
532 check on s->origPtr.
533 */
534 if (s->origPtr < 0 || s->origPtr >= nblock)
535 RETURN(BZ_DATA_ERROR);
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
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
571 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
572 WATCHDOG_RESET();
573 #endif
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 }
583
584 } else {
585
586 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
587 WATCHDOG_RESET();
588 #endif
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 }
605
606 }
607
608 RETURN(BZ_OK);
609
610
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 */
"Das U-Boot" Source Tree