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