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