1 /* Modified for busybox by Glenn McGrath <bug1@optushome.com.au> */
2 /* Added support output to stdout by Thomas Lundquist <thomasez@zelow.no> */
4 This file is a part of bzip2 and/or libbzip2, a program and
5 library for lossless, block-sorting data compression.
7 Copyright (C) 1996-2000 Julian R Seward. All rights reserved.
9 Redistribution and use in source and binary forms, with or without
10 modification, are permitted provided that the following conditions
13 1. Redistributions of source code must retain the above copyright
14 notice, this list of conditions and the following disclaimer.
16 2. The origin of this software must not be misrepresented; you must
17 not claim that you wrote the original software. If you use this
18 software in a product, an acknowledgment in the product
19 documentation would be appreciated but is not required.
21 3. Altered source versions must be plainly marked as such, and must
22 not be misrepresented as being the original software.
24 4. The name of the author may not be used to endorse or promote
25 products derived from this software without specific prior written
28 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
29 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
30 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
32 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
34 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
36 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
37 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
38 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 Julian Seward, Cambridge, UK.
42 bzip2/libbzip2 version 1.0 of 21 March 2000
44 This program is based on (at least) the work of:
54 For more information on these sources, see the manual.
67 #define MTFA_SIZE 4096
71 #define BZ_MAX_ALPHA_SIZE 258
76 #define BZ_FINISH_OK 3
77 #define BZ_STREAM_END 4
78 #define BZ_SEQUENCE_ERROR (-1)
79 #define BZ_PARAM_ERROR (-2)
80 #define BZ_MEM_ERROR (-3)
81 #define BZ_DATA_ERROR (-4)
82 #define BZ_DATA_ERROR_MAGIC (-5)
83 #define BZ_IO_ERROR (-6)
84 #define BZ_UNEXPECTED_EOF (-7)
85 #define BZ_OUTBUFF_FULL (-8)
86 #define BZ_CONFIG_ERROR (-9)
91 #define BZ_MAX_UNUSED 5000
92 #define FILE_NAME_LEN 1034
93 /*-- states for decompression. --*/
98 #define BZ_X_MAGIC_1 10
99 #define BZ_X_MAGIC_2 11
100 #define BZ_X_MAGIC_3 12
101 #define BZ_X_MAGIC_4 13
102 #define BZ_X_BLKHDR_1 14
103 #define BZ_X_BLKHDR_2 15
104 #define BZ_X_BLKHDR_3 16
105 #define BZ_X_BLKHDR_4 17
106 #define BZ_X_BLKHDR_5 18
107 #define BZ_X_BLKHDR_6 19
108 #define BZ_X_BCRC_1 20
109 #define BZ_X_BCRC_2 21
110 #define BZ_X_BCRC_3 22
111 #define BZ_X_BCRC_4 23
112 #define BZ_X_RANDBIT 24
113 #define BZ_X_ORIGPTR_1 25
114 #define BZ_X_ORIGPTR_2 26
115 #define BZ_X_ORIGPTR_3 27
116 #define BZ_X_MAPPING_1 28
117 #define BZ_X_MAPPING_2 29
118 #define BZ_X_SELECTOR_1 30
119 #define BZ_X_SELECTOR_2 31
120 #define BZ_X_SELECTOR_3 32
121 #define BZ_X_CODING_1 33
122 #define BZ_X_CODING_2 34
123 #define BZ_X_CODING_3 35
124 #define BZ_X_MTF_1 36
125 #define BZ_X_MTF_2 37
126 #define BZ_X_MTF_3 38
127 #define BZ_X_MTF_4 39
128 #define BZ_X_MTF_5 40
129 #define BZ_X_MTF_6 41
130 #define BZ_X_ENDHDR_2 42
131 #define BZ_X_ENDHDR_3 43
132 #define BZ_X_ENDHDR_4 44
133 #define BZ_X_ENDHDR_5 45
134 #define BZ_X_ENDHDR_6 46
135 #define BZ_X_CCRC_1 47
136 #define BZ_X_CCRC_2 48
137 #define BZ_X_CCRC_3 49
138 #define BZ_X_CCRC_4 50
140 #define BZ_MAX_CODE_LEN 23
141 #define BZ_VERSION "1.0.1, 23-June-2000"
147 unsigned int avail_in;
148 unsigned int total_in_lo32;
149 unsigned int total_in_hi32;
152 unsigned int avail_out;
153 unsigned int total_out_lo32;
154 unsigned int total_out_hi32;
158 void *(*bzalloc)(void *,int,int);
159 void (*bzfree)(void *,void *);
166 unsigned char initialisedOk;
167 unsigned char writing;
168 char buf[BZ_MAX_UNUSED];
173 /*-- Structure holding all the decompression-side stuff. --*/
175 /* pointer back to the struct bz_stream */
178 /* state indicator for this stream */
181 /* for doing the final run-length decoding */
182 unsigned char state_out_ch;
184 unsigned char blockRandomised;
188 /* the buffer for bit stream reading */
192 /* misc administratium */
194 unsigned char smallDecompress;
198 /* for undoing the Burrows-Wheeler transform */
207 /* for undoing the Burrows-Wheeler transform (FAST) */
210 /* for undoing the Burrows-Wheeler transform (SMALL) */
211 unsigned short *ll16;
214 /* stored and calculated CRCs */
215 unsigned int storedBlockCRC;
216 unsigned int storedCombinedCRC;
217 unsigned int calculatedBlockCRC;
218 unsigned int calculatedCombinedCRC;
220 /* map of bytes used in block */
222 unsigned char inUse[256];
223 unsigned char inUse16[16];
224 unsigned char seqToUnseq[256];
226 /* for decoding the MTF values */
227 unsigned char mtfa [MTFA_SIZE];
228 unsigned char selector [2 + (900000 / BZ_G_SIZE)];
229 unsigned char selectorMtf[2 + (900000 / BZ_G_SIZE)];
230 unsigned char len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
231 int mtfbase[256 / MTFL_SIZE];
233 int limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
234 int base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
235 int perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
236 int minLens[BZ_N_GROUPS];
238 /* save area for scalars in the main decompress code */
266 //int verbosity_level;
267 unsigned char smallMode;
270 char inName[FILE_NAME_LEN];
271 char outName[FILE_NAME_LEN];
274 unsigned char deleteOutputOnInterrupt;
275 FILE *outputHandleJustInCase;
277 int numFilesProcessed;
280 const unsigned int BZ2_crc32Table[256] = {
282 /*-- Ugly, innit? --*/
284 0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
285 0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
286 0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
287 0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
288 0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
289 0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
290 0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
291 0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
292 0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
293 0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
294 0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
295 0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
296 0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
297 0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
298 0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
299 0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
300 0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
301 0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
302 0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
303 0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
304 0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
305 0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
306 0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
307 0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
308 0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
309 0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
310 0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
311 0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
312 0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
313 0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
314 0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
315 0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
316 0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
317 0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
318 0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
319 0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
320 0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
321 0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
322 0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
323 0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
324 0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
325 0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
326 0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
327 0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
328 0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
329 0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
330 0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
331 0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
332 0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
333 0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
334 0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
335 0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
336 0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
337 0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
338 0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
339 0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
340 0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
341 0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
342 0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
343 0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
344 0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
345 0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
346 0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
347 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
350 void bz_rand_udp_mask(DState *s)
352 if (s->rNToGo == 0) {
353 s->rNToGo = BZ2_rNums[s->rTPos];
355 if (s->rTPos == 512) {
362 static unsigned char myfeof(FILE *f)
372 static void cleanUpAndFail(int ec)
376 if ((srcMode == SM_F2F) && (opMode != OM_TEST) && deleteOutputOnInterrupt) {
378 error_msg("%s: Deleting output file %s, if it exists.\n", progName, outName);
380 if (outputHandleJustInCase != NULL) {
381 fclose(outputHandleJustInCase);
383 retVal = remove(outName);
385 error_msg("%s: WARNING: deletion of output file (apparently) failed.\n", progName);
388 if (noisy && (numFileNames > 0) && (numFilesProcessed < numFileNames)) {
389 error_msg("%s: WARNING: some files have not been processed:\n"
390 "\t%d specified on command line, %d not processed yet.\n\n",
391 progName, numFileNames, numFileNames - numFilesProcessed );
400 error_msg("\n%s: PANIC -- internal consistency error:\n"
402 "\tThis is a BUG. Please report it to me at:\n"
403 "\tjseward@acm.org\n",
408 void BZ2_hbCreateDecodeTables(int *limit, int *base, int *perm, unsigned char *length, int minLen, int maxLen, int alphaSize )
413 for (i = minLen; i <= maxLen; i++) {
414 for (j = 0; j < alphaSize; j++) {
415 if (length[j] == i) {
422 for (i = 0; i < BZ_MAX_CODE_LEN; i++) {
426 for (i = 0; i < alphaSize; i++) {
430 for (i = 1; i < BZ_MAX_CODE_LEN; i++) {
431 base[i] += base[i-1];
434 for (i = 0; i < BZ_MAX_CODE_LEN; i++) {
439 for (i = minLen; i <= maxLen; i++) {
440 vec += (base[i+1] - base[i]);
444 for (i = minLen + 1; i <= maxLen; i++) {
445 base[i] = ((limit[i-1] + 1) << 1) - base[i];
449 int bz_get_small(DState *s)
456 mid = (nb + na) >> 1;
457 if (s->tPos >= s->cftab[mid]) {
463 while (na - nb != 1);
465 s->tPos = (((unsigned int)s->ll16[s->tPos]) |
466 (((((unsigned int)(s->ll4[(s->tPos) >> 1])) >>
467 (((s->tPos) << 2) & 0x4)) & 0xF) << 16));
471 void assert_h(int errcode)
473 error_msg_and_die("\n\nbzip2/libbzip2: internal error number %d.\n"
474 "This is a bug in bzip2/libbzip2, %s.\n"
475 "Please report it to me at: jseward@acm.org. If this happened\n"
476 "when you were using some program which uses libbzip2 as a\n"
477 "component, you should also report this bug to the author(s)\n"
478 "of that program. Please make an effort to report this bug;\n"
479 "timely and accurate bug reports eventually lead to higher\n"
480 "quality software. Thanks. Julian Seward, 21 March 2000.\n\n",
481 errcode, BZ_VERSION);
484 static int get_bits(DState *s, int *vvv, char nnn)
487 if (s->bsLive >= nnn) {
488 *vvv = (s->bsBuff >> (s->bsLive-nnn)) & ((1 << nnn)-1);
492 if (s->strm->avail_in == 0) {
495 s->bsBuff = (s->bsBuff << 8) | ((unsigned int) (*((unsigned char*)(s->strm->next_in))));
499 s->strm->total_in_lo32++;
500 if (s->strm->total_in_lo32 == 0) {
501 s->strm->total_in_hi32++;
507 int bz_get_fast(DState *s)
510 s->tPos = s->tt[s->tPos];
511 cccc = (unsigned char)(s->tPos & 0xff);
516 /*---------------------------------------------------*/
517 int BZ2_decompress(DState *s)
522 bz_stream *strm = s->strm;
524 /* stuff that needs to be saved/restored */
551 int get_mtf_val_init(void)
555 if (groupNo >= nSelectors) {
556 retVal = BZ_DATA_ERROR;
559 groupPos = BZ_G_SIZE;
560 gSel = s->selector[groupNo];
561 gMinlen = s->minLens[gSel];
562 gLimit = &(s->limit[gSel][0]);
563 gPerm = &(s->perm[gSel][0]);
564 gBase = &(s->base[gSel][0]);
571 if (s->state == BZ_X_MAGIC_1) {
572 /*initialise the save area*/
576 s->save_alphaSize = 0;
578 s->save_nSelectors = 0;
581 s->save_groupPos = 0;
583 s->save_nblockMAX = 0;
594 s->save_gLimit = NULL;
595 s->save_gBase = NULL;
596 s->save_gPerm = NULL;
599 /*restore from the save area*/
603 alphaSize = s->save_alphaSize;
604 nGroups = s->save_nGroups;
605 nSelectors = s->save_nSelectors;
607 groupNo = s->save_groupNo;
608 groupPos = s->save_groupPos;
609 nextSym = s->save_nextSym;
610 nblockMAX = s->save_nblockMAX;
611 nblock = s->save_nblock;
620 gMinlen = s->save_gMinlen;
621 gLimit = s->save_gLimit;
622 gBase = s->save_gBase;
623 gPerm = s->save_gPerm;
626 switch_val = s->state;
627 switch (switch_val) {
629 s->state = BZ_X_MAGIC_1;
630 if (! get_bits(s, &uc, 8)) {
632 goto save_state_and_return;
635 retVal = BZ_DATA_ERROR_MAGIC;
636 goto save_state_and_return;
640 s->state = BZ_X_MAGIC_2;
641 if (! get_bits(s, &uc, 8)) {
643 goto save_state_and_return;
646 retVal = BZ_DATA_ERROR_MAGIC;
647 goto save_state_and_return;
651 s->state = BZ_X_MAGIC_3;
652 if (! get_bits(s, &uc, 8)) {
654 goto save_state_and_return;
657 retVal = BZ_DATA_ERROR_MAGIC;
658 goto save_state_and_return;
662 s->state = BZ_X_MAGIC_4;
663 if (! get_bits(s, &s->blockSize100k, 8)) {
665 goto save_state_and_return;
667 if ((s->blockSize100k < '1') || (s->blockSize100k > '9')) {
668 retVal = BZ_DATA_ERROR_MAGIC;
669 goto save_state_and_return;
671 s->blockSize100k -= '0';
673 if (s->smallDecompress) {
674 s->ll16 = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(unsigned short), 1);
675 s->ll4 = (strm->bzalloc)(strm->opaque, ((1 + s->blockSize100k * 100000) >> 1) * sizeof(unsigned char), 1);
677 if (s->ll16 == NULL || s->ll4 == NULL) {
678 retVal = BZ_MEM_ERROR;
679 goto save_state_and_return;
682 s->tt = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(int), 1);
684 retVal = BZ_MEM_ERROR;
685 goto save_state_and_return;
690 s->state = BZ_X_BLKHDR_1;
691 if (! get_bits(s, &uc, 8)) {
693 goto save_state_and_return;
700 retVal = BZ_DATA_ERROR;
701 goto save_state_and_return;
705 s->state = BZ_X_BLKHDR_2;
706 if (! get_bits(s, &uc, 8)) {
708 goto save_state_and_return;
711 retVal = BZ_DATA_ERROR;
712 goto save_state_and_return;
716 s->state = BZ_X_BLKHDR_3;
717 if (! get_bits(s, &uc, 8)) {
719 goto save_state_and_return;
722 retVal = BZ_DATA_ERROR;
723 goto save_state_and_return;
727 s->state = BZ_X_BLKHDR_4;
728 if (! get_bits(s, &uc, 8)) {
730 goto save_state_and_return;
733 retVal = BZ_DATA_ERROR;
734 goto save_state_and_return;
738 s->state = BZ_X_BLKHDR_5;
739 if (! get_bits(s, &uc, 8)) {
741 goto save_state_and_return;
744 retVal = BZ_DATA_ERROR;
745 goto save_state_and_return;
749 s->state = BZ_X_BLKHDR_6;
750 if (! get_bits(s, &uc, 8)) {
752 goto save_state_and_return;
755 retVal = BZ_DATA_ERROR;
756 goto save_state_and_return;
760 if (s->verbosity >= 2) {
761 error_msg("\n [%d: huff+mtf ", s->currBlockNo);
763 s->storedBlockCRC = 0;
766 s->state = BZ_X_BCRC_1;
767 if (! get_bits(s, &uc, 8)) {
769 goto save_state_and_return;
771 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
774 s->state = BZ_X_BCRC_2;
775 if (! get_bits(s, &uc, 8)) {
777 goto save_state_and_return;
779 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
782 s->state = BZ_X_BCRC_3;
783 if (! get_bits(s, &uc, 8)) {
785 goto save_state_and_return;
787 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
790 s->state = BZ_X_BCRC_4;
791 if (! get_bits(s, &uc, 8)) {
793 goto save_state_and_return;
795 s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
798 s->state = BZ_X_RANDBIT;
800 int tmp = s->blockRandomised;
801 const int ret = get_bits(s, &tmp, 1);
802 s->blockRandomised = tmp;
805 goto save_state_and_return;
812 s->state = BZ_X_ORIGPTR_1;
813 if (! get_bits(s, &uc, 8)) {
815 goto save_state_and_return;
817 s->origPtr = (s->origPtr << 8) | ((int)uc);
820 s->state = BZ_X_ORIGPTR_2;
821 if (! get_bits(s, &uc, 8)) {
823 goto save_state_and_return;
825 s->origPtr = (s->origPtr << 8) | ((int)uc);
828 s->state = BZ_X_ORIGPTR_3;
829 if (! get_bits(s, &uc, 8)) {
831 goto save_state_and_return;
833 s->origPtr = (s->origPtr << 8) | ((int)uc);
835 if (s->origPtr < 0) {
836 retVal = BZ_DATA_ERROR;
837 goto save_state_and_return;
839 if (s->origPtr > 10 + 100000*s->blockSize100k) {
840 retVal = BZ_DATA_ERROR;
841 goto save_state_and_return;
844 /*--- Receive the mapping table ---*/
846 for (i = 0; i < 16; i++) {
847 s->state = BZ_X_MAPPING_1;
848 if (! get_bits(s, &uc, 1)) {
850 goto save_state_and_return;
853 s->inUse16[i] = TRUE;
855 s->inUse16[i] = FALSE;
859 for (i = 0; i < 256; i++) {
863 for (i = 0; i < 16; i++) {
865 for (j = 0; j < 16; j++) {
867 s->state = BZ_X_MAPPING_2;
868 if (! get_bits(s, &uc, 1)) {
870 goto save_state_and_return;
873 s->inUse[i * 16 + j] = TRUE;
880 for (i = 0; i < 256; i++) {
882 s->seqToUnseq[s->nInUse] = i;
886 if (s->nInUse == 0) {
887 retVal = BZ_DATA_ERROR;
888 goto save_state_and_return;
890 alphaSize = s->nInUse+2;
892 /*--- Now the selectors ---*/
893 case BZ_X_SELECTOR_1:
894 s->state = BZ_X_SELECTOR_1;
895 if (! get_bits(s, &nGroups, 3)) {
897 goto save_state_and_return;
899 if (nGroups < 2 || nGroups > 6) {
900 retVal = BZ_DATA_ERROR;
901 goto save_state_and_return;
904 case BZ_X_SELECTOR_2:
905 s->state = BZ_X_SELECTOR_2;
906 if (! get_bits(s, &nSelectors, 15)) {
908 goto save_state_and_return;
910 if (nSelectors < 1) {
911 retVal = BZ_DATA_ERROR;
912 goto save_state_and_return;
917 for (i = 0; i < nSelectors; i++) {
920 case BZ_X_SELECTOR_3:
921 s->state = BZ_X_SELECTOR_3;
922 if (! get_bits(s, &uc, 1)) {
924 goto save_state_and_return;
931 retVal = BZ_DATA_ERROR;
932 goto save_state_and_return;
935 s->selectorMtf[i] = j;
938 /*--- Undo the MTF values for the selectors. ---*/
940 unsigned char pos[BZ_N_GROUPS], tmp, v;
941 for (v = 0; v < nGroups; v++) {
944 for (i = 0; i < nSelectors; i++) {
945 v = s->selectorMtf[i];
952 s->selector[i] = tmp;
956 /*--- Now the coding tables ---*/
957 for (t = 0; t < nGroups; t++) {
959 s->state = BZ_X_CODING_1;
960 if (! get_bits(s, &curr, 5)) {
962 goto save_state_and_return;
964 for (i = 0; i < alphaSize; i++) {
966 if (curr < 1 || curr > 20) {
967 retVal = BZ_DATA_ERROR;
968 goto save_state_and_return;
972 s->state = BZ_X_CODING_2;
973 if (! get_bits(s, &uc, 1)) {
975 goto save_state_and_return;
982 s->state = BZ_X_CODING_3;
983 if (! get_bits(s, &uc, 1)) {
985 goto save_state_and_return;
997 /*--- Create the Huffman decoding tables ---*/
998 for (t = 0; t < nGroups; t++) {
1001 for (i = 0; i < alphaSize; i++) {
1002 if (s->len[t][i] > maxLen) {
1003 maxLen = s->len[t][i];
1005 if (s->len[t][i] < minLen) {
1006 minLen = s->len[t][i];
1010 BZ2_hbCreateDecodeTables (
1015 minLen, maxLen, alphaSize
1019 s->minLens[t] = minLen;
1022 /*--- Now the MTF values ---*/
1025 nblockMAX = 100000 * s->blockSize100k;
1029 for (i = 0; i <= 255; i++) {
1036 for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
1037 for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
1038 s->mtfa[kk] = (unsigned char)(ii * MTFL_SIZE + jj);
1041 s->mtfbase[ii] = kk + 1;
1044 /*-- end MTF init --*/
1048 if (! get_mtf_val_init()) {
1049 goto save_state_and_return;
1052 s->state = BZ_X_MTF_1;
1053 if (! get_bits(s, &zvec, zn)) {
1055 goto save_state_and_return;
1058 if (zn > 20 /* the longest code */) {
1059 retVal = BZ_DATA_ERROR;
1060 goto save_state_and_return;
1062 if (zvec <= gLimit[zn]) {
1068 s->state = BZ_X_MTF_2;
1069 if (! get_bits(s, &zj, 1)) {
1071 goto save_state_and_return;
1073 zvec = (zvec << 1) | zj;
1075 if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
1076 retVal = BZ_DATA_ERROR;
1077 goto save_state_and_return;
1079 nextSym = gPerm[zvec - gBase[zn]];
1082 if (nextSym == EOB) {
1086 if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
1090 if (nextSym == BZ_RUNA) {
1091 es = es + (0+1) * N;
1093 if (nextSym == BZ_RUNB) {
1094 es = es + (1+1) * N;
1098 if (! get_mtf_val_init()) {
1099 goto save_state_and_return;
1102 s->state = BZ_X_MTF_3;
1103 if (! get_bits(s, &zvec, zn)) {
1105 goto save_state_and_return;
1108 if (zn > 20 /* the longest code */) {
1109 retVal = BZ_DATA_ERROR;
1110 goto save_state_and_return;
1112 if (zvec <= gLimit[zn]) {
1118 s->state = BZ_X_MTF_4;
1119 if (! get_bits(s, &zj, 1)) {
1121 goto save_state_and_return;
1123 zvec = (zvec << 1) | zj;
1125 if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
1126 retVal = BZ_DATA_ERROR;
1127 goto save_state_and_return;
1130 nextSym = gPerm[zvec - gBase[zn]];
1132 while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
1135 uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
1136 s->unzftab[uc] += es;
1138 if (s->smallDecompress) {
1140 if (nblock >= nblockMAX) {
1141 retVal = BZ_DATA_ERROR;
1142 goto save_state_and_return;
1144 s->ll16[nblock] = (unsigned short)uc;
1150 if (nblock >= nblockMAX) {
1151 retVal = BZ_DATA_ERROR;
1152 goto save_state_and_return;
1154 s->tt[nblock] = (unsigned int)uc;
1161 if (nblock >= nblockMAX) {
1162 retVal = BZ_DATA_ERROR;
1163 goto save_state_and_return;
1165 /*-- uc = MTF ( nextSym-1 ) --*/
1167 int ii, jj, kk, pp, lno, off;
1169 nn = (unsigned int)(nextSym - 1);
1171 if (nn < MTFL_SIZE) {
1172 /* avoid general-case expense */
1174 uc = s->mtfa[pp+nn];
1177 s->mtfa[(z) ] = s->mtfa[(z)-1];
1178 s->mtfa[(z)-1] = s->mtfa[(z)-2];
1179 s->mtfa[(z)-2] = s->mtfa[(z)-3];
1180 s->mtfa[(z)-3] = s->mtfa[(z)-4];
1184 s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
1189 lno = nn / MTFL_SIZE;
1190 off = nn % MTFL_SIZE;
1191 pp = s->mtfbase[lno] + off;
1193 while (pp > s->mtfbase[lno]) {
1194 s->mtfa[pp] = s->mtfa[pp-1];
1200 s->mtfa[s->mtfbase[lno]] = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
1204 s->mtfa[s->mtfbase[0]] = uc;
1205 if (s->mtfbase[0] == 0) {
1207 for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
1208 for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
1209 s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
1212 s->mtfbase[ii] = kk + 1;
1217 /*-- end uc = MTF ( nextSym-1 ) --*/
1219 s->unzftab[s->seqToUnseq[uc]]++;
1220 if (s->smallDecompress) {
1221 s->ll16[nblock] = (unsigned short)(s->seqToUnseq[uc]);
1223 s->tt[nblock] = (unsigned int)(s->seqToUnseq[uc]);
1227 if (! get_mtf_val_init()) {
1228 goto save_state_and_return;
1231 s->state = BZ_X_MTF_5;
1232 if (! get_bits(s, &zvec, zn)) {
1234 goto save_state_and_return;
1237 if (zn > 20 /* the longest code */) {
1238 retVal = BZ_DATA_ERROR;
1239 goto save_state_and_return;
1241 if (zvec <= gLimit[zn]) {
1247 s->state = BZ_X_MTF_6;
1248 if (! get_bits(s, &zj, 1)) {
1250 goto save_state_and_return;
1252 zvec = (zvec << 1) | zj;
1254 if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
1255 retVal = BZ_DATA_ERROR;
1256 goto save_state_and_return;
1258 nextSym = gPerm[zvec - gBase[zn]];
1263 /* Now we know what nblock is, we can do a better sanity
1264 check on s->origPtr.
1266 if (s->origPtr < 0 || s->origPtr >= nblock) {
1267 retVal = BZ_DATA_ERROR;
1268 goto save_state_and_return;
1270 s->state_out_len = 0;
1271 s->state_out_ch = 0;
1272 s->calculatedBlockCRC = 0xffffffffL;
1273 s->state = BZ_X_OUTPUT;
1274 if (s->verbosity >= 2) {
1275 error_msg("rt+rld");
1278 /*-- Set up cftab to facilitate generation of T^(-1) --*/
1280 for (i = 1; i <= 256; i++) {
1281 s->cftab[i] = s->unzftab[i-1];
1283 for (i = 1; i <= 256; i++) {
1284 s->cftab[i] += s->cftab[i-1];
1287 if (s->smallDecompress) {
1289 /*-- Make a copy of cftab, used in generation of T --*/
1290 for (i = 0; i <= 256; i++) {
1291 s->cftabCopy[i] = s->cftab[i];
1294 /*-- compute the T vector --*/
1295 for (i = 0; i < nblock; i++) {
1296 uc = (unsigned char)(s->ll16[i]);
1297 s->ll16[i] = (unsigned short)(s->cftabCopy[uc] & 0x0000ffff);
1298 if (((i) & 0x1) == 0) {
1299 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (s->cftabCopy[uc] >> 16);
1301 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((s->cftabCopy[uc] >> 16) << 4);
1306 /*-- Compute T^(-1) by pointer reversal on T --*/
1308 j = (((unsigned int)s->ll16[i]) |
1309 (((((unsigned int)(s->ll4[(i) >> 1])) >>
1310 (((i) << 2) & 0x4)) & 0xF) << 16));
1313 const int tmp = (((unsigned int)s->ll16[j]) |
1314 (((((unsigned int)(s->ll4[(j) >> 1])) >>
1315 (((j) << 2) & 0x4)) & 0xF) << 16));
1317 s->ll16[j] = (unsigned short)(i & 0x0000ffff);
1318 if (((j) & 0x1) == 0) {
1319 s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0xf0) | (i >> 16);
1321 s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0x0f) | ((i >> 16) << 4);
1326 while (i != s->origPtr);
1327 s->tPos = s->origPtr;
1329 if (s->blockRandomised) {
1332 s->k0 = bz_get_small(s);
1334 bz_rand_udp_mask(s);
1335 s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1337 s->k0 = bz_get_small(s);
1341 /*-- compute the T^(-1) vector --*/
1342 for (i = 0; i < nblock; i++) {
1343 uc = (unsigned char)(s->tt[i] & 0xff);
1344 s->tt[s->cftab[uc]] |= (i << 8);
1348 s->tPos = s->tt[s->origPtr] >> 8;
1350 if (s->blockRandomised) {
1353 s->k0 = bz_get_fast(s);
1356 bz_rand_udp_mask(s);
1357 s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1359 s->k0 = bz_get_fast(s);
1365 goto save_state_and_return;
1369 s->state = BZ_X_ENDHDR_2;
1370 if (! get_bits(s, &uc, 8)) {
1372 goto save_state_and_return;
1375 retVal = BZ_DATA_ERROR;
1376 goto save_state_and_return;
1380 s->state = BZ_X_ENDHDR_3;
1381 if (! get_bits(s, &uc, 8)) {
1383 goto save_state_and_return;
1386 retVal = BZ_DATA_ERROR;
1387 goto save_state_and_return;
1391 s->state = BZ_X_ENDHDR_4;
1392 if (! get_bits(s, &uc, 8)) {
1394 goto save_state_and_return;
1397 retVal = BZ_DATA_ERROR;
1398 goto save_state_and_return;
1402 s->state = BZ_X_ENDHDR_5;
1403 if (! get_bits(s, &uc, 8)) {
1405 goto save_state_and_return;
1408 retVal = BZ_DATA_ERROR;
1409 goto save_state_and_return;
1413 s->state = BZ_X_ENDHDR_6;
1414 if (! get_bits(s, &uc, 8)) {
1416 goto save_state_and_return;
1419 retVal = BZ_DATA_ERROR;
1420 goto save_state_and_return;
1422 s->storedCombinedCRC = 0;
1425 s->state = BZ_X_CCRC_1;
1426 if (! get_bits(s, &uc, 8)) {
1428 goto save_state_and_return;
1430 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1432 s->state = BZ_X_CCRC_2;
1433 if (! get_bits(s, &uc, 8)) {
1435 goto save_state_and_return;
1437 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1440 s->state = BZ_X_CCRC_3;
1441 if (! get_bits(s, &uc, 8)) {
1443 goto save_state_and_return;
1445 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1448 s->state = BZ_X_CCRC_4;
1449 if (! get_bits(s, &uc, 8)) {
1451 goto save_state_and_return;
1453 s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
1455 s->state = BZ_X_IDLE;
1456 retVal = BZ_STREAM_END;
1457 goto save_state_and_return;
1460 printf("switch val is %d\n", switch_val);
1466 save_state_and_return:
1470 s->save_alphaSize = alphaSize;
1471 s->save_nGroups = nGroups;
1472 s->save_nSelectors = nSelectors;
1474 s->save_groupNo = groupNo;
1475 s->save_groupPos = groupPos;
1476 s->save_nextSym = nextSym;
1477 s->save_nblockMAX = nblockMAX;
1478 s->save_nblock = nblock;
1481 s->save_curr = curr;
1484 s->save_zvec = zvec;
1486 s->save_gSel = gSel;
1487 s->save_gMinlen = gMinlen;
1488 s->save_gLimit = gLimit;
1489 s->save_gBase = gBase;
1490 s->save_gPerm = gPerm;
1495 static void *default_bzalloc(void *opaque, int items, int size)
1497 void *v = xmalloc(items *size);
1501 static void default_bzfree(void *opaque, void *addr)
1508 //int BZ2_bzDecompressInit(bz_stream* strm, int verbosity_level, int small)
1509 int BZ2_bzDecompressInit(bz_stream* strm, int small)
1513 if (sizeof(int) != 4) {
1514 return BZ_CONFIG_ERROR;
1516 if (sizeof(short) != 2) {
1517 return BZ_CONFIG_ERROR;
1519 if (sizeof(char) != 1) {
1520 return BZ_CONFIG_ERROR;
1523 return BZ_PARAM_ERROR;
1525 if (small != 0 && small != 1) {
1526 return BZ_PARAM_ERROR;
1528 // if (verbosity_level < 0 || verbosity_level > 4) {
1529 // return BZ_PARAM_ERROR;
1531 if (strm->bzalloc == NULL) {
1532 strm->bzalloc = default_bzalloc;
1534 if (strm->bzfree == NULL) {
1535 strm->bzfree = default_bzfree;
1537 s = (strm->bzalloc)(strm->opaque, sizeof(DState), 1);
1539 return BZ_MEM_ERROR;
1543 s->state = BZ_X_MAGIC_1;
1546 s->calculatedCombinedCRC = 0;
1547 strm->total_in_lo32 = 0;
1548 strm->total_in_hi32 = 0;
1549 strm->total_out_lo32 = 0;
1550 strm->total_out_hi32 = 0;
1551 s->smallDecompress = (unsigned char)small;
1556 // s->verbosity = verbosity_level;
1561 void bz_seterr(int eee, int *bzerror, bzFile **bzf)
1563 if (bzerror != NULL) {
1567 (*bzf)->lastErr = eee;
1571 void BZ2_bzReadClose(int *bzerror, void *b)
1573 bzFile* bzf = (bzFile*)b;
1575 bz_seterr(BZ_OK, bzerror, &bzf);
1577 bz_seterr(BZ_OK, bzerror, &bzf);
1582 bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
1586 if (bzf->initialisedOk) {
1587 bz_stream *strm = &(bzf->strm);
1593 if ((s == NULL) || (s->strm != strm)) {
1596 if (s->tt != NULL) {
1597 (strm->bzfree)(strm->opaque,(s->tt));
1599 if (s->ll16 != NULL) {
1600 (strm->bzfree)(strm->opaque,(s->ll16));
1602 if (s->ll4 != NULL) {
1603 (strm->bzfree)(strm->opaque,(s->ll4));
1605 (strm->bzfree)(strm->opaque,(strm->state));
1612 static void unRLE_obuf_to_output_FAST(DState *s)
1616 if (s->blockRandomised) {
1618 /* try to finish existing run */
1620 if (s->strm->avail_out == 0) {
1623 if (s->state_out_len == 0) {
1626 *((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
1627 s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
1628 BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
1629 ((unsigned char)s->state_out_ch)];
1631 s->strm->next_out++;
1632 s->strm->avail_out--;
1633 s->strm->total_out_lo32++;
1634 if (s->strm->total_out_lo32 == 0) {
1635 s->strm->total_out_hi32++;
1639 /* can a new run be started? */
1640 if (s->nblock_used == s->save_nblock+1) {
1643 s->state_out_len = 1;
1644 s->state_out_ch = s->k0;
1645 k1 = bz_get_fast(s);
1646 bz_rand_udp_mask(s);
1647 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1649 if (s->nblock_used == s->save_nblock+1) {
1657 s->state_out_len = 2;
1658 k1 = bz_get_fast(s);
1659 bz_rand_udp_mask(s);
1660 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1662 if (s->nblock_used == s->save_nblock+1) {
1669 s->state_out_len = 3;
1670 k1 = bz_get_fast(s);
1671 bz_rand_udp_mask(s);
1672 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1674 if (s->nblock_used == s->save_nblock+1) {
1682 k1 = bz_get_fast(s);
1683 bz_rand_udp_mask(s);
1684 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1686 s->state_out_len = ((int)k1) + 4;
1687 s->k0 = bz_get_fast(s);
1688 bz_rand_udp_mask(s);
1689 s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1694 unsigned int c_calculatedBlockCRC = s->calculatedBlockCRC;
1695 unsigned char c_state_out_ch = s->state_out_ch;
1696 int c_state_out_len = s->state_out_len;
1697 int c_nblock_used = s->nblock_used;
1699 unsigned int *c_tt = s->tt;
1700 unsigned int c_tPos = s->tPos;
1701 char *cs_next_out = s->strm->next_out;
1702 unsigned int cs_avail_out = s->strm->avail_out;
1705 unsigned int avail_out_INIT = cs_avail_out;
1706 int s_save_nblockPP = s->save_nblock+1;
1707 unsigned int total_out_lo32_old;
1710 /* try to finish existing run */
1711 if (c_state_out_len > 0) {
1713 if (cs_avail_out == 0) {
1716 if (c_state_out_len == 1) {
1719 *((unsigned char *)(cs_next_out)) = c_state_out_ch;
1720 c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
1721 BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
1722 ((unsigned char)c_state_out_ch)];
1727 s_state_out_len_eq_one:
1729 if (cs_avail_out == 0) {
1730 c_state_out_len = 1;
1733 *((unsigned char *)(cs_next_out)) = c_state_out_ch;
1734 c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
1735 BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
1736 ((unsigned char)c_state_out_ch)];
1741 /* can a new run be started? */
1742 if (c_nblock_used == s_save_nblockPP) {
1743 c_state_out_len = 0; goto return_notr;
1745 c_state_out_ch = c_k0;
1746 c_tPos = c_tt[c_tPos];
1747 k1 = (unsigned char)(c_tPos & 0xff);
1754 goto s_state_out_len_eq_one;
1757 if (c_nblock_used == s_save_nblockPP) {
1758 goto s_state_out_len_eq_one;
1761 c_state_out_len = 2;
1762 c_tPos = c_tt[c_tPos];
1763 k1 = (unsigned char)(c_tPos & 0xff);
1767 if (c_nblock_used == s_save_nblockPP) {
1775 c_state_out_len = 3;
1776 c_tPos = c_tt[c_tPos];
1777 k1 = (unsigned char)(c_tPos & 0xff);
1781 if (c_nblock_used == s_save_nblockPP) {
1789 c_tPos = c_tt[c_tPos];
1790 k1 = (unsigned char)(c_tPos & 0xff);
1794 c_state_out_len = ((int)k1) + 4;
1796 c_tPos = c_tt[c_tPos];
1797 c_k0 = (unsigned char)(c_tPos & 0xff);
1804 total_out_lo32_old = s->strm->total_out_lo32;
1805 s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
1806 if (s->strm->total_out_lo32 < total_out_lo32_old) {
1807 s->strm->total_out_hi32++;
1811 s->calculatedBlockCRC = c_calculatedBlockCRC;
1812 s->state_out_ch = c_state_out_ch;
1813 s->state_out_len = c_state_out_len;
1814 s->nblock_used = c_nblock_used;
1818 s->strm->next_out = cs_next_out;
1819 s->strm->avail_out = cs_avail_out;
1824 static void unRLE_obuf_to_output_SMALL(DState *s)
1828 if (s->blockRandomised) {
1830 /* try to finish existing run */
1832 if (s->strm->avail_out == 0) {
1835 if (s->state_out_len == 0) {
1838 *((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
1839 s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
1840 BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
1841 ((unsigned char)s->state_out_ch)];
1843 s->strm->next_out++;
1844 s->strm->avail_out--;
1845 s->strm->total_out_lo32++;
1846 if (s->strm->total_out_lo32 == 0) {
1847 s->strm->total_out_hi32++;
1851 /* can a new run be started? */
1852 if (s->nblock_used == s->save_nblock+1) {
1856 s->state_out_len = 1;
1857 s->state_out_ch = s->k0;
1858 k1 = bz_get_small(s);
1859 bz_rand_udp_mask(s);
1860 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1862 if (s->nblock_used == s->save_nblock+1) {
1870 s->state_out_len = 2;
1871 k1 = bz_get_small(s);
1872 bz_rand_udp_mask(s);
1873 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1875 if (s->nblock_used == s->save_nblock+1) {
1883 s->state_out_len = 3;
1884 k1 = bz_get_small(s);
1885 bz_rand_udp_mask(s);
1886 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1888 if (s->nblock_used == s->save_nblock+1) {
1895 k1 = bz_get_small(s);
1896 bz_rand_udp_mask(s);
1897 k1 ^= ((s->rNToGo == 1) ? 1 : 0);
1899 s->state_out_len = ((int)k1) + 4;
1900 s->k0 = bz_get_small(s);
1901 bz_rand_udp_mask(s);
1902 s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1907 /* try to finish existing run */
1909 if (s->strm->avail_out == 0) {
1912 if (s->state_out_len == 0) {
1915 *((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
1916 s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
1917 BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
1918 ((unsigned char)s->state_out_ch)];
1920 s->strm->next_out++;
1921 s->strm->avail_out--;
1922 s->strm->total_out_lo32++;
1923 if (s->strm->total_out_lo32 == 0) {
1924 s->strm->total_out_hi32++;
1928 /* can a new run be started? */
1929 if (s->nblock_used == s->save_nblock+1) {
1933 s->state_out_len = 1;
1934 s->state_out_ch = s->k0;
1935 k1 = bz_get_small(s);
1937 if (s->nblock_used == s->save_nblock+1) {
1945 s->state_out_len = 2;
1946 k1 = bz_get_small(s);
1948 if (s->nblock_used == s->save_nblock+1) {
1956 s->state_out_len = 3;
1957 k1 = bz_get_small(s);
1959 if (s->nblock_used == s->save_nblock+1) {
1967 k1 = bz_get_small(s);
1969 s->state_out_len = ((int)k1) + 4;
1970 s->k0 = bz_get_small(s);
1976 int BZ2_bzDecompress(bz_stream *strm)
1980 return BZ_PARAM_ERROR;
1984 return BZ_PARAM_ERROR;
1986 if (s->strm != strm) {
1987 return BZ_PARAM_ERROR;
1991 if (s->state == BZ_X_IDLE) {
1992 return BZ_SEQUENCE_ERROR;
1994 if (s->state == BZ_X_OUTPUT) {
1995 if (s->smallDecompress) {
1996 unRLE_obuf_to_output_SMALL(s);
1998 unRLE_obuf_to_output_FAST(s);
2000 if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
2001 s->calculatedBlockCRC = ~(s->calculatedBlockCRC);
2002 if (s->verbosity >= 3) {
2003 error_msg("{0x%x, 0x%x}", s->storedBlockCRC, s->calculatedBlockCRC);
2005 if (s->verbosity >= 2) {
2008 if (s->calculatedBlockCRC != s->storedBlockCRC) {
2009 return BZ_DATA_ERROR;
2011 s->calculatedCombinedCRC = (s->calculatedCombinedCRC << 1) | (s->calculatedCombinedCRC >> 31);
2012 s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
2013 s->state = BZ_X_BLKHDR_1;
2018 if (s->state >= BZ_X_MAGIC_1) {
2019 int r = BZ2_decompress(s);
2020 if (r == BZ_STREAM_END) {
2021 if (s->verbosity >= 3) {
2022 error_msg("\n combined CRCs: stored = 0x%x, computed = 0x%x",
2023 s->storedCombinedCRC, s->calculatedCombinedCRC );
2025 if (s->calculatedCombinedCRC != s->storedCombinedCRC) {
2026 return BZ_DATA_ERROR;
2030 if (s->state != BZ_X_OUTPUT) {
2038 return(0); /*NOTREACHED*/
2041 int BZ2_bzRead(int *bzerror, void *b, void *buf, int len)
2044 bzFile *bzf = (bzFile*)b;
2046 bz_seterr(BZ_OK, bzerror, &bzf);
2048 if (bzf == NULL || buf == NULL || len < 0) {
2049 bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
2054 bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
2059 bz_seterr(BZ_OK, bzerror, &bzf);
2063 bzf->strm.avail_out = len;
2064 bzf->strm.next_out = buf;
2067 if (ferror(bzf->handle)) {
2068 bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
2071 if ((bzf->strm.avail_in == 0) && !myfeof(bzf->handle)) {
2072 n = fread(bzf->buf, sizeof(unsigned char), BZ_MAX_UNUSED, bzf->handle);
2073 if (ferror(bzf->handle)) {
2074 bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
2078 bzf->strm.avail_in = bzf->bufN;
2079 bzf->strm.next_in = bzf->buf;
2082 ret = BZ2_bzDecompress(&(bzf->strm));
2084 if ((ret != BZ_OK) && (ret != BZ_STREAM_END)) {
2085 bz_seterr(ret, bzerror, &bzf);
2089 if ((ret == BZ_OK) && myfeof(bzf->handle) &&
2090 (bzf->strm.avail_in == 0) && (bzf->strm.avail_out > 0)) {
2091 bz_seterr(BZ_UNEXPECTED_EOF, bzerror, &bzf);
2095 if (ret == BZ_STREAM_END) {
2096 bz_seterr(BZ_STREAM_END, bzerror, &bzf);
2097 return(len - bzf->strm.avail_out);
2099 if (bzf->strm.avail_out == 0) {
2100 bz_seterr(BZ_OK, bzerror, &bzf);
2104 return(0); /*not reached*/
2107 void BZ2_bzReadGetUnused(int *bzerror, void *b, void **unused, int *nUnused)
2109 bzFile *bzf = (bzFile*)b;
2111 bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
2114 if (bzf->lastErr != BZ_STREAM_END) {
2115 bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
2118 if (unused == NULL || nUnused == NULL) {
2119 bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
2123 bz_seterr(BZ_OK, bzerror, &bzf);
2124 *nUnused = bzf->strm.avail_in;
2125 *unused = bzf->strm.next_in;
2128 void *BZ2_bzReadOpen(int *bzerror, FILE *f, int small, void *unused, int nUnused)
2133 bz_seterr(BZ_OK, bzerror, &bzf);
2135 if (f == NULL || (small != 0 && small != 1) ||
2136 (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)) ||
2137 // (verbosity_level < 0 || verbosity_level > 4) ||
2138 (unused == NULL && nUnused != 0)) {
2139 bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
2144 bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
2148 bzf = xmalloc(sizeof(bzFile));
2150 bz_seterr(BZ_MEM_ERROR, bzerror, &bzf);
2153 bz_seterr(BZ_OK, bzerror, &bzf);
2155 bzf->initialisedOk = FALSE;
2158 bzf->writing = FALSE;
2159 bzf->strm.bzalloc = NULL;
2160 bzf->strm.bzfree = NULL;
2161 bzf->strm.opaque = NULL;
2163 while (nUnused > 0) {
2164 bzf->buf[bzf->bufN] = *((unsigned char *)(unused)); bzf->bufN++;
2165 unused = ((void *)( 1 + ((unsigned char *)(unused)) ));
2169 ret = BZ2_bzDecompressInit(&(bzf->strm), small);
2171 bz_seterr(ret, bzerror, &bzf);
2176 bzf->strm.avail_in = bzf->bufN;
2177 bzf->strm.next_in = bzf->buf;
2179 bzf->initialisedOk = TRUE;
2183 static unsigned char uncompressStream(FILE *zStream, FILE *stream)
2185 unsigned char unused[BZ_MAX_UNUSED];
2186 unsigned char *unusedTmp;
2187 unsigned char obuf[5000];
2200 if (ferror(stream)) {
2203 if (ferror(zStream)) {
2208 bzf = BZ2_bzReadOpen(&bzerr, zStream, (int)smallMode, unused, nUnused);
2209 if (bzf == NULL || bzerr != BZ_OK) {
2214 while (bzerr == BZ_OK) {
2215 nread = BZ2_bzRead(&bzerr, bzf, obuf, 5000);
2216 if (bzerr == BZ_DATA_ERROR_MAGIC) {
2219 if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0) {
2220 fwrite(obuf, sizeof(unsigned char), nread, stream);
2222 if (ferror(stream)) {
2226 if (bzerr != BZ_STREAM_END) {
2229 BZ2_bzReadGetUnused(&bzerr, bzf, (void **)(&unusedTmp), &nUnused);
2230 if (bzerr != BZ_OK) {
2231 panic("decompress:bzReadGetUnused");
2233 for (i = 0; i < nUnused; i++) {
2234 unused[i] = unusedTmp[i];
2236 BZ2_bzReadClose(&bzerr, bzf);
2237 if (bzerr != BZ_OK) {
2238 panic("decompress:bzReadGetUnused");
2240 if ((nUnused == 0) && myfeof(zStream)) {
2245 if (ferror(zStream)) {
2248 ret = fclose(zStream);
2252 if (ferror(stream)) {
2255 ret = fflush(stream);
2259 if (stream != stdout) {
2260 ret = fclose(stream);
2265 // if (verbosity_level >= 2) {
2266 // fprintf(stderr,"\n ");
2271 BZ2_bzReadClose ( &bzerr_dummy, bzf );
2273 case BZ_CONFIG_ERROR:
2274 error_msg("bzip2: I'm not configured correctly for this platform!\n"
2275 "\tI require Int32, Int16 and Char to have sizes\n"
2276 "\tof 4, 2 and 1 bytes to run properly, and they don't.\n"
2277 "\tProbably you can fix this by defining them correctly,\n"
2278 "\tand recompiling. Bye!\n" );
2282 error_msg("\n%s: I/O or other error, bailing out. "
2283 "Possible reason follows.\n", progName);
2287 error_msg("\n%s: Data integrity error when decompressing.\n", progName);
2290 error_msg("\n%s: couldn't allocate enough memory\n", progName);
2292 case BZ_UNEXPECTED_EOF:
2293 error_msg("\n%s: Compressed file ends unexpectedly;\n\t"
2294 "perhaps it is corrupted? *Possible* reason follows.\n", progName);
2297 case BZ_DATA_ERROR_MAGIC:
2298 if (zStream != stdin) {
2301 if (stream != stdout) {
2304 if (streamNo == 1) {
2308 error_msg("\n%s: %s: trailing garbage after EOF ignored\n", progName, inName );
2313 panic ( "decompress:unexpected error" );
2316 panic("decompress:end");
2317 return(TRUE); /*notreached*/
2320 int bunzip2_main(int argc, char **argv)
2322 const int bunzip_to_stdout = 1;
2323 const int bunzip_force = 2;
2329 char *save_name = NULL;
2331 /* if called as bzcat */
2332 if (strcmp(applet_name, "bzcat") == 0)
2333 flags |= bunzip_to_stdout;
2335 while ((opt = getopt(argc, argv, "cfh")) != -1) {
2338 flags |= bunzip_to_stdout;
2341 flags |= bunzip_force;
2345 show_usage(); /* exit's inside usage */
2349 /* Set input filename and number */
2350 if (argv[optind] == NULL || strcmp(argv[optind], "-") == 0) {
2351 flags |= bunzip_to_stdout;
2354 /* Open input file */
2355 src_stream = xfopen(argv[optind], "r");
2357 save_name = xstrdup(argv[optind]);
2358 if (strcmp(save_name + strlen(save_name) - 4, ".bz2") != 0)
2359 error_msg_and_die("Invalid extension");
2360 save_name[strlen(save_name) - 4] = '\0';
2363 /* Check that the input is sane. */
2364 if (isatty(fileno(src_stream)) && (flags & bunzip_force) == 0)
2365 error_msg_and_die("compressed data not read from terminal. Use -f to force it.");
2367 if (flags & bunzip_to_stdout) {
2368 dst_stream = stdout;
2370 dst_stream = xfopen(save_name, "w");
2372 uncompressStream(src_stream, dst_stream);