?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add basic support for mini2440 board to barebox.
[barebox-mini2440.git] / lib / bzlib.c
blob4c928cadc814089208e379111e45bbb2b4fe8799
1 #include <config.h>
2 #include <common.h>
3 #include <watchdog.h>
4
5 /*
6 * This file is a modified version of bzlib.c from the bzip2-1.0.2
7 * distribution which can be found at http://sources.redhat.com/bzip2/
8 */
9
10 /*-------------------------------------------------------------*/
11 /*--- Library top-level functions. ---*/
12 /*--- bzlib.c ---*/
13 /*-------------------------------------------------------------*/
14
15 /*--
16 This file is a part of bzip2 and/or libbzip2, a program and
17 library for lossless, block-sorting data compression.
18
19 Copyright (C) 1996-2002 Julian R Seward. All rights reserved.
20
21 Redistribution and use in source and binary forms, with or without
22 modification, are permitted provided that the following conditions
23 are met:
24
25 1. Redistributions of source code must retain the above copyright
26 notice, this list of conditions and the following disclaimer.
27
28 2. The origin of this software must not be misrepresented; you must
29 not claim that you wrote the original software. If you use this
30 software in a product, an acknowledgment in the product
31 documentation would be appreciated but is not required.
32
33 3. Altered source versions must be plainly marked as such, and must
34 not be misrepresented as being the original software.
35
36 4. The name of the author may not be used to endorse or promote
37 products derived from this software without specific prior written
38 permission.
39
40 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
41 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
42 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
44 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
46 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
47 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
48 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
49 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
50 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
51
52 Julian Seward, Cambridge, UK.
53 jseward@acm.org
54 bzip2/libbzip2 version 1.0 of 21 March 2000
55
56 This program is based on (at least) the work of:
57 Mike Burrows
58 David Wheeler
59 Peter Fenwick
60 Alistair Moffat
61 Radford Neal
62 Ian H. Witten
63 Robert Sedgewick
64 Jon L. Bentley
65
66 For more information on these sources, see the manual.
67 --*/
68
69 /*--
70 CHANGES
71 ~~~~~~~
72 0.9.0 -- original version.
73
74 0.9.0a/b -- no changes in this file.
75
76 0.9.0c
77 * made zero-length BZ_FLUSH work correctly in bzCompress().
78 * fixed bzWrite/bzRead to ignore zero-length requests.
79 * fixed bzread to correctly handle read requests after EOF.
80 * wrong parameter order in call to bzDecompressInit in
81 bzBuffToBuffDecompress. Fixed.
82 --*/
83
84 #include "bzlib_private.h"
85
86 /*---------------------------------------------------*/
87 /*--- Compression stuff ---*/
88 /*---------------------------------------------------*/
89
90
91 /*---------------------------------------------------*/
92 #ifndef BZ_NO_STDIO
93 void BZ2_bz__AssertH__fail ( int errcode )
94 {
95 fprintf(stderr,
96 "\n\nbzip2/libbzip2: internal error number %d.\n"
97 "This is a bug in bzip2/libbzip2, %s.\n"
98 "Please report it to me at: jseward@acm.org. If this happened\n"
99 "when you were using some program which uses libbzip2 as a\n"
100 "component, you should also report this bug to the author(s)\n"
101 "of that program. Please make an effort to report this bug;\n"
102 "timely and accurate bug reports eventually lead to higher\n"
103 "quality software. Thanks. Julian Seward, 30 December 2001.\n\n",
104 errcode,
105 BZ2_bzlibVersion()
106 );
107
108 if (errcode == 1007) {
109 fprintf(stderr,
110 "\n*** A special note about internal error number 1007 ***\n"
111 "\n"
112 "Experience suggests that a common cause of i.e. 1007\n"
113 "is unreliable memory or other hardware. The 1007 assertion\n"
114 "just happens to cross-check the results of huge numbers of\n"
115 "memory reads/writes, and so acts (unintendedly) as a stress\n"
116 "test of your memory system.\n"
117 "\n"
118 "I suggest the following: try compressing the file again,\n"
119 "possibly monitoring progress in detail with the -vv flag.\n"
120 "\n"
121 "* If the error cannot be reproduced, and/or happens at different\n"
122 " points in compression, you may have a flaky memory system.\n"
123 " Try a memory-test program. I have used Memtest86\n"
124 " (www.memtest86.com). At the time of writing it is free (GPLd).\n"
125 " Memtest86 tests memory much more thorougly than your BIOSs\n"
126 " power-on test, and may find failures that the BIOS doesn't.\n"
127 "\n"
128 "* If the error can be repeatably reproduced, this is a bug in\n"
129 " bzip2, and I would very much like to hear about it. Please\n"
130 " let me know, and, ideally, save a copy of the file causing the\n"
131 " problem -- without which I will be unable to investigate it.\n"
132 "\n"
133 );
134 }
135
136 exit(3);
137 }
138 #endif
139
140
141 /*---------------------------------------------------*/
142 static
143 int bz_config_ok ( void )
144 {
145 if (sizeof(int) != 4) return 0;
146 if (sizeof(short) != 2) return 0;
147 if (sizeof(char) != 1) return 0;
148 return 1;
149 }
150
151
152 /*---------------------------------------------------*/
153 static
154 void* default_bzalloc ( void* opaque, Int32 items, Int32 size )
155 {
156 void* v = malloc ( items * size );
157 return v;
158 }
159
160 static
161 void default_bzfree ( void* opaque, void* addr )
162 {
163 if (addr != NULL) free ( addr );
164 }
165
166 #ifndef BZ_NO_COMPRESS
167 /*---------------------------------------------------*/
168 static
169 void prepare_new_block ( EState* s )
170 {
171 Int32 i;
172 s->nblock = 0;
173 s->numZ = 0;
174 s->state_out_pos = 0;
175 BZ_INITIALISE_CRC ( s->blockCRC );
176 for (i = 0; i < 256; i++) s->inUse[i] = False;
177 s->blockNo++;
178 }
179
180
181 /*---------------------------------------------------*/
182 static
183 void init_RL ( EState* s )
184 {
185 s->state_in_ch = 256;
186 s->state_in_len = 0;
187 }
188
189
190 static
191 Bool isempty_RL ( EState* s )
192 {
193 if (s->state_in_ch < 256 && s->state_in_len > 0)
194 return False; else
195 return True;
196 }
197
198 /*---------------------------------------------------*/
199 int BZ_API(BZ2_bzCompressInit)
200 ( bz_stream* strm,
201 int blockSize100k,
202 int verbosity,
203 int workFactor )
204 {
205 Int32 n;
206 EState* s;
207
208 if (!bz_config_ok()) return BZ_CONFIG_ERROR;
209
210 if (strm == NULL ||
211 blockSize100k < 1 || blockSize100k > 9 ||
212 workFactor < 0 || workFactor > 250)
213 return BZ_PARAM_ERROR;
214
215 if (workFactor == 0) workFactor = 30;
216 if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
217 if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
218
219 s = BZALLOC( sizeof(EState) );
220 if (s == NULL) return BZ_MEM_ERROR;
221 s->strm = strm;
222
223 s->arr1 = NULL;
224 s->arr2 = NULL;
225 s->ftab = NULL;
226
227 n = 100000 * blockSize100k;
228 s->arr1 = BZALLOC( n * sizeof(UInt32) );
229 s->arr2 = BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) );
230 s->ftab = BZALLOC( 65537 * sizeof(UInt32) );
231
232 if (s->arr1 == NULL || s->arr2 == NULL || s->ftab == NULL) {
233 if (s->arr1 != NULL) BZFREE(s->arr1);
234 if (s->arr2 != NULL) BZFREE(s->arr2);
235 if (s->ftab != NULL) BZFREE(s->ftab);
236 if (s != NULL) BZFREE(s);
237 return BZ_MEM_ERROR;
238 }
239
240 s->blockNo = 0;
241 s->state = BZ_S_INPUT;
242 s->mode = BZ_M_RUNNING;
243 s->combinedCRC = 0;
244 s->blockSize100k = blockSize100k;
245 s->nblockMAX = 100000 * blockSize100k - 19;
246 s->verbosity = verbosity;
247 s->workFactor = workFactor;
248
249 s->block = (UChar*)s->arr2;
250 s->mtfv = (UInt16*)s->arr1;
251 s->zbits = NULL;
252 s->ptr = (UInt32*)s->arr1;
253
254 strm->state = s;
255 strm->total_in_lo32 = 0;
256 strm->total_in_hi32 = 0;
257 strm->total_out_lo32 = 0;
258 strm->total_out_hi32 = 0;
259 init_RL ( s );
260 prepare_new_block ( s );
261 return BZ_OK;
262 }
263
264
265 /*---------------------------------------------------*/
266 static
267 void add_pair_to_block ( EState* s )
268 {
269 Int32 i;
270 UChar ch = (UChar)(s->state_in_ch);
271 for (i = 0; i < s->state_in_len; i++) {
272 BZ_UPDATE_CRC( s->blockCRC, ch );
273 }
274 s->inUse[s->state_in_ch] = True;
275 switch (s->state_in_len) {
276 case 1:
277 s->block[s->nblock] = (UChar)ch; s->nblock++;
278 break;
279 case 2:
280 s->block[s->nblock] = (UChar)ch; s->nblock++;
281 s->block[s->nblock] = (UChar)ch; s->nblock++;
282 break;
283 case 3:
284 s->block[s->nblock] = (UChar)ch; s->nblock++;
285 s->block[s->nblock] = (UChar)ch; s->nblock++;
286 s->block[s->nblock] = (UChar)ch; s->nblock++;
287 break;
288 default:
289 s->inUse[s->state_in_len-4] = True;
290 s->block[s->nblock] = (UChar)ch; s->nblock++;
291 s->block[s->nblock] = (UChar)ch; s->nblock++;
292 s->block[s->nblock] = (UChar)ch; s->nblock++;
293 s->block[s->nblock] = (UChar)ch; s->nblock++;
294 s->block[s->nblock] = ((UChar)(s->state_in_len-4));
295 s->nblock++;
296 break;
297 }
298 }
299
300
301 /*---------------------------------------------------*/
302 static
303 void flush_RL ( EState* s )
304 {
305 if (s->state_in_ch < 256) add_pair_to_block ( s );
306 init_RL ( s );
307 }
308
309
310 /*---------------------------------------------------*/
311 #define ADD_CHAR_TO_BLOCK(zs,zchh0) \
312 { \
313 UInt32 zchh = (UInt32)(zchh0); \
314 /*-- fast track the common case --*/ \
315 if (zchh != zs->state_in_ch && \
316 zs->state_in_len == 1) { \
317 UChar ch = (UChar)(zs->state_in_ch); \
318 BZ_UPDATE_CRC( zs->blockCRC, ch ); \
319 zs->inUse[zs->state_in_ch] = True; \
320 zs->block[zs->nblock] = (UChar)ch; \
321 zs->nblock++; \
322 zs->state_in_ch = zchh; \
323 } \
324 else \
325 /*-- general, uncommon cases --*/ \
326 if (zchh != zs->state_in_ch || \
327 zs->state_in_len == 255) { \
328 if (zs->state_in_ch < 256) \
329 add_pair_to_block ( zs ); \
330 zs->state_in_ch = zchh; \
331 zs->state_in_len = 1; \
332 } else { \
333 zs->state_in_len++; \
334 } \
335 }
336
337
338 /*---------------------------------------------------*/
339 static
340 Bool copy_input_until_stop ( EState* s )
341 {
342 Bool progress_in = False;
343
344 if (s->mode == BZ_M_RUNNING) {
345
346 /*-- fast track the common case --*/
347 while (True) {
348 /*-- block full? --*/
349 if (s->nblock >= s->nblockMAX) break;
350 /*-- no input? --*/
351 if (s->strm->avail_in == 0) break;
352 progress_in = True;
353 ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
354 s->strm->next_in++;
355 s->strm->avail_in--;
356 s->strm->total_in_lo32++;
357 if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
358 }
359
360 } else {
361
362 /*-- general, uncommon case --*/
363 while (True) {
364 /*-- block full? --*/
365 if (s->nblock >= s->nblockMAX) break;
366 /*-- no input? --*/
367 if (s->strm->avail_in == 0) break;
368 /*-- flush/finish end? --*/
369 if (s->avail_in_expect == 0) break;
370 progress_in = True;
371 ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
372 s->strm->next_in++;
373 s->strm->avail_in--;
374 s->strm->total_in_lo32++;
375 if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
376 s->avail_in_expect--;
377 }
378 }
379 return progress_in;
380 }
381
382
383 /*---------------------------------------------------*/
384 static
385 Bool copy_output_until_stop ( EState* s )
386 {
387 Bool progress_out = False;
388
389 while (True) {
390
391 /*-- no output space? --*/
392 if (s->strm->avail_out == 0) break;
393
394 /*-- block done? --*/
395 if (s->state_out_pos >= s->numZ) break;
396
397 progress_out = True;
398 *(s->strm->next_out) = s->zbits[s->state_out_pos];
399 s->state_out_pos++;
400 s->strm->avail_out--;
401 s->strm->next_out++;
402 s->strm->total_out_lo32++;
403 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
404 }
405
406 return progress_out;
407 }
408
409
410 /*---------------------------------------------------*/
411 static
412 Bool handle_compress ( bz_stream* strm )
413 {
414 Bool progress_in = False;
415 Bool progress_out = False;
416 EState* s = strm->state;
417
418 while (True) {
419
420 if (s->state == BZ_S_OUTPUT) {
421 progress_out |= copy_output_until_stop ( s );
422 if (s->state_out_pos < s->numZ) break;
423 if (s->mode == BZ_M_FINISHING &&
424 s->avail_in_expect == 0 &&
425 isempty_RL(s)) break;
426 prepare_new_block ( s );
427 s->state = BZ_S_INPUT;
428 if (s->mode == BZ_M_FLUSHING &&
429 s->avail_in_expect == 0 &&
430 isempty_RL(s)) break;
431 }
432
433 if (s->state == BZ_S_INPUT) {
434 progress_in |= copy_input_until_stop ( s );
435 if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) {
436 flush_RL ( s );
437 BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) );
438 s->state = BZ_S_OUTPUT;
439 }
440 else
441 if (s->nblock >= s->nblockMAX) {
442 BZ2_compressBlock ( s, False );
443 s->state = BZ_S_OUTPUT;
444 }
445 else
446 if (s->strm->avail_in == 0) {
447 break;
448 }
449 }
450
451 }
452
453 return progress_in || progress_out;
454 }
455
456
457 /*---------------------------------------------------*/
458 int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
459 {
460 Bool progress;
461 EState* s;
462 if (strm == NULL) return BZ_PARAM_ERROR;
463 s = strm->state;
464 if (s == NULL) return BZ_PARAM_ERROR;
465 if (s->strm != strm) return BZ_PARAM_ERROR;
466
467 preswitch:
468 switch (s->mode) {
469
470 case BZ_M_IDLE:
471 return BZ_SEQUENCE_ERROR;
472
473 case BZ_M_RUNNING:
474 if (action == BZ_RUN) {
475 progress = handle_compress ( strm );
476 return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
477 }
478 else
479 if (action == BZ_FLUSH) {
480 s->avail_in_expect = strm->avail_in;
481 s->mode = BZ_M_FLUSHING;
482 goto preswitch;
483 }
484 else
485 if (action == BZ_FINISH) {
486 s->avail_in_expect = strm->avail_in;
487 s->mode = BZ_M_FINISHING;
488 goto preswitch;
489 }
490 else
491 return BZ_PARAM_ERROR;
492
493 case BZ_M_FLUSHING:
494 if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
495 if (s->avail_in_expect != s->strm->avail_in)
496 return BZ_SEQUENCE_ERROR;
497 progress = handle_compress ( strm );
498 if (s->avail_in_expect > 0 || !isempty_RL(s) ||
499 s->state_out_pos < s->numZ) return BZ_FLUSH_OK;
500 s->mode = BZ_M_RUNNING;
501 return BZ_RUN_OK;
502
503 case BZ_M_FINISHING:
504 if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
505 if (s->avail_in_expect != s->strm->avail_in)
506 return BZ_SEQUENCE_ERROR;
507 progress = handle_compress ( strm );
508 if (!progress) return BZ_SEQUENCE_ERROR;
509 if (s->avail_in_expect > 0 || !isempty_RL(s) ||
510 s->state_out_pos < s->numZ) return BZ_FINISH_OK;
511 s->mode = BZ_M_IDLE;
512 return BZ_STREAM_END;
513 }
514 return BZ_OK; /*--not reached--*/
515 }
516
517
518 /*---------------------------------------------------*/
519 int BZ_API(BZ2_bzCompressEnd) ( bz_stream *strm )
520 {
521 EState* s;
522 if (strm == NULL) return BZ_PARAM_ERROR;
523 s = strm->state;
524 if (s == NULL) return BZ_PARAM_ERROR;
525 if (s->strm != strm) return BZ_PARAM_ERROR;
526
527 if (s->arr1 != NULL) BZFREE(s->arr1);
528 if (s->arr2 != NULL) BZFREE(s->arr2);
529 if (s->ftab != NULL) BZFREE(s->ftab);
530 BZFREE(strm->state);
531
532 strm->state = NULL;
533
534 return BZ_OK;
535 }
536 #endif /* BZ_NO_COMPRESS */
537
538 /*---------------------------------------------------*/
539 /*--- Decompression stuff ---*/
540 /*---------------------------------------------------*/
541
542 /*---------------------------------------------------*/
543 int BZ_API(BZ2_bzDecompressInit)
544 ( bz_stream* strm,
545 int verbosity,
546 int small )
547 {
548 DState* s;
549
550 if (!bz_config_ok()) return BZ_CONFIG_ERROR;
551
552 if (strm == NULL) return BZ_PARAM_ERROR;
553 if (small != 0 && small != 1) return BZ_PARAM_ERROR;
554 if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR;
555
556 if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc;
557 if (strm->bzfree == NULL) strm->bzfree = default_bzfree;
558
559 s = BZALLOC( sizeof(DState) );
560 if (s == NULL) return BZ_MEM_ERROR;
561 s->strm = strm;
562 strm->state = s;
563 s->state = BZ_X_MAGIC_1;
564 s->bsLive = 0;
565 s->bsBuff = 0;
566 s->calculatedCombinedCRC = 0;
567 strm->total_in_lo32 = 0;
568 strm->total_in_hi32 = 0;
569 strm->total_out_lo32 = 0;
570 strm->total_out_hi32 = 0;
571 s->smallDecompress = (Bool)small;
572 s->ll4 = NULL;
573 s->ll16 = NULL;
574 s->tt = NULL;
575 s->currBlockNo = 0;
576 s->verbosity = verbosity;
577
578 return BZ_OK;
579 }
580
581
582 /*---------------------------------------------------*/
583 static
584 void unRLE_obuf_to_output_FAST ( DState* s )
585 {
586 UChar k1;
587
588 if (s->blockRandomised) {
589
590 while (True) {
591 /* try to finish existing run */
592 while (True) {
593 if (s->strm->avail_out == 0) return;
594 if (s->state_out_len == 0) break;
595 *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
596 BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
597 s->state_out_len--;
598 s->strm->next_out++;
599 s->strm->avail_out--;
600 s->strm->total_out_lo32++;
601 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
602 }
603
604 /* can a new run be started? */
605 if (s->nblock_used == s->save_nblock+1) return;
606
607
608 s->state_out_len = 1;
609 s->state_out_ch = s->k0;
610 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
611 k1 ^= BZ_RAND_MASK; s->nblock_used++;
612 if (s->nblock_used == s->save_nblock+1) continue;
613 if (k1 != s->k0) { s->k0 = k1; continue; };
614
615 s->state_out_len = 2;
616 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
617 k1 ^= BZ_RAND_MASK; s->nblock_used++;
618 if (s->nblock_used == s->save_nblock+1) continue;
619 if (k1 != s->k0) { s->k0 = k1; continue; };
620
621 s->state_out_len = 3;
622 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
623 k1 ^= BZ_RAND_MASK; s->nblock_used++;
624 if (s->nblock_used == s->save_nblock+1) continue;
625 if (k1 != s->k0) { s->k0 = k1; continue; };
626
627 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
628 k1 ^= BZ_RAND_MASK; s->nblock_used++;
629 s->state_out_len = ((Int32)k1) + 4;
630 BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK;
631 s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
632 }
633
634 } else {
635
636 /* restore */
637 UInt32 c_calculatedBlockCRC = s->calculatedBlockCRC;
638 UChar c_state_out_ch = s->state_out_ch;
639 Int32 c_state_out_len = s->state_out_len;
640 Int32 c_nblock_used = s->nblock_used;
641 Int32 c_k0 = s->k0;
642 UInt32* c_tt = s->tt;
643 UInt32 c_tPos = s->tPos;
644 char* cs_next_out = s->strm->next_out;
645 unsigned int cs_avail_out = s->strm->avail_out;
646 /* end restore */
647
648 UInt32 avail_out_INIT = cs_avail_out;
649 Int32 s_save_nblockPP = s->save_nblock+1;
650 unsigned int total_out_lo32_old;
651
652 while (True) {
653
654 /* try to finish existing run */
655 if (c_state_out_len > 0) {
656 while (True) {
657 if (cs_avail_out == 0) goto return_notr;
658 if (c_state_out_len == 1) break;
659 *( (UChar*)(cs_next_out) ) = c_state_out_ch;
660 BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
661 c_state_out_len--;
662 cs_next_out++;
663 cs_avail_out--;
664 }
665 s_state_out_len_eq_one:
666 {
667 if (cs_avail_out == 0) {
668 c_state_out_len = 1; goto return_notr;
669 };
670 *( (UChar*)(cs_next_out) ) = c_state_out_ch;
671 BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
672 cs_next_out++;
673 cs_avail_out--;
674 }
675 }
676 /* can a new run be started? */
677 if (c_nblock_used == s_save_nblockPP) {
678 c_state_out_len = 0; goto return_notr;
679 };
680 c_state_out_ch = c_k0;
681 BZ_GET_FAST_C(k1); c_nblock_used++;
682 if (k1 != c_k0) {
683 c_k0 = k1; goto s_state_out_len_eq_one;
684 };
685 if (c_nblock_used == s_save_nblockPP)
686 goto s_state_out_len_eq_one;
687
688 c_state_out_len = 2;
689 BZ_GET_FAST_C(k1); c_nblock_used++;
690 if (c_nblock_used == s_save_nblockPP) continue;
691 if (k1 != c_k0) { c_k0 = k1; continue; };
692
693 c_state_out_len = 3;
694 BZ_GET_FAST_C(k1); c_nblock_used++;
695 if (c_nblock_used == s_save_nblockPP) continue;
696 if (k1 != c_k0) { c_k0 = k1; continue; };
697
698 BZ_GET_FAST_C(k1); c_nblock_used++;
699 c_state_out_len = ((Int32)k1) + 4;
700 BZ_GET_FAST_C(c_k0); c_nblock_used++;
701 }
702
703 return_notr:
704 total_out_lo32_old = s->strm->total_out_lo32;
705 s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
706 if (s->strm->total_out_lo32 < total_out_lo32_old)
707 s->strm->total_out_hi32++;
708
709 /* save */
710 s->calculatedBlockCRC = c_calculatedBlockCRC;
711 s->state_out_ch = c_state_out_ch;
712 s->state_out_len = c_state_out_len;
713 s->nblock_used = c_nblock_used;
714 s->k0 = c_k0;
715 s->tt = c_tt;
716 s->tPos = c_tPos;
717 s->strm->next_out = cs_next_out;
718 s->strm->avail_out = cs_avail_out;
719 /* end save */
720 }
721 }
722
723
724 /*---------------------------------------------------*/
725 __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
726 {
727 Int32 nb, na, mid;
728 nb = 0;
729 na = 256;
730 do {
731 mid = (nb + na) >> 1;
732 if (indx >= cftab[mid]) nb = mid; else na = mid;
733 }
734 while (na - nb != 1);
735 return nb;
736 }
737
738
739 /*---------------------------------------------------*/
740 static
741 void unRLE_obuf_to_output_SMALL ( DState* s )
742 {
743 UChar k1;
744
745 if (s->blockRandomised) {
746
747 while (True) {
748 /* try to finish existing run */
749 while (True) {
750 if (s->strm->avail_out == 0) return;
751 if (s->state_out_len == 0) break;
752 *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
753 BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
754 s->state_out_len--;
755 s->strm->next_out++;
756 s->strm->avail_out--;
757 s->strm->total_out_lo32++;
758 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
759 }
760
761 /* can a new run be started? */
762 if (s->nblock_used == s->save_nblock+1) return;
763
764
765 s->state_out_len = 1;
766 s->state_out_ch = s->k0;
767 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
768 k1 ^= BZ_RAND_MASK; s->nblock_used++;
769 if (s->nblock_used == s->save_nblock+1) continue;
770 if (k1 != s->k0) { s->k0 = k1; continue; };
771
772 s->state_out_len = 2;
773 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
774 k1 ^= BZ_RAND_MASK; s->nblock_used++;
775 if (s->nblock_used == s->save_nblock+1) continue;
776 if (k1 != s->k0) { s->k0 = k1; continue; };
777
778 s->state_out_len = 3;
779 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
780 k1 ^= BZ_RAND_MASK; s->nblock_used++;
781 if (s->nblock_used == s->save_nblock+1) continue;
782 if (k1 != s->k0) { s->k0 = k1; continue; };
783
784 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
785 k1 ^= BZ_RAND_MASK; s->nblock_used++;
786 s->state_out_len = ((Int32)k1) + 4;
787 BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
788 s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
789 }
790
791 } else {
792
793 while (True) {
794 /* try to finish existing run */
795 while (True) {
796 if (s->strm->avail_out == 0) return;
797 if (s->state_out_len == 0) break;
798 *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
799 BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
800 s->state_out_len--;
801 s->strm->next_out++;
802 s->strm->avail_out--;
803 s->strm->total_out_lo32++;
804 if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
805 }
806
807 /* can a new run be started? */
808 if (s->nblock_used == s->save_nblock+1) return;
809
810 s->state_out_len = 1;
811 s->state_out_ch = s->k0;
812 BZ_GET_SMALL(k1); s->nblock_used++;
813 if (s->nblock_used == s->save_nblock+1) continue;
814 if (k1 != s->k0) { s->k0 = k1; continue; };
815
816 s->state_out_len = 2;
817 BZ_GET_SMALL(k1); s->nblock_used++;
818 if (s->nblock_used == s->save_nblock+1) continue;
819 if (k1 != s->k0) { s->k0 = k1; continue; };
820
821 s->state_out_len = 3;
822 BZ_GET_SMALL(k1); s->nblock_used++;
823 if (s->nblock_used == s->save_nblock+1) continue;
824 if (k1 != s->k0) { s->k0 = k1; continue; };
825
826 BZ_GET_SMALL(k1); s->nblock_used++;
827 s->state_out_len = ((Int32)k1) + 4;
828 BZ_GET_SMALL(s->k0); s->nblock_used++;
829 }
830
831 }
832 }
833
834
835 /*---------------------------------------------------*/
836 int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
837 {
838 DState* s;
839 if (strm == NULL) return BZ_PARAM_ERROR;
840 s = strm->state;
841 if (s == NULL) return BZ_PARAM_ERROR;
842 if (s->strm != strm) return BZ_PARAM_ERROR;
843
844 while (True) {
845 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
846 WATCHDOG_RESET();
847 #endif
848 if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
849 if (s->state == BZ_X_OUTPUT) {
850 if (s->smallDecompress)
851 unRLE_obuf_to_output_SMALL ( s ); else
852 unRLE_obuf_to_output_FAST ( s );
853 if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
854 BZ_FINALISE_CRC ( s->calculatedBlockCRC );
855 if (s->verbosity >= 3)
856 VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC,
857 s->calculatedBlockCRC );
858 if (s->verbosity >= 2) VPrintf0 ( "]" );
859 if (s->calculatedBlockCRC != s->storedBlockCRC)
860 return BZ_DATA_ERROR;
861 s->calculatedCombinedCRC
862 = (s->calculatedCombinedCRC << 1) |
863 (s->calculatedCombinedCRC >> 31);
864 s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
865 s->state = BZ_X_BLKHDR_1;
866 } else {
867 return BZ_OK;
868 }
869 }
870 if (s->state >= BZ_X_MAGIC_1) {
871 Int32 r = BZ2_decompress ( s );
872 if (r == BZ_STREAM_END) {
873 if (s->verbosity >= 3)
874 VPrintf2 ( "\n combined CRCs: stored = 0x%x, computed = 0x%x",
875 s->storedCombinedCRC, s->calculatedCombinedCRC );
876 if (s->calculatedCombinedCRC != s->storedCombinedCRC)
877 return BZ_DATA_ERROR;
878 return r;
879 }
880 if (s->state != BZ_X_OUTPUT) return r;
881 }
882 }
883
884 AssertH ( 0, 6001 );
885
886 return 0; /*NOTREACHED*/
887 }
888
889
890 /*---------------------------------------------------*/
891 int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm )
892 {
893 DState* s;
894 if (strm == NULL) return BZ_PARAM_ERROR;
895 s = strm->state;
896 if (s == NULL) return BZ_PARAM_ERROR;
897 if (s->strm != strm) return BZ_PARAM_ERROR;
898
899 if (s->tt != NULL) BZFREE(s->tt);
900 if (s->ll16 != NULL) BZFREE(s->ll16);
901 if (s->ll4 != NULL) BZFREE(s->ll4);
902
903 BZFREE(strm->state);
904 strm->state = NULL;
905
906 return BZ_OK;
907 }
908
909
910 #ifndef BZ_NO_STDIO
911 /*---------------------------------------------------*/
912 /*--- File I/O stuff ---*/
913 /*---------------------------------------------------*/
914
915 #define BZ_SETERR(eee) \
916 { \
917 if (bzerror != NULL) *bzerror = eee; \
918 if (bzf != NULL) bzf->lastErr = eee; \
919 }
920
921 typedef
922 struct {
923 FILE* handle;
924 Char buf[BZ_MAX_UNUSED];
925 Int32 bufN;
926 Bool writing;
927 bz_stream strm;
928 Int32 lastErr;
929 Bool initialisedOk;
930 }
931 bzFile;
932
933
934 /*---------------------------------------------*/
935 static Bool myfeof ( FILE* f )
936 {
937 Int32 c = fgetc ( f );
938 if (c == EOF) return True;
939 ungetc ( c, f );
940 return False;
941 }
942
943
944 /*---------------------------------------------------*/
945 BZFILE* BZ_API(BZ2_bzWriteOpen)
946 ( int* bzerror,
947 FILE* f,
948 int blockSize100k,
949 int verbosity,
950 int workFactor )
951 {
952 Int32 ret;
953 bzFile* bzf = NULL;
954
955 BZ_SETERR(BZ_OK);
956
957 if (f == NULL ||
958 (blockSize100k < 1 || blockSize100k > 9) ||
959 (workFactor < 0 || workFactor > 250) ||
960 (verbosity < 0 || verbosity > 4))
961 { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
962
963 if (ferror(f))
964 { BZ_SETERR(BZ_IO_ERROR); return NULL; };
965
966 bzf = malloc ( sizeof(bzFile) );
967 if (bzf == NULL)
968 { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
969
970 BZ_SETERR(BZ_OK);
971 bzf->initialisedOk = False;
972 bzf->bufN = 0;
973 bzf->handle = f;
974 bzf->writing = True;
975 bzf->strm.bzalloc = NULL;
976 bzf->strm.bzfree = NULL;
977 bzf->strm.opaque = NULL;
978
979 if (workFactor == 0) workFactor = 30;
980 ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k,
981 verbosity, workFactor );
982 if (ret != BZ_OK)
983 { BZ_SETERR(ret); free(bzf); return NULL; };
984
985 bzf->strm.avail_in = 0;
986 bzf->initialisedOk = True;
987 return bzf;
988 }
989
990
991 /*---------------------------------------------------*/
992 void BZ_API(BZ2_bzWrite)
993 ( int* bzerror,
994 BZFILE* b,
995 void* buf,
996 int len )
997 {
998 Int32 n, n2, ret;
999 bzFile* bzf = (bzFile*)b;
1000
1001 BZ_SETERR(BZ_OK);
1002 if (bzf == NULL || buf == NULL || len < 0)
1003 { BZ_SETERR(BZ_PARAM_ERROR); return; };
1004 if (!(bzf->writing))
1005 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1006 if (ferror(bzf->handle))
1007 { BZ_SETERR(BZ_IO_ERROR); return; };
1008
1009 if (len == 0)
1010 { BZ_SETERR(BZ_OK); return; };
1011
1012 bzf->strm.avail_in = len;
1013 bzf->strm.next_in = buf;
1014
1015 while (True) {
1016 bzf->strm.avail_out = BZ_MAX_UNUSED;
1017 bzf->strm.next_out = bzf->buf;
1018 ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN );
1019 if (ret != BZ_RUN_OK)
1020 { BZ_SETERR(ret); return; };
1021
1022 if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
1023 n = BZ_MAX_UNUSED - bzf->strm.avail_out;
1024 n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
1025 n, bzf->handle );
1026 if (n != n2 || ferror(bzf->handle))
1027 { BZ_SETERR(BZ_IO_ERROR); return; };
1028 }
1029
1030 if (bzf->strm.avail_in == 0)
1031 { BZ_SETERR(BZ_OK); return; };
1032 }
1033 }
1034
1035
1036 /*---------------------------------------------------*/
1037 void BZ_API(BZ2_bzWriteClose)
1038 ( int* bzerror,
1039 BZFILE* b,
1040 int abandon,
1041 unsigned int* nbytes_in,
1042 unsigned int* nbytes_out )
1043 {
1044 BZ2_bzWriteClose64 ( bzerror, b, abandon,
1045 nbytes_in, NULL, nbytes_out, NULL );
1046 }
1047
1048
1049 void BZ_API(BZ2_bzWriteClose64)
1050 ( int* bzerror,
1051 BZFILE* b,
1052 int abandon,
1053 unsigned int* nbytes_in_lo32,
1054 unsigned int* nbytes_in_hi32,
1055 unsigned int* nbytes_out_lo32,
1056 unsigned int* nbytes_out_hi32 )
1057 {
1058 Int32 n, n2, ret;
1059 bzFile* bzf = (bzFile*)b;
1060
1061 if (bzf == NULL)
1062 { BZ_SETERR(BZ_OK); return; };
1063 if (!(bzf->writing))
1064 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1065 if (ferror(bzf->handle))
1066 { BZ_SETERR(BZ_IO_ERROR); return; };
1067
1068 if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0;
1069 if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0;
1070 if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0;
1071 if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0;
1072
1073 if ((!abandon) && bzf->lastErr == BZ_OK) {
1074 while (True) {
1075 bzf->strm.avail_out = BZ_MAX_UNUSED;
1076 bzf->strm.next_out = bzf->buf;
1077 ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH );
1078 if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END)
1079 { BZ_SETERR(ret); return; };
1080
1081 if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
1082 n = BZ_MAX_UNUSED - bzf->strm.avail_out;
1083 n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
1084 n, bzf->handle );
1085 if (n != n2 || ferror(bzf->handle))
1086 { BZ_SETERR(BZ_IO_ERROR); return; };
1087 }
1088
1089 if (ret == BZ_STREAM_END) break;
1090 }
1091 }
1092
1093 if ( !abandon && !ferror ( bzf->handle ) ) {
1094 fflush ( bzf->handle );
1095 if (ferror(bzf->handle))
1096 { BZ_SETERR(BZ_IO_ERROR); return; };
1097 }
1098
1099 if (nbytes_in_lo32 != NULL)
1100 *nbytes_in_lo32 = bzf->strm.total_in_lo32;
1101 if (nbytes_in_hi32 != NULL)
1102 *nbytes_in_hi32 = bzf->strm.total_in_hi32;
1103 if (nbytes_out_lo32 != NULL)
1104 *nbytes_out_lo32 = bzf->strm.total_out_lo32;
1105 if (nbytes_out_hi32 != NULL)
1106 *nbytes_out_hi32 = bzf->strm.total_out_hi32;
1107
1108 BZ_SETERR(BZ_OK);
1109 BZ2_bzCompressEnd ( &(bzf->strm) );
1110 free ( bzf );
1111 }
1112
1113
1114 /*---------------------------------------------------*/
1115 BZFILE* BZ_API(BZ2_bzReadOpen)
1116 ( int* bzerror,
1117 FILE* f,
1118 int verbosity,
1119 int small,
1120 void* unused,
1121 int nUnused )
1122 {
1123 bzFile* bzf = NULL;
1124 int ret;
1125
1126 BZ_SETERR(BZ_OK);
1127
1128 if (f == NULL ||
1129 (small != 0 && small != 1) ||
1130 (verbosity < 0 || verbosity > 4) ||
1131 (unused == NULL && nUnused != 0) ||
1132 (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)))
1133 { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
1134
1135 if (ferror(f))
1136 { BZ_SETERR(BZ_IO_ERROR); return NULL; };
1137
1138 bzf = malloc ( sizeof(bzFile) );
1139 if (bzf == NULL)
1140 { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
1141
1142 BZ_SETERR(BZ_OK);
1143
1144 bzf->initialisedOk = False;
1145 bzf->handle = f;
1146 bzf->bufN = 0;
1147 bzf->writing = False;
1148 bzf->strm.bzalloc = NULL;
1149 bzf->strm.bzfree = NULL;
1150 bzf->strm.opaque = NULL;
1151
1152 while (nUnused > 0) {
1153 bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
1154 unused = ((void*)( 1 + ((UChar*)(unused)) ));
1155 nUnused--;
1156 }
1157
1158 ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
1159 if (ret != BZ_OK)
1160 { BZ_SETERR(ret); free(bzf); return NULL; };
1161
1162 bzf->strm.avail_in = bzf->bufN;
1163 bzf->strm.next_in = bzf->buf;
1164
1165 bzf->initialisedOk = True;
1166 return bzf;
1167 }
1168
1169
1170 /*---------------------------------------------------*/
1171 void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
1172 {
1173 bzFile* bzf = (bzFile*)b;
1174
1175 BZ_SETERR(BZ_OK);
1176 if (bzf == NULL)
1177 { BZ_SETERR(BZ_OK); return; };
1178
1179 if (bzf->writing)
1180 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1181
1182 if (bzf->initialisedOk)
1183 (void)BZ2_bzDecompressEnd ( &(bzf->strm) );
1184 free ( bzf );
1185 }
1186
1187
1188 /*---------------------------------------------------*/
1189 int BZ_API(BZ2_bzRead)
1190 ( int* bzerror,
1191 BZFILE* b,
1192 void* buf,
1193 int len )
1194 {
1195 Int32 n, ret;
1196 bzFile* bzf = (bzFile*)b;
1197
1198 BZ_SETERR(BZ_OK);
1199
1200 if (bzf == NULL || buf == NULL || len < 0)
1201 { BZ_SETERR(BZ_PARAM_ERROR); return 0; };
1202
1203 if (bzf->writing)
1204 { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };
1205
1206 if (len == 0)
1207 { BZ_SETERR(BZ_OK); return 0; };
1208
1209 bzf->strm.avail_out = len;
1210 bzf->strm.next_out = buf;
1211
1212 while (True) {
1213
1214 if (ferror(bzf->handle))
1215 { BZ_SETERR(BZ_IO_ERROR); return 0; };
1216
1217 if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) {
1218 n = fread ( bzf->buf, sizeof(UChar),
1219 BZ_MAX_UNUSED, bzf->handle );
1220 if (ferror(bzf->handle))
1221 { BZ_SETERR(BZ_IO_ERROR); return 0; };
1222 bzf->bufN = n;
1223 bzf->strm.avail_in = bzf->bufN;
1224 bzf->strm.next_in = bzf->buf;
1225 }
1226
1227 ret = BZ2_bzDecompress ( &(bzf->strm) );
1228
1229 if (ret != BZ_OK && ret != BZ_STREAM_END)
1230 { BZ_SETERR(ret); return 0; };
1231
1232 if (ret == BZ_OK && myfeof(bzf->handle) &&
1233 bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
1234 { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
1235
1236 if (ret == BZ_STREAM_END)
1237 { BZ_SETERR(BZ_STREAM_END);
1238 return len - bzf->strm.avail_out; };
1239 if (bzf->strm.avail_out == 0)
1240 { BZ_SETERR(BZ_OK); return len; };
1241
1242 }
1243
1244 return 0; /*not reached*/
1245 }
1246
1247
1248 /*---------------------------------------------------*/
1249 void BZ_API(BZ2_bzReadGetUnused)
1250 ( int* bzerror,
1251 BZFILE* b,
1252 void** unused,
1253 int* nUnused )
1254 {
1255 bzFile* bzf = (bzFile*)b;
1256 if (bzf == NULL)
1257 { BZ_SETERR(BZ_PARAM_ERROR); return; };
1258 if (bzf->lastErr != BZ_STREAM_END)
1259 { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
1260 if (unused == NULL || nUnused == NULL)
1261 { BZ_SETERR(BZ_PARAM_ERROR); return; };
1262
1263 BZ_SETERR(BZ_OK);
1264 *nUnused = bzf->strm.avail_in;
1265 *unused = bzf->strm.next_in;
1266 }
1267 #endif
1268
1269
1270 /*---------------------------------------------------*/
1271 /*--- Misc convenience stuff ---*/
1272 /*---------------------------------------------------*/
1273 #ifndef BZ_NO_COMPRESS
1274 /*---------------------------------------------------*/
1275 int BZ_API(BZ2_bzBuffToBuffCompress)
1276 ( char* dest,
1277 unsigned int* destLen,
1278 char* source,
1279 unsigned int sourceLen,
1280 int blockSize100k,
1281 int verbosity,
1282 int workFactor )
1283 {
1284 bz_stream strm;
1285 int ret;
1286
1287 if (dest == NULL || destLen == NULL ||
1288 source == NULL ||
1289 blockSize100k < 1 || blockSize100k > 9 ||
1290 verbosity < 0 || verbosity > 4 ||
1291 workFactor < 0 || workFactor > 250)
1292 return BZ_PARAM_ERROR;
1293
1294 if (workFactor == 0) workFactor = 30;
1295 strm.bzalloc = NULL;
1296 strm.bzfree = NULL;
1297 strm.opaque = NULL;
1298 ret = BZ2_bzCompressInit ( &strm, blockSize100k,
1299 verbosity, workFactor );
1300 if (ret != BZ_OK) return ret;
1301
1302 strm.next_in = source;
1303 strm.next_out = dest;
1304 strm.avail_in = sourceLen;
1305 strm.avail_out = *destLen;
1306
1307 ret = BZ2_bzCompress ( &strm, BZ_FINISH );
1308 if (ret == BZ_FINISH_OK) goto output_overflow;
1309 if (ret != BZ_STREAM_END) goto errhandler;
1310
1311 /* normal termination */
1312 *destLen -= strm.avail_out;
1313 BZ2_bzCompressEnd ( &strm );
1314 return BZ_OK;
1315
1316 output_overflow:
1317 BZ2_bzCompressEnd ( &strm );
1318 return BZ_OUTBUFF_FULL;
1319
1320 errhandler:
1321 BZ2_bzCompressEnd ( &strm );
1322 return ret;
1323 }
1324 #endif /* BZ_NO_COMPRESS */
1325
1326 /*---------------------------------------------------*/
1327 int BZ_API(BZ2_bzBuffToBuffDecompress)
1328 ( char* dest,
1329 unsigned int* destLen,
1330 char* source,
1331 unsigned int sourceLen,
1332 int small,
1333 int verbosity )
1334 {
1335 bz_stream strm;
1336 int ret;
1337
1338 if (destLen == NULL || source == NULL)
1339 return BZ_PARAM_ERROR;
1340
1341 strm.bzalloc = NULL;
1342 strm.bzfree = NULL;
1343 strm.opaque = NULL;
1344 ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
1345 if (ret != BZ_OK) return ret;
1346
1347 strm.next_in = source;
1348 strm.next_out = dest;
1349 strm.avail_in = sourceLen;
1350 strm.avail_out = *destLen;
1351
1352 ret = BZ2_bzDecompress ( &strm );
1353 if (ret == BZ_OK) goto output_overflow_or_eof;
1354 if (ret != BZ_STREAM_END) goto errhandler;
1355
1356 /* normal termination */
1357 *destLen -= strm.avail_out;
1358 BZ2_bzDecompressEnd ( &strm );
1359 return BZ_OK;
1360
1361 output_overflow_or_eof:
1362 if (strm.avail_out > 0) {
1363 BZ2_bzDecompressEnd ( &strm );
1364 return BZ_UNEXPECTED_EOF;
1365 } else {
1366 BZ2_bzDecompressEnd ( &strm );
1367 return BZ_OUTBUFF_FULL;
1368 };
1369
1370 errhandler:
1371 BZ2_bzDecompressEnd ( &strm );
1372 return ret;
1373 }
1374
1375
1376 /*---------------------------------------------------*/
1377 /*--
1378 Code contributed by Yoshioka Tsuneo
1379 (QWF00133@niftyserve.or.jp/tsuneo-y@is.aist-nara.ac.jp),
1380 to support better zlib compatibility.
1381 This code is not _officially_ part of libbzip2 (yet);
1382 I haven't tested it, documented it, or considered the
1383 threading-safeness of it.
1384 If this code breaks, please contact both Yoshioka and me.
1385 --*/
1386 /*---------------------------------------------------*/
1387
1388 /*---------------------------------------------------*/
1389 /*--
1390 return version like "0.9.0c".
1391 --*/
1392 const char * BZ_API(BZ2_bzlibVersion)(void)
1393 {
1394 return BZ_VERSION;
1395 }
1396
1397
1398 #ifndef BZ_NO_STDIO
1399 /*---------------------------------------------------*/
1400
1401 #if defined(_WIN32) || defined(OS2) || defined(MSDOS)
1402 # include <fcntl.h>
1403 # include <io.h>
1404 # define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY)
1405 #else
1406 # define SET_BINARY_MODE(file)
1407 #endif
1408 static
1409 BZFILE * bzopen_or_bzdopen
1410 ( const char *path, /* no use when bzdopen */
1411 int fd, /* no use when bzdopen */
1412 const char *mode,
1413 int open_mode) /* bzopen: 0, bzdopen:1 */
1414 {
1415 int bzerr;
1416 char unused[BZ_MAX_UNUSED];
1417 int blockSize100k = 9;
1418 int writing = 0;
1419 char mode2[10] = "";
1420 FILE *fp = NULL;
1421 BZFILE *bzfp = NULL;
1422 int verbosity = 0;
1423 int workFactor = 30;
1424 int smallMode = 0;
1425 int nUnused = 0;
1426
1427 if (mode == NULL) return NULL;
1428 while (*mode) {
1429 switch (*mode) {
1430 case 'r':
1431 writing = 0; break;
1432 case 'w':
1433 writing = 1; break;
1434 case 's':
1435 smallMode = 1; break;
1436 default:
1437 if (isdigit((int)(*mode))) {
1438 blockSize100k = *mode-BZ_HDR_0;
1439 }
1440 }
1441 mode++;
1442 }
1443 strcat(mode2, writing ? "w" : "r" );
1444 strcat(mode2,"b"); /* binary mode */
1445
1446 if (open_mode==0) {
1447 if (path==NULL || strcmp(path,"")==0) {
1448 fp = (writing ? stdout : stdin);
1449 SET_BINARY_MODE(fp);
1450 } else {
1451 fp = fopen(path,mode2);
1452 }
1453 } else {
1454 #ifdef BZ_STRICT_ANSI
1455 fp = NULL;
1456 #else
1457 fp = fdopen(fd,mode2);
1458 #endif
1459 }
1460 if (fp == NULL) return NULL;
1461
1462 if (writing) {
1463 /* Guard against total chaos and anarchy -- JRS */
1464 if (blockSize100k < 1) blockSize100k = 1;
1465 if (blockSize100k > 9) blockSize100k = 9;
1466 bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k,
1467 verbosity,workFactor);
1468 } else {
1469 bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode,
1470 unused,nUnused);
1471 }
1472 if (bzfp == NULL) {
1473 if (fp != stdin && fp != stdout) fclose(fp);
1474 return NULL;
1475 }
1476 return bzfp;
1477 }
1478
1479
1480 /*---------------------------------------------------*/
1481 /*--
1482 open file for read or write.
1483 ex) bzopen("file","w9")
1484 case path="" or NULL => use stdin or stdout.
1485 --*/
1486 BZFILE * BZ_API(BZ2_bzopen)
1487 ( const char *path,
1488 const char *mode )
1489 {
1490 return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
1491 }
1492
1493
1494 /*---------------------------------------------------*/
1495 BZFILE * BZ_API(BZ2_bzdopen)
1496 ( int fd,
1497 const char *mode )
1498 {
1499 return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
1500 }
1501
1502
1503 /*---------------------------------------------------*/
1504 int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
1505 {
1506 int bzerr, nread;
1507 if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
1508 nread = BZ2_bzRead(&bzerr,b,buf,len);
1509 if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
1510 return nread;
1511 } else {
1512 return -1;
1513 }
1514 }
1515
1516
1517 /*---------------------------------------------------*/
1518 int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len )
1519 {
1520 int bzerr;
1521
1522 BZ2_bzWrite(&bzerr,b,buf,len);
1523 if(bzerr == BZ_OK){
1524 return len;
1525 }else{
1526 return -1;
1527 }
1528 }
1529
1530
1531 /*---------------------------------------------------*/
1532 int BZ_API(BZ2_bzflush) (BZFILE *b)
1533 {
1534 /* do nothing now... */
1535 return 0;
1536 }
1537
1538
1539 /*---------------------------------------------------*/
1540 void BZ_API(BZ2_bzclose) (BZFILE* b)
1541 {
1542 int bzerr;
1543 FILE *fp = ((bzFile *)b)->handle;
1544
1545 if (b==NULL) {return;}
1546 if(((bzFile*)b)->writing){
1547 BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
1548 if(bzerr != BZ_OK){
1549 BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
1550 }
1551 }else{
1552 BZ2_bzReadClose(&bzerr,b);
1553 }
1554 if(fp!=stdin && fp!=stdout){
1555 fclose(fp);
1556 }
1557 }
1558
1559
1560 /*---------------------------------------------------*/
1561 /*--
1562 return last error code
1563 --*/
1564 static char *bzerrorstrings[] = {
1565 "OK"
1566 ,"SEQUENCE_ERROR"
1567 ,"PARAM_ERROR"
1568 ,"MEM_ERROR"
1569 ,"DATA_ERROR"
1570 ,"DATA_ERROR_MAGIC"
1571 ,"IO_ERROR"
1572 ,"UNEXPECTED_EOF"
1573 ,"OUTBUFF_FULL"
1574 ,"CONFIG_ERROR"
1575 ,"???" /* for future */
1576 ,"???" /* for future */
1577 ,"???" /* for future */
1578 ,"???" /* for future */
1579 ,"???" /* for future */
1580 ,"???" /* for future */
1581 };
1582
1583
1584 const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum)
1585 {
1586 int err = ((bzFile *)b)->lastErr;
1587
1588 if(err>0) err = 0;
1589 *errnum = err;
1590 return bzerrorstrings[err*-1];
1591 }
1592 #endif
This tree is no more updated. Use official barebox repo to get latest mini2440 code.