mz_adler32: 41| 1.64k|{ 42| 1.64k| mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16); 43| 1.64k| size_t block_len = buf_len % 5552; 44| 1.64k| if (!ptr) ------------------ | Branch (44:9): [True: 0, False: 1.64k] ------------------ 45| 0| return MZ_ADLER32_INIT; ------------------ | | 240| 0|#define MZ_ADLER32_INIT (1) ------------------ 46| 17.9k| while (buf_len) ------------------ | Branch (46:12): [True: 16.3k, False: 1.64k] ------------------ 47| 16.3k| { 48| 11.1M| for (i = 0; i + 7 < block_len; i += 8, ptr += 8) ------------------ | Branch (48:21): [True: 11.1M, False: 16.3k] ------------------ 49| 11.1M| { 50| 11.1M| s1 += ptr[0], s2 += s1; 51| 11.1M| s1 += ptr[1], s2 += s1; 52| 11.1M| s1 += ptr[2], s2 += s1; 53| 11.1M| s1 += ptr[3], s2 += s1; 54| 11.1M| s1 += ptr[4], s2 += s1; 55| 11.1M| s1 += ptr[5], s2 += s1; 56| 11.1M| s1 += ptr[6], s2 += s1; 57| 11.1M| s1 += ptr[7], s2 += s1; 58| 11.1M| } 59| 18.0k| for (; i < block_len; ++i) ------------------ | Branch (59:16): [True: 1.72k, False: 16.3k] ------------------ 60| 1.72k| s1 += *ptr++, s2 += s1; 61| 16.3k| s1 %= 65521U, s2 %= 65521U; 62| 16.3k| buf_len -= block_len; 63| 16.3k| block_len = 5552; 64| 16.3k| } 65| 1.64k| return (s2 << 16) + s1; 66| 1.64k|} miniz_def_alloc_func: 168| 1.09k|{ 169| 1.09k| (void)opaque, (void)items, (void)size; 170| 1.09k| return MZ_MALLOC(items * size); ------------------ | | 589| 1.09k|#define MZ_MALLOC(x) malloc(x) ------------------ 171| 1.09k|} miniz_def_free_func: 173| 1.09k|{ 174| 1.09k| (void)opaque, (void)address; 175| 1.09k| MZ_FREE(address); ------------------ | | 590| 1.09k|#define MZ_FREE(x) free(x) ------------------ 176| 1.09k|} mz_deflateInit: 193| 547|{ 194| 547| return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY); ------------------ | | 259| 547|#define MZ_DEFLATED 8 ------------------ return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY); ------------------ | | 314| 547|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ 195| 547|} mz_deflateInit2: 198| 547|{ 199| 547| tdefl_compressor *pComp; 200| 547| mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy); 201| | 202| 547| if (!pStream) ------------------ | Branch (202:9): [True: 0, False: 547] ------------------ 203| 0| return MZ_STREAM_ERROR; 204| 547| if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) ------------------ | | 259| 547|#define MZ_DEFLATED 8 ------------------ if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) ------------------ | | 314| 547|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) ------------------ | | 314| 0|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ | Branch (204:9): [True: 0, False: 547] | Branch (204:37): [True: 0, False: 547] | Branch (204:56): [True: 0, False: 547] | Branch (204:77): [True: 0, False: 547] | Branch (204:120): [True: 0, False: 0] ------------------ 205| 0| return MZ_PARAM_ERROR; 206| | 207| 547| pStream->data_type = 0; 208| 547| pStream->adler = MZ_ADLER32_INIT; ------------------ | | 240| 547|#define MZ_ADLER32_INIT (1) ------------------ 209| 547| pStream->msg = NULL; 210| 547| pStream->reserved = 0; 211| 547| pStream->total_in = 0; 212| 547| pStream->total_out = 0; 213| 547| if (!pStream->zalloc) ------------------ | Branch (213:9): [True: 547, False: 0] ------------------ 214| 547| pStream->zalloc = miniz_def_alloc_func; 215| 547| if (!pStream->zfree) ------------------ | Branch (215:9): [True: 547, False: 0] ------------------ 216| 547| pStream->zfree = miniz_def_free_func; 217| | 218| 547| pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor)); 219| 547| if (!pComp) ------------------ | Branch (219:9): [True: 0, False: 547] ------------------ 220| 0| return MZ_MEM_ERROR; 221| | 222| 547| pStream->state = (struct mz_internal_state *)pComp; 223| | 224| 547| if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY) ------------------ | Branch (224:9): [True: 0, False: 547] ------------------ 225| 0| { 226| 0| mz_deflateEnd(pStream); 227| 0| return MZ_PARAM_ERROR; 228| 0| } 229| | 230| 547| return MZ_OK; 231| 547|} mz_deflate: 243| 1.64k|{ 244| 1.64k| size_t in_bytes, out_bytes; 245| 1.64k| mz_ulong orig_total_in, orig_total_out; 246| 1.64k| int mz_status = MZ_OK; 247| | 248| 1.64k| if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) ------------------ | Branch (248:9): [True: 0, False: 1.64k] | Branch (248:23): [True: 0, False: 1.64k] | Branch (248:44): [True: 0, False: 1.64k] | Branch (248:59): [True: 0, False: 1.64k] | Branch (248:82): [True: 0, False: 1.64k] ------------------ 249| 0| return MZ_STREAM_ERROR; 250| 1.64k| if (!pStream->avail_out) ------------------ | Branch (250:9): [True: 0, False: 1.64k] ------------------ 251| 0| return MZ_BUF_ERROR; 252| | 253| 1.64k| if (flush == MZ_PARTIAL_FLUSH) ------------------ | Branch (253:9): [True: 0, False: 1.64k] ------------------ 254| 0| flush = MZ_SYNC_FLUSH; 255| | 256| 1.64k| if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE) ------------------ | Branch (256:9): [True: 0, False: 1.64k] ------------------ 257| 0| return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR; ------------------ | Branch (257:16): [True: 0, False: 0] ------------------ 258| | 259| 1.64k| orig_total_in = pStream->total_in; 260| 1.64k| orig_total_out = pStream->total_out; 261| 1.64k| for (;;) 262| 1.64k| { 263| 1.64k| tdefl_status defl_status; 264| 1.64k| in_bytes = pStream->avail_in; 265| 1.64k| out_bytes = pStream->avail_out; 266| | 267| 1.64k| defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush); 268| 1.64k| pStream->next_in += (mz_uint)in_bytes; 269| 1.64k| pStream->avail_in -= (mz_uint)in_bytes; 270| 1.64k| pStream->total_in += (mz_uint)in_bytes; 271| 1.64k| pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state); 272| | 273| 1.64k| pStream->next_out += (mz_uint)out_bytes; 274| 1.64k| pStream->avail_out -= (mz_uint)out_bytes; 275| 1.64k| pStream->total_out += (mz_uint)out_bytes; 276| | 277| 1.64k| if (defl_status < 0) ------------------ | Branch (277:13): [True: 0, False: 1.64k] ------------------ 278| 0| { 279| 0| mz_status = MZ_STREAM_ERROR; 280| 0| break; 281| 0| } 282| 1.64k| else if (defl_status == TDEFL_STATUS_DONE) ------------------ | Branch (282:18): [True: 547, False: 1.09k] ------------------ 283| 547| { 284| 547| mz_status = MZ_STREAM_END; 285| 547| break; 286| 547| } 287| 1.09k| else if (!pStream->avail_out) ------------------ | Branch (287:18): [True: 0, False: 1.09k] ------------------ 288| 0| break; 289| 1.09k| else if ((!pStream->avail_in) && (flush != MZ_FINISH)) ------------------ | Branch (289:18): [True: 1.09k, False: 0] | Branch (289:42): [True: 1.09k, False: 0] ------------------ 290| 1.09k| { 291| 1.09k| if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) ------------------ | Branch (291:17): [True: 0, False: 1.09k] | Branch (291:28): [True: 547, False: 547] | Branch (291:68): [True: 0, False: 547] ------------------ 292| 547| break; 293| 547| return MZ_BUF_ERROR; /* Can't make forward progress without some input. 294| | */ 295| 1.09k| } 296| 1.64k| } 297| 1.09k| return mz_status; 298| 1.64k|} mz_deflateEnd: 301| 547|{ 302| 547| if (!pStream) ------------------ | Branch (302:9): [True: 0, False: 547] ------------------ 303| 0| return MZ_STREAM_ERROR; 304| 547| if (pStream->state) ------------------ | Branch (304:9): [True: 547, False: 0] ------------------ 305| 547| { 306| 547| pStream->zfree(pStream->opaque, pStream->state); 307| 547| pStream->state = NULL; 308| 547| } 309| 547| return MZ_OK; 310| 547|} mz_inflateInit2: 373| 547|{ 374| 547| inflate_state *pDecomp; 375| 547| if (!pStream) ------------------ | Branch (375:9): [True: 0, False: 547] ------------------ 376| 0| return MZ_STREAM_ERROR; 377| 547| if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) ------------------ | | 314| 547|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) ------------------ | | 314| 0|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ | Branch (377:9): [True: 0, False: 547] | Branch (377:52): [True: 0, False: 0] ------------------ 378| 0| return MZ_PARAM_ERROR; 379| | 380| 547| pStream->data_type = 0; 381| 547| pStream->adler = 0; 382| 547| pStream->msg = NULL; 383| 547| pStream->total_in = 0; 384| 547| pStream->total_out = 0; 385| 547| pStream->reserved = 0; 386| 547| if (!pStream->zalloc) ------------------ | Branch (386:9): [True: 547, False: 0] ------------------ 387| 547| pStream->zalloc = miniz_def_alloc_func; 388| 547| if (!pStream->zfree) ------------------ | Branch (388:9): [True: 547, False: 0] ------------------ 389| 547| pStream->zfree = miniz_def_free_func; 390| | 391| 547| pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state)); 392| 547| if (!pDecomp) ------------------ | Branch (392:9): [True: 0, False: 547] ------------------ 393| 0| return MZ_MEM_ERROR; 394| | 395| 547| pStream->state = (struct mz_internal_state *)pDecomp; 396| | 397| 547| tinfl_init(&pDecomp->m_decomp); ------------------ | | 918| 547| do \ | | 919| 547| { \ | | 920| 547| (r)->m_state = 0; \ | | 921| 547| } \ | | 922| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 398| 547| pDecomp->m_dict_ofs = 0; 399| 547| pDecomp->m_dict_avail = 0; 400| 547| pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; 401| 547| pDecomp->m_first_call = 1; 402| 547| pDecomp->m_has_flushed = 0; 403| 547| pDecomp->m_window_bits = window_bits; 404| | 405| 547| return MZ_OK; 406| 547|} mz_inflateInit: 409| 547|{ 410| 547| return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS); ------------------ | | 314| 547|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ 411| 547|} mz_inflate: 440| 547|{ 441| 547| inflate_state *pState; 442| 547| mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32; 443| 547| size_t in_bytes, out_bytes, orig_avail_in; 444| 547| tinfl_status status; 445| | 446| 547| if ((!pStream) || (!pStream->state)) ------------------ | Branch (446:9): [True: 0, False: 547] | Branch (446:23): [True: 0, False: 547] ------------------ 447| 0| return MZ_STREAM_ERROR; 448| 547| if (flush == MZ_PARTIAL_FLUSH) ------------------ | Branch (448:9): [True: 0, False: 547] ------------------ 449| 0| flush = MZ_SYNC_FLUSH; 450| 547| if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) ------------------ | Branch (450:9): [True: 0, False: 547] | Branch (450:20): [True: 0, False: 0] | Branch (450:48): [True: 0, False: 0] ------------------ 451| 0| return MZ_STREAM_ERROR; 452| | 453| 547| pState = (inflate_state *)pStream->state; 454| 547| if (pState->m_window_bits > 0) ------------------ | Branch (454:9): [True: 547, False: 0] ------------------ 455| 547| decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER; 456| 547| orig_avail_in = pStream->avail_in; 457| | 458| 547| first_call = pState->m_first_call; 459| 547| pState->m_first_call = 0; 460| 547| if (pState->m_last_status < 0) ------------------ | Branch (460:9): [True: 0, False: 547] ------------------ 461| 0| return MZ_DATA_ERROR; 462| | 463| 547| if (pState->m_has_flushed && (flush != MZ_FINISH)) ------------------ | Branch (463:9): [True: 0, False: 547] | Branch (463:34): [True: 0, False: 0] ------------------ 464| 0| return MZ_STREAM_ERROR; 465| 547| pState->m_has_flushed |= (flush == MZ_FINISH); 466| | 467| 547| if ((flush == MZ_FINISH) && (first_call)) ------------------ | Branch (467:9): [True: 0, False: 547] | Branch (467:33): [True: 0, False: 0] ------------------ 468| 0| { 469| | /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */ 470| 0| decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF; 471| 0| in_bytes = pStream->avail_in; 472| 0| out_bytes = pStream->avail_out; 473| 0| status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags); 474| 0| pState->m_last_status = status; 475| 0| pStream->next_in += (mz_uint)in_bytes; 476| 0| pStream->avail_in -= (mz_uint)in_bytes; 477| 0| pStream->total_in += (mz_uint)in_bytes; 478| 0| pStream->adler = tinfl_get_adler32(&pState->m_decomp); ------------------ | | 923| 0|#define tinfl_get_adler32(r) (r)->m_check_adler32 ------------------ 479| 0| pStream->next_out += (mz_uint)out_bytes; 480| 0| pStream->avail_out -= (mz_uint)out_bytes; 481| 0| pStream->total_out += (mz_uint)out_bytes; 482| | 483| 0| if (status < 0) ------------------ | Branch (483:13): [True: 0, False: 0] ------------------ 484| 0| return MZ_DATA_ERROR; 485| 0| else if (status != TINFL_STATUS_DONE) ------------------ | Branch (485:18): [True: 0, False: 0] ------------------ 486| 0| { 487| 0| pState->m_last_status = TINFL_STATUS_FAILED; 488| 0| return MZ_BUF_ERROR; 489| 0| } 490| 0| return MZ_STREAM_END; 491| 0| } 492| | /* flush != MZ_FINISH then we must assume there's more input. */ 493| 547| if (flush != MZ_FINISH) ------------------ | Branch (493:9): [True: 547, False: 0] ------------------ 494| 547| decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT; 495| | 496| 547| if (pState->m_dict_avail) ------------------ | Branch (496:9): [True: 0, False: 547] ------------------ 497| 0| { 498| 0| n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); ------------------ | | 595| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 0, False: 0] | | ------------------ ------------------ 499| 0| memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); 500| 0| pStream->next_out += n; 501| 0| pStream->avail_out -= n; 502| 0| pStream->total_out += n; 503| 0| pState->m_dict_avail -= n; 504| 0| pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); ------------------ | | 880| 0|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 505| 0| return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; ------------------ | Branch (505:17): [True: 0, False: 0] | Branch (505:65): [True: 0, False: 0] ------------------ 506| 0| } 507| | 508| 547| for (;;) 509| 3.10k| { 510| 3.10k| in_bytes = pStream->avail_in; 511| 3.10k| out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs; ------------------ | | 880| 3.10k|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 512| | 513| 3.10k| status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags); 514| 3.10k| pState->m_last_status = status; 515| | 516| 3.10k| pStream->next_in += (mz_uint)in_bytes; 517| 3.10k| pStream->avail_in -= (mz_uint)in_bytes; 518| 3.10k| pStream->total_in += (mz_uint)in_bytes; 519| 3.10k| pStream->adler = tinfl_get_adler32(&pState->m_decomp); ------------------ | | 923| 3.10k|#define tinfl_get_adler32(r) (r)->m_check_adler32 ------------------ 520| | 521| 3.10k| pState->m_dict_avail = (mz_uint)out_bytes; 522| | 523| 3.10k| n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); ------------------ | | 595| 3.10k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 2.56k, False: 547] | | ------------------ ------------------ 524| 3.10k| memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); 525| 3.10k| pStream->next_out += n; 526| 3.10k| pStream->avail_out -= n; 527| 3.10k| pStream->total_out += n; 528| 3.10k| pState->m_dict_avail -= n; 529| 3.10k| pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); ------------------ | | 880| 3.10k|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 530| | 531| 3.10k| if (status < 0) ------------------ | Branch (531:13): [True: 0, False: 3.10k] ------------------ 532| 0| return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */ 533| 3.10k| else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) ------------------ | Branch (533:18): [True: 0, False: 3.10k] | Branch (533:63): [True: 0, False: 0] ------------------ 534| 0| return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */ 535| 3.10k| else if (flush == MZ_FINISH) ------------------ | Branch (535:18): [True: 0, False: 3.10k] ------------------ 536| 0| { 537| | /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */ 538| 0| if (status == TINFL_STATUS_DONE) ------------------ | Branch (538:17): [True: 0, False: 0] ------------------ 539| 0| return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END; ------------------ | Branch (539:24): [True: 0, False: 0] ------------------ 540| | /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong. */ 541| 0| else if (!pStream->avail_out) ------------------ | Branch (541:22): [True: 0, False: 0] ------------------ 542| 0| return MZ_BUF_ERROR; 543| 0| } 544| 3.10k| else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) ------------------ | Branch (544:18): [True: 547, False: 2.56k] | Branch (544:51): [True: 0, False: 2.56k] | Branch (544:75): [True: 0, False: 2.56k] | Branch (544:100): [True: 0, False: 2.56k] ------------------ 545| 547| break; 546| 3.10k| } 547| | 548| 547| return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; ------------------ | Branch (548:13): [True: 547, False: 0] | Branch (548:46): [True: 547, False: 0] ------------------ 549| 547|} mz_inflateEnd: 552| 547|{ 553| 547| if (!pStream) ------------------ | Branch (553:9): [True: 0, False: 547] ------------------ 554| 0| return MZ_STREAM_ERROR; 555| 547| if (pStream->state) ------------------ | Branch (555:9): [True: 547, False: 0] ------------------ 556| 547| { 557| 547| pStream->zfree(pStream->opaque, pStream->state); 558| 547| pStream->state = NULL; 559| 547| } 560| 547| return MZ_OK; 561| 547|} tdefl_compress: 1919| 1.64k|{ 1920| 1.64k| if (!d) ------------------ | Branch (1920:9): [True: 0, False: 1.64k] ------------------ 1921| 0| { 1922| 0| if (pIn_buf_size) ------------------ | Branch (1922:13): [True: 0, False: 0] ------------------ 1923| 0| *pIn_buf_size = 0; 1924| 0| if (pOut_buf_size) ------------------ | Branch (1924:13): [True: 0, False: 0] ------------------ 1925| 0| *pOut_buf_size = 0; 1926| 0| return TDEFL_STATUS_BAD_PARAM; 1927| 0| } 1928| | 1929| 1.64k| d->m_pIn_buf = pIn_buf; 1930| 1.64k| d->m_pIn_buf_size = pIn_buf_size; 1931| 1.64k| d->m_pOut_buf = pOut_buf; 1932| 1.64k| d->m_pOut_buf_size = pOut_buf_size; 1933| 1.64k| d->m_pSrc = (const mz_uint8 *)(pIn_buf); 1934| 1.64k| d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; ------------------ | Branch (1934:25): [True: 1.64k, False: 0] ------------------ 1935| 1.64k| d->m_out_buf_ofs = 0; 1936| 1.64k| d->m_flush = flush; 1937| | 1938| 1.64k| if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) || ------------------ | Branch (1938:9): [True: 0, False: 1.64k] | Branch (1938:43): [True: 1.64k, False: 0] | Branch (1938:65): [True: 0, False: 0] | Branch (1938:94): [True: 0, False: 1.64k] ------------------ 1939| 1.64k| (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) ------------------ | Branch (1939:10): [True: 0, False: 1.64k] | Branch (1939:34): [True: 0, False: 0] | Branch (1939:63): [True: 1.64k, False: 0] | Branch (1939:79): [True: 547, False: 1.09k] | Branch (1939:96): [True: 0, False: 547] | Branch (1939:110): [True: 1.64k, False: 0] | Branch (1939:127): [True: 1.64k, False: 0] | Branch (1939:145): [True: 0, False: 1.64k] ------------------ 1940| 0| { 1941| 0| if (pIn_buf_size) ------------------ | Branch (1941:13): [True: 0, False: 0] ------------------ 1942| 0| *pIn_buf_size = 0; 1943| 0| if (pOut_buf_size) ------------------ | Branch (1943:13): [True: 0, False: 0] ------------------ 1944| 0| *pOut_buf_size = 0; 1945| 0| return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM); 1946| 0| } 1947| 1.64k| d->m_wants_to_finish |= (flush == TDEFL_FINISH); 1948| | 1949| 1.64k| if ((d->m_output_flush_remaining) || (d->m_finished)) ------------------ | Branch (1949:9): [True: 0, False: 1.64k] | Branch (1949:42): [True: 0, False: 1.64k] ------------------ 1950| 0| return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); 1951| | 1952| |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN 1953| | if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) && 1954| | ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) && 1955| | ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0)) 1956| | { 1957| | if (!tdefl_compress_fast(d)) 1958| | return d->m_prev_return_status; 1959| | } 1960| | else 1961| |#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */ 1962| 1.64k| { 1963| 1.64k| if (!tdefl_compress_normal(d)) ------------------ | Branch (1963:13): [True: 0, False: 1.64k] ------------------ 1964| 0| return d->m_prev_return_status; 1965| 1.64k| } 1966| | 1967| 1.64k| if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf)) ------------------ | Branch (1967:9): [True: 1.64k, False: 0] | Branch (1967:77): [True: 1.64k, False: 0] ------------------ 1968| 1.64k| d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf); 1969| | 1970| 1.64k| if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) ------------------ | Branch (1970:9): [True: 547, False: 1.09k] | Branch (1970:20): [True: 547, False: 0] | Branch (1970:46): [True: 547, False: 0] | Branch (1970:70): [True: 547, False: 0] ------------------ 1971| 547| { 1972| 547| if (tdefl_flush_block(d, flush) < 0) ------------------ | Branch (1972:13): [True: 0, False: 547] ------------------ 1973| 0| return d->m_prev_return_status; 1974| 547| d->m_finished = (flush == TDEFL_FINISH); 1975| 547| if (flush == TDEFL_FULL_FLUSH) ------------------ | Branch (1975:13): [True: 0, False: 547] ------------------ 1976| 0| { 1977| 0| MZ_CLEAR_ARR(d->m_hash); ------------------ | | 597| 0|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 1978| 0| MZ_CLEAR_ARR(d->m_next); ------------------ | | 597| 0|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 1979| 0| d->m_dict_size = 0; 1980| 0| } 1981| 547| } 1982| | 1983| 1.64k| return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); 1984| 1.64k|} tdefl_init: 1993| 547|{ 1994| 547| d->m_pPut_buf_func = pPut_buf_func; 1995| 547| d->m_pPut_buf_user = pPut_buf_user; 1996| 547| d->m_flags = (mz_uint)(flags); 1997| 547| d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; 1998| 547| d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0; 1999| 547| d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3; 2000| 547| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (2000:9): [True: 547, False: 0] ------------------ 2001| 547| MZ_CLEAR_ARR(d->m_hash); ------------------ | | 597| 547|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2002| 547| d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0; 2003| 547| d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0; 2004| 547| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 2005| 547| d->m_pLZ_flags = d->m_lz_code_buf; 2006| 547| *d->m_pLZ_flags = 0; 2007| 547| d->m_num_flags_left = 8; 2008| 547| d->m_pOutput_buf = d->m_output_buf; 2009| 547| d->m_pOutput_buf_end = d->m_output_buf; 2010| 547| d->m_prev_return_status = TDEFL_STATUS_OKAY; 2011| 547| d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; 2012| 547| d->m_adler32 = 1; 2013| 547| d->m_pIn_buf = NULL; 2014| 547| d->m_pOut_buf = NULL; 2015| 547| d->m_pIn_buf_size = NULL; 2016| 547| d->m_pOut_buf_size = NULL; 2017| 547| d->m_flush = TDEFL_NO_FLUSH; 2018| 547| d->m_pSrc = NULL; 2019| 547| d->m_src_buf_left = 0; 2020| 547| d->m_out_buf_ofs = 0; 2021| 547| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (2021:9): [True: 547, False: 0] ------------------ 2022| 547| MZ_CLEAR_ARR(d->m_dict); ------------------ | | 597| 547|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2023| 547| memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 2024| 547| memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 2025| 547| return TDEFL_STATUS_OKAY; 2026| 547|} tdefl_get_adler32: 2034| 1.64k|{ 2035| 1.64k| return d->m_adler32; 2036| 1.64k|} tdefl_create_comp_flags_from_zip_params: 2117| 547|{ 2118| 547| mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); ------------------ | | 595| 547|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 0, False: 547] | | ------------------ ------------------ | Branch (2118:45): [True: 547, False: 0] | Branch (2118:101): [True: 0, False: 547] ------------------ 2119| 547| if (window_bits > 0) ------------------ | Branch (2119:9): [True: 547, False: 0] ------------------ 2120| 547| comp_flags |= TDEFL_WRITE_ZLIB_HEADER; 2121| | 2122| 547| if (!level) ------------------ | Branch (2122:9): [True: 0, False: 547] ------------------ 2123| 0| comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; 2124| 547| else if (strategy == MZ_FILTERED) ------------------ | Branch (2124:14): [True: 0, False: 547] ------------------ 2125| 0| comp_flags |= TDEFL_FILTER_MATCHES; 2126| 547| else if (strategy == MZ_HUFFMAN_ONLY) ------------------ | Branch (2126:14): [True: 0, False: 547] ------------------ 2127| 0| comp_flags &= ~TDEFL_MAX_PROBES_MASK; 2128| 547| else if (strategy == MZ_FIXED) ------------------ | Branch (2128:14): [True: 0, False: 547] ------------------ 2129| 0| comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS; 2130| 547| else if (strategy == MZ_RLE) ------------------ | Branch (2130:14): [True: 0, False: 547] ------------------ 2131| 0| comp_flags |= TDEFL_RLE_MATCHES; 2132| | 2133| 547| return comp_flags; 2134| 547|} tinfl_decompress: 2438| 3.10k|{ 2439| 3.10k| static const mz_uint16 s_length_base[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 }; 2440| 3.10k| static const mz_uint8 s_length_extra[31] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0 }; 2441| 3.10k| static const mz_uint16 s_dist_base[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0 }; 2442| 3.10k| static const mz_uint8 s_dist_extra[32] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 }; 2443| 3.10k| static const mz_uint8 s_length_dezigzag[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; 2444| 3.10k| static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 }; 2445| | 2446| 3.10k| mz_int16 *pTrees[3]; 2447| 3.10k| mz_uint8 *pCode_sizes[3]; 2448| | 2449| 3.10k| tinfl_status status = TINFL_STATUS_FAILED; 2450| 3.10k| mz_uint32 num_bits, dist, counter, num_extra; 2451| 3.10k| tinfl_bit_buf_t bit_buf; 2452| 3.10k| const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size; 2453| 3.10k| mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next ? pOut_buf_next + *pOut_buf_size : NULL; ------------------ | Branch (2453:67): [True: 3.10k, False: 0] ------------------ 2454| 3.10k| size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start; ------------------ | Branch (2454:32): [True: 0, False: 3.10k] ------------------ 2455| | 2456| | /* Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter). */ 2457| 3.10k| if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) ------------------ | Branch (2457:9): [True: 0, False: 3.10k] | Branch (2457:58): [True: 0, False: 3.10k] ------------------ 2458| 0| { 2459| 0| *pIn_buf_size = *pOut_buf_size = 0; 2460| 0| return TINFL_STATUS_BAD_PARAM; 2461| 0| } 2462| | 2463| 3.10k| pTrees[0] = r->m_tree_0; 2464| 3.10k| pTrees[1] = r->m_tree_1; 2465| 3.10k| pTrees[2] = r->m_tree_2; 2466| 3.10k| pCode_sizes[0] = r->m_code_size_0; 2467| 3.10k| pCode_sizes[1] = r->m_code_size_1; 2468| 3.10k| pCode_sizes[2] = r->m_code_size_2; 2469| | 2470| 3.10k| num_bits = r->m_num_bits; 2471| 3.10k| bit_buf = r->m_bit_buf; 2472| 3.10k| dist = r->m_dist; 2473| 3.10k| counter = r->m_counter; 2474| 3.10k| num_extra = r->m_num_extra; 2475| 3.10k| dist_from_out_buf_start = r->m_dist_from_out_buf_start; 2476| 3.10k| TINFL_CR_BEGIN ------------------ | | 2292| 6.21k| switch (r->m_state) \ | | ------------------ | | | Branch (2292:13): [True: 0, False: 3.10k] | | ------------------ | | 2293| 6.21k| { \ | | 2294| 547| case 0: | | ------------------ | | | Branch (2294:9): [True: 547, False: 2.56k] | | ------------------ ------------------ 2477| | 2478| 547| bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; 2479| 547| r->m_z_adler32 = r->m_check_adler32 = 1; 2480| 547| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) ------------------ | Branch (2480:9): [True: 547, False: 0] ------------------ 2481| 547| { 2482| 547| TINFL_GET_BYTE(1, r->m_zhdr0); ------------------ | | 2316| 547| do \ | | 2317| 547| { \ | | 2318| 547| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (2318:16): [True: 0, False: 547] | | ------------------ | | 2319| 547| { \ | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | ------------------ | | | | | Branch (2298:18): [True: 0, False: 0] | | | | ------------------ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2321| 0| } \ | | 2322| 547| c = *pIn_buf_cur++; \ | | 2323| 547| } \ | | 2324| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2483| 547| TINFL_GET_BYTE(2, r->m_zhdr1); ------------------ | | 2316| 547| do \ | | 2317| 547| { \ | | 2318| 547| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (2318:16): [True: 0, False: 547] | | ------------------ | | 2319| 547| { \ | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | ------------------ | | | | | Branch (2298:18): [True: 0, False: 0] | | | | ------------------ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2321| 0| } \ | | 2322| 547| c = *pIn_buf_cur++; \ | | 2323| 547| } \ | | 2324| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2484| 547| counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); ------------------ | Branch (2484:20): [True: 0, False: 547] | Branch (2484:67): [True: 0, False: 547] | Branch (2484:88): [True: 0, False: 547] ------------------ 2485| 547| if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) ------------------ | Branch (2485:13): [True: 547, False: 0] ------------------ 2486| 547| counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4))))); ------------------ | Branch (2486:25): [True: 0, False: 547] | Branch (2486:72): [True: 0, False: 547] ------------------ 2487| 547| if (counter) ------------------ | Branch (2487:13): [True: 0, False: 547] ------------------ 2488| 0| { 2489| 0| TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); ------------------ | | 2305| 0| do \ | | 2306| 0| { \ | | 2307| 0| for (;;) \ | | 2308| 0| { \ | | 2309| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 0| } \ | | 2311| 0| } \ | | 2312| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2490| 0| } 2491| 547| } 2492| | 2493| 547| do 2494| 547| { 2495| 547| TINFL_GET_BITS(3, r->m_final, 3); ------------------ | | 2346| 547| do \ | | 2347| 547| { \ | | 2348| 547| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 547, False: 0] | | ------------------ | | 2349| 547| { \ | | 2350| 547| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 547| do \ | | | | 2328| 547| { \ | | | | 2329| 547| mz_uint c; \ | | | | 2330| 547| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 547| do \ | | | | | | 2317| 547| { \ | | | | | | 2318| 547| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 547] | | | | | | ------------------ | | | | | | 2319| 547| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 547| c = *pIn_buf_cur++; \ | | | | | | 2323| 547| } \ | | | | | | 2324| 547| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 547| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 547| num_bits += 8; \ | | | | 2333| 547| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 547] | | | | ------------------ | | ------------------ | | 2351| 547| } \ | | 2352| 547| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 547| bit_buf >>= (n); \ | | 2354| 547| num_bits -= (n); \ | | 2355| 547| } \ | | 2356| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2496| 547| r->m_type = r->m_final >> 1; 2497| 547| if (r->m_type == 0) ------------------ | Branch (2497:13): [True: 0, False: 547] ------------------ 2498| 0| { 2499| 0| TINFL_SKIP_BITS(5, num_bits & 7); ------------------ | | 2335| 0| do \ | | 2336| 0| { \ | | 2337| 0| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2337:13): [True: 0, False: 0] | | ------------------ | | 2338| 0| { \ | | 2339| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2340| 0| } \ | | 2341| 0| bit_buf >>= (n); \ | | 2342| 0| num_bits -= (n); \ | | 2343| 0| } \ | | 2344| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2500| 0| for (counter = 0; counter < 4; ++counter) ------------------ | Branch (2500:31): [True: 0, False: 0] ------------------ 2501| 0| { 2502| 0| if (num_bits) ------------------ | Branch (2502:21): [True: 0, False: 0] ------------------ 2503| 0| TINFL_GET_BITS(6, r->m_raw_header[counter], 8); ------------------ | | 2346| 0| do \ | | 2347| 0| { \ | | 2348| 0| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 0] | | ------------------ | | 2349| 0| { \ | | 2350| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2351| 0| } \ | | 2352| 0| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 0| bit_buf >>= (n); \ | | 2354| 0| num_bits -= (n); \ | | 2355| 0| } \ | | 2356| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2504| 0| else 2505| 0| TINFL_GET_BYTE(7, r->m_raw_header[counter]); ------------------ | | 2316| 0| do \ | | 2317| 0| { \ | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (2318:16): [True: 0, False: 0] | | ------------------ | | 2319| 0| { \ | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | ------------------ | | | | | Branch (2298:18): [True: 0, False: 0] | | | | ------------------ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2321| 0| } \ | | 2322| 0| c = *pIn_buf_cur++; \ | | 2323| 0| } \ | | 2324| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2506| 0| } 2507| 0| if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) ------------------ | Branch (2507:17): [True: 0, False: 0] ------------------ 2508| 0| { 2509| 0| TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); ------------------ | | 2305| 0| do \ | | 2306| 0| { \ | | 2307| 0| for (;;) \ | | 2308| 0| { \ | | 2309| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 0| } \ | | 2311| 0| } \ | | 2312| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2510| 0| } 2511| 0| while ((counter) && (num_bits)) ------------------ | Branch (2511:20): [True: 0, False: 0] | Branch (2511:33): [True: 0, False: 0] ------------------ 2512| 0| { 2513| 0| TINFL_GET_BITS(51, dist, 8); ------------------ | | 2346| 0| do \ | | 2347| 0| { \ | | 2348| 0| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 0] | | ------------------ | | 2349| 0| { \ | | 2350| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2351| 0| } \ | | 2352| 0| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 0| bit_buf >>= (n); \ | | 2354| 0| num_bits -= (n); \ | | 2355| 0| } \ | | 2356| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2514| 0| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2514:24): [True: 0, False: 0] ------------------ 2515| 0| { 2516| 0| TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 2296| 0| do \ | | 2297| 0| { \ | | 2298| 0| status = result; \ | | 2299| 0| r->m_state = state_index; \ | | 2300| 0| goto common_exit; \ | | 2301| 0| case state_index:; \ | | ------------------ | | | Branch (2301:9): [True: 0, False: 3.10k] | | ------------------ | | 2302| 0| } \ | | 2303| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2517| 0| } 2518| 0| *pOut_buf_cur++ = (mz_uint8)dist; 2519| 0| counter--; 2520| 0| } 2521| 0| while (counter) ------------------ | Branch (2521:20): [True: 0, False: 0] ------------------ 2522| 0| { 2523| 0| size_t n; 2524| 0| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2524:24): [True: 0, False: 0] ------------------ 2525| 0| { 2526| 0| TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 2296| 0| do \ | | 2297| 0| { \ | | 2298| 0| status = result; \ | | 2299| 0| r->m_state = state_index; \ | | 2300| 0| goto common_exit; \ | | 2301| 0| case state_index:; \ | | ------------------ | | | Branch (2301:9): [True: 0, False: 3.10k] | | ------------------ | | 2302| 0| } \ | | 2303| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2527| 0| } 2528| 0| while (pIn_buf_cur >= pIn_buf_end) ------------------ | Branch (2528:24): [True: 0, False: 0] ------------------ 2529| 0| { 2530| 0| TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); ------------------ | | 2296| 0| do \ | | 2297| 0| { \ | | 2298| 0| status = result; \ | | ------------------ | | | Branch (2298:18): [True: 0, False: 0] | | ------------------ | | 2299| 0| r->m_state = state_index; \ | | 2300| 0| goto common_exit; \ | | 2301| 0| case state_index:; \ | | ------------------ | | | Branch (2301:9): [True: 0, False: 3.10k] | | ------------------ | | 2302| 0| } \ | | 2303| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2531| 0| } 2532| 0| n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter); ------------------ | | 595| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 0, False: 0] | | | Branch (595:25): [True: 0, False: 0] | | | Branch (595:38): [True: 0, False: 0] | | ------------------ ------------------ 2533| 0| TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); ------------------ | | 2288| 0|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 2534| 0| pIn_buf_cur += n; 2535| 0| pOut_buf_cur += n; 2536| 0| counter -= (mz_uint)n; 2537| 0| } 2538| 0| } 2539| 547| else if (r->m_type == 3) ------------------ | Branch (2539:18): [True: 0, False: 547] ------------------ 2540| 0| { 2541| 0| TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED); ------------------ | | 2305| 0| do \ | | 2306| 0| { \ | | 2307| 0| for (;;) \ | | 2308| 0| { \ | | 2309| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 0| } \ | | 2311| 0| } \ | | 2312| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2542| 0| } 2543| 547| else 2544| 547| { 2545| 547| if (r->m_type == 1) ------------------ | Branch (2545:17): [True: 0, False: 547] ------------------ 2546| 0| { 2547| 0| mz_uint8 *p = r->m_code_size_0; 2548| 0| mz_uint i; 2549| 0| r->m_table_sizes[0] = 288; 2550| 0| r->m_table_sizes[1] = 32; 2551| 0| TINFL_MEMSET(r->m_code_size_1, 5, 32); ------------------ | | 2289| 0|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 2552| 0| for (i = 0; i <= 143; ++i) ------------------ | Branch (2552:29): [True: 0, False: 0] ------------------ 2553| 0| *p++ = 8; 2554| 0| for (; i <= 255; ++i) ------------------ | Branch (2554:24): [True: 0, False: 0] ------------------ 2555| 0| *p++ = 9; 2556| 0| for (; i <= 279; ++i) ------------------ | Branch (2556:24): [True: 0, False: 0] ------------------ 2557| 0| *p++ = 7; 2558| 0| for (; i <= 287; ++i) ------------------ | Branch (2558:24): [True: 0, False: 0] ------------------ 2559| 0| *p++ = 8; 2560| 0| } 2561| 547| else 2562| 547| { 2563| 2.18k| for (counter = 0; counter < 3; counter++) ------------------ | Branch (2563:35): [True: 1.64k, False: 547] ------------------ 2564| 1.64k| { 2565| 1.64k| TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); ------------------ | | 2346| 1.64k| do \ | | 2347| 1.64k| { \ | | 2348| 1.64k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 1.09k, False: 547] | | ------------------ | | 2349| 1.64k| { \ | | 2350| 1.09k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 1.09k| do \ | | | | 2328| 1.09k| { \ | | | | 2329| 1.09k| mz_uint c; \ | | | | 2330| 1.09k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 1.09k| do \ | | | | | | 2317| 1.09k| { \ | | | | | | 2318| 1.09k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 1.09k] | | | | | | ------------------ | | | | | | 2319| 1.09k| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 1.09k| c = *pIn_buf_cur++; \ | | | | | | 2323| 1.09k| } \ | | | | | | 2324| 1.09k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 1.09k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 1.09k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 1.09k| num_bits += 8; \ | | | | 2333| 1.09k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 1.09k] | | | | ------------------ | | ------------------ | | 2351| 1.09k| } \ | | 2352| 1.64k| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 1.64k| bit_buf >>= (n); \ | | 2354| 1.64k| num_bits -= (n); \ | | 2355| 1.64k| } \ | | 2356| 1.64k| MZ_MACRO_END | | ------------------ | | | | 561| 1.64k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2566| 1.64k| r->m_table_sizes[counter] += s_min_table_sizes[counter]; 2567| 1.64k| } 2568| 547| MZ_CLEAR_ARR(r->m_code_size_2); ------------------ | | 597| 547|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2569| 10.3k| for (counter = 0; counter < r->m_table_sizes[2]; counter++) ------------------ | Branch (2569:35): [True: 9.84k, False: 547] ------------------ 2570| 9.84k| { 2571| 9.84k| mz_uint s; 2572| 9.84k| TINFL_GET_BITS(14, s, 3); ------------------ | | 2346| 9.84k| do \ | | 2347| 9.84k| { \ | | 2348| 9.84k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 3.28k, False: 6.56k] | | ------------------ | | 2349| 9.84k| { \ | | 2350| 3.28k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 3.28k| do \ | | | | 2328| 3.28k| { \ | | | | 2329| 3.28k| mz_uint c; \ | | | | 2330| 3.28k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 3.28k| do \ | | | | | | 2317| 3.28k| { \ | | | | | | 2318| 3.28k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 3.28k] | | | | | | ------------------ | | | | | | 2319| 3.28k| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 3.28k| c = *pIn_buf_cur++; \ | | | | | | 2323| 3.28k| } \ | | | | | | 2324| 3.28k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 3.28k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 3.28k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 3.28k| num_bits += 8; \ | | | | 2333| 3.28k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 3.28k] | | | | ------------------ | | ------------------ | | 2351| 3.28k| } \ | | 2352| 9.84k| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 9.84k| bit_buf >>= (n); \ | | 2354| 9.84k| num_bits -= (n); \ | | 2355| 9.84k| } \ | | 2356| 9.84k| MZ_MACRO_END | | ------------------ | | | | 561| 9.84k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2573| 9.84k| r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s; 2574| 9.84k| } 2575| 547| r->m_table_sizes[2] = 19; 2576| 547| } 2577| 2.18k| for (; (int)r->m_type >= 0; r->m_type--) ------------------ | Branch (2577:20): [True: 1.64k, False: 547] ------------------ 2578| 1.64k| { 2579| 1.64k| int tree_next, tree_cur; 2580| 1.64k| mz_int16 *pLookUp; 2581| 1.64k| mz_int16 *pTree; 2582| 1.64k| mz_uint8 *pCode_size; 2583| 1.64k| mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; 2584| 1.64k| pLookUp = r->m_look_up[r->m_type]; 2585| 1.64k| pTree = pTrees[r->m_type]; 2586| 1.64k| pCode_size = pCode_sizes[r->m_type]; 2587| 1.64k| MZ_CLEAR_ARR(total_syms); ------------------ | | 597| 1.64k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2588| 1.64k| TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0])); ------------------ | | 2289| 1.64k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 2589| 1.64k| tinfl_clear_tree(r); 2590| 168k| for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) ------------------ | Branch (2590:29): [True: 167k, False: 1.64k] ------------------ 2591| 167k| total_syms[pCode_size[i]]++; 2592| 1.64k| used_syms = 0, total = 0; 2593| 1.64k| next_code[0] = next_code[1] = 0; 2594| 26.2k| for (i = 1; i <= 15; ++i) ------------------ | Branch (2594:29): [True: 24.6k, False: 1.64k] ------------------ 2595| 24.6k| { 2596| 24.6k| used_syms += total_syms[i]; 2597| 24.6k| next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); 2598| 24.6k| } 2599| 1.64k| if ((65536 != total) && (used_syms > 1)) ------------------ | Branch (2599:21): [True: 547, False: 1.09k] | Branch (2599:41): [True: 0, False: 547] ------------------ 2600| 0| { 2601| 0| TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED); ------------------ | | 2305| 0| do \ | | 2306| 0| { \ | | 2307| 0| for (;;) \ | | 2308| 0| { \ | | 2309| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 0| } \ | | 2311| 0| } \ | | 2312| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2602| 0| } 2603| 168k| for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index) ------------------ | Branch (2603:53): [True: 167k, False: 1.64k] ------------------ 2604| 167k| { 2605| 167k| mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index]; 2606| 167k| if (!code_size) ------------------ | Branch (2606:25): [True: 162k, False: 4.98k] ------------------ 2607| 162k| continue; 2608| 4.98k| cur_code = next_code[code_size]++; 2609| 15.2k| for (l = code_size; l > 0; l--, cur_code >>= 1) ------------------ | Branch (2609:41): [True: 10.2k, False: 4.98k] ------------------ 2610| 10.2k| rev_code = (rev_code << 1) | (cur_code & 1); 2611| 4.98k| if (code_size <= TINFL_FAST_LOOKUP_BITS) ------------------ | Branch (2611:25): [True: 4.98k, False: 0] ------------------ 2612| 4.98k| { 2613| 4.98k| mz_int16 k = (mz_int16)((code_size << 9) | sym_index); 2614| 1.40M| while (rev_code < TINFL_FAST_LOOKUP_SIZE) ------------------ | Branch (2614:32): [True: 1.40M, False: 4.98k] ------------------ 2615| 1.40M| { 2616| 1.40M| pLookUp[rev_code] = k; 2617| 1.40M| rev_code += (1 << code_size); 2618| 1.40M| } 2619| 4.98k| continue; 2620| 4.98k| } 2621| 0| if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) ------------------ | Branch (2621:25): [True: 0, False: 0] ------------------ 2622| 0| { 2623| 0| pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; 2624| 0| tree_cur = tree_next; 2625| 0| tree_next -= 2; 2626| 0| } 2627| 0| rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1); 2628| 0| for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) ------------------ | Branch (2628:41): [True: 0, False: 0] ------------------ 2629| 0| { 2630| 0| tree_cur -= ((rev_code >>= 1) & 1); 2631| 0| if (!pTree[-tree_cur - 1]) ------------------ | Branch (2631:29): [True: 0, False: 0] ------------------ 2632| 0| { 2633| 0| pTree[-tree_cur - 1] = (mz_int16)tree_next; 2634| 0| tree_cur = tree_next; 2635| 0| tree_next -= 2; 2636| 0| } 2637| 0| else 2638| 0| tree_cur = pTree[-tree_cur - 1]; 2639| 0| } 2640| 0| tree_cur -= ((rev_code >>= 1) & 1); 2641| 0| pTree[-tree_cur - 1] = (mz_int16)sym_index; 2642| 0| } 2643| 1.64k| if (r->m_type == 2) ------------------ | Branch (2643:21): [True: 547, False: 1.09k] ------------------ 2644| 547| { 2645| 5.27k| for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) ------------------ | Branch (2645:39): [True: 4.72k, False: 547] ------------------ 2646| 4.72k| { 2647| 4.72k| mz_uint s; 2648| 4.72k| TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); ------------------ | | 2394| 4.72k| do \ | | 2395| 4.72k| { \ | | 2396| 4.72k| int temp; \ | | 2397| 4.72k| mz_uint code_len, c; \ | | 2398| 4.72k| if (num_bits < 15) \ | | ------------------ | | | Branch (2398:13): [True: 2.07k, False: 2.65k] | | ------------------ | | 2399| 4.72k| { \ | | 2400| 2.07k| if ((pIn_buf_end - pIn_buf_cur) < 2) \ | | ------------------ | | | Branch (2400:17): [True: 0, False: 2.07k] | | ------------------ | | 2401| 2.07k| { \ | | 2402| 0| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 2363| 0| do \ | | | | 2364| 0| { \ | | | | 2365| 0| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 2366| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (2366:13): [True: 0, False: 0] | | | | ------------------ | | | | 2367| 0| { \ | | | | 2368| 0| code_len = temp >> 9; \ | | | | 2369| 0| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (2369:17): [True: 0, False: 0] | | | | | Branch (2369:31): [True: 0, False: 0] | | | | ------------------ | | | | 2370| 0| break; \ | | | | 2371| 0| } \ | | | | 2372| 0| else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ | | | | ------------------ | | | | | Branch (2372:18): [True: 0, False: 0] | | | | ------------------ | | | | 2373| 0| { \ | | | | 2374| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 2375| 0| do \ | | | | 2376| 0| { \ | | | | 2377| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 2378| 0| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (2378:22): [True: 0, False: 0] | | | | | Branch (2378:36): [True: 0, False: 0] | | | | ------------------ | | | | 2379| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (2379:17): [True: 0, False: 0] | | | | ------------------ | | | | 2380| 0| break; \ | | | | 2381| 0| } \ | | | | 2382| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2383| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2384| 0| num_bits += 8; \ | | | | 2385| 0| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (2385:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2403| 0| } \ | | 2404| 2.07k| else \ | | 2405| 2.07k| { \ | | 2406| 2.07k| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 2407| 2.07k| pIn_buf_cur += 2; \ | | 2408| 2.07k| num_bits += 16; \ | | 2409| 2.07k| } \ | | 2410| 2.07k| } \ | | 2411| 4.72k| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (2411:13): [True: 4.72k, False: 0] | | ------------------ | | 2412| 4.72k| code_len = temp >> 9, temp &= 511; \ | | 2413| 4.72k| else \ | | 2414| 4.72k| { \ | | 2415| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 2416| 0| do \ | | 2417| 0| { \ | | 2418| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 2419| 0| } while (temp < 0); \ | | ------------------ | | | Branch (2419:22): [True: 0, False: 0] | | ------------------ | | 2420| 0| } \ | | 2421| 4.72k| sym = temp; \ | | 2422| 4.72k| bit_buf >>= code_len; \ | | 2423| 4.72k| num_bits -= code_len; \ | | 2424| 4.72k| } \ | | 2425| 4.72k| MZ_MACRO_END | | ------------------ | | | | 561| 4.72k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2649| 4.72k| if (dist < 16) ------------------ | Branch (2649:29): [True: 2.82k, False: 1.90k] ------------------ 2650| 2.82k| { 2651| 2.82k| r->m_len_codes[counter++] = (mz_uint8)dist; 2652| 2.82k| continue; 2653| 2.82k| } 2654| 1.90k| if ((dist == 16) && (!counter)) ------------------ | Branch (2654:29): [True: 0, False: 1.90k] | Branch (2654:45): [True: 0, False: 0] ------------------ 2655| 0| { 2656| 0| TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED); ------------------ | | 2305| 0| do \ | | 2306| 0| { \ | | 2307| 0| for (;;) \ | | 2308| 0| { \ | | 2309| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 0| } \ | | 2311| 0| } \ | | 2312| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2657| 0| } 2658| 1.90k| num_extra = "\02\03\07"[dist - 16]; 2659| 1.90k| TINFL_GET_BITS(18, s, num_extra); ------------------ | | 2346| 1.90k| do \ | | 2347| 1.90k| { \ | | 2348| 1.90k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 1.90k] | | ------------------ | | 2349| 1.90k| { \ | | 2350| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2351| 0| } \ | | 2352| 1.90k| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 1.90k| bit_buf >>= (n); \ | | 2354| 1.90k| num_bits -= (n); \ | | 2355| 1.90k| } \ | | 2356| 1.90k| MZ_MACRO_END | | ------------------ | | | | 561| 1.90k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2660| 1.90k| s += "\03\03\013"[dist - 16]; 2661| 1.90k| TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); ------------------ | | 2289| 3.80k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) | | ------------------ | | | Branch (2289:41): [True: 0, False: 1.90k] | | ------------------ ------------------ 2662| 1.90k| counter += s; 2663| 1.90k| } 2664| 547| if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) ------------------ | Branch (2664:25): [True: 0, False: 547] ------------------ 2665| 0| { 2666| 0| TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED); ------------------ | | 2305| 0| do \ | | 2306| 0| { \ | | 2307| 0| for (;;) \ | | 2308| 0| { \ | | 2309| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 0| } \ | | 2311| 0| } \ | | 2312| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2667| 0| } 2668| 547| TINFL_MEMCPY(r->m_code_size_0, r->m_len_codes, r->m_table_sizes[0]); ------------------ | | 2288| 547|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 2669| 547| TINFL_MEMCPY(r->m_code_size_1, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]); ------------------ | | 2288| 547|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 2670| 547| } 2671| 1.64k| } 2672| 547| for (;;) 2673| 345k| { 2674| 345k| mz_uint8 *pSrc; 2675| 345k| for (;;) 2676| 345k| { 2677| 345k| if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) ------------------ | Branch (2677:25): [True: 0, False: 345k] | Branch (2677:62): [True: 261, False: 345k] ------------------ 2678| 261| { 2679| 261| TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); ------------------ | | 2394| 261| do \ | | 2395| 261| { \ | | 2396| 261| int temp; \ | | 2397| 261| mz_uint code_len, c; \ | | 2398| 261| if (num_bits < 15) \ | | ------------------ | | | Branch (2398:13): [True: 0, False: 261] | | ------------------ | | 2399| 261| { \ | | 2400| 0| if ((pIn_buf_end - pIn_buf_cur) < 2) \ | | ------------------ | | | Branch (2400:17): [True: 0, False: 0] | | ------------------ | | 2401| 0| { \ | | 2402| 0| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 2363| 0| do \ | | | | 2364| 0| { \ | | | | 2365| 0| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 2366| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (2366:13): [True: 0, False: 0] | | | | ------------------ | | | | 2367| 0| { \ | | | | 2368| 0| code_len = temp >> 9; \ | | | | 2369| 0| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (2369:17): [True: 0, False: 0] | | | | | Branch (2369:31): [True: 0, False: 0] | | | | ------------------ | | | | 2370| 0| break; \ | | | | 2371| 0| } \ | | | | 2372| 0| else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ | | | | ------------------ | | | | | Branch (2372:18): [True: 0, False: 0] | | | | ------------------ | | | | 2373| 0| { \ | | | | 2374| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 2375| 0| do \ | | | | 2376| 0| { \ | | | | 2377| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 2378| 0| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (2378:22): [True: 0, False: 0] | | | | | Branch (2378:36): [True: 0, False: 0] | | | | ------------------ | | | | 2379| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (2379:17): [True: 0, False: 0] | | | | ------------------ | | | | 2380| 0| break; \ | | | | 2381| 0| } \ | | | | 2382| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2383| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2384| 0| num_bits += 8; \ | | | | 2385| 0| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (2385:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2403| 0| } \ | | 2404| 0| else \ | | 2405| 0| { \ | | 2406| 0| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 2407| 0| pIn_buf_cur += 2; \ | | 2408| 0| num_bits += 16; \ | | 2409| 0| } \ | | 2410| 0| } \ | | 2411| 261| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (2411:13): [True: 261, False: 0] | | ------------------ | | 2412| 261| code_len = temp >> 9, temp &= 511; \ | | 2413| 261| else \ | | 2414| 261| { \ | | 2415| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 2416| 0| do \ | | 2417| 0| { \ | | 2418| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 2419| 0| } while (temp < 0); \ | | ------------------ | | | Branch (2419:22): [True: 0, False: 0] | | ------------------ | | 2420| 0| } \ | | 2421| 261| sym = temp; \ | | 2422| 261| bit_buf >>= code_len; \ | | 2423| 261| num_bits -= code_len; \ | | 2424| 261| } \ | | 2425| 261| MZ_MACRO_END | | ------------------ | | | | 561| 261|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2680| 261| if (counter >= 256) ------------------ | Branch (2680:29): [True: 260, False: 1] ------------------ 2681| 260| break; 2682| 2| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2682:32): [True: 1, False: 1] ------------------ 2683| 1| { 2684| 1| TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 2296| 1| do \ | | 2297| 1| { \ | | 2298| 1| status = result; \ | | 2299| 1| r->m_state = state_index; \ | | 2300| 1| goto common_exit; \ | | 2301| 1| case state_index:; \ | | ------------------ | | | Branch (2301:9): [True: 1, False: 3.10k] | | ------------------ | | 2302| 1| } \ | | 2303| 1| MZ_MACRO_END | | ------------------ | | | | 561| 1|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2685| 1| } 2686| 1| *pOut_buf_cur++ = (mz_uint8)counter; 2687| 1| } 2688| 345k| else 2689| 345k| { 2690| 345k| int sym2; 2691| 345k| mz_uint code_len; 2692| 345k|#if TINFL_USE_64BIT_BITBUF 2693| 345k| if (num_bits < 30) ------------------ | Branch (2693:29): [True: 24.8k, False: 320k] ------------------ 2694| 24.8k| { 2695| 24.8k| bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); ------------------ | | 605| 24.8k|#define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 2696| 24.8k| pIn_buf_cur += 4; 2697| 24.8k| num_bits += 32; 2698| 24.8k| } 2699| |#else 2700| | if (num_bits < 15) 2701| | { 2702| | bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 2703| | pIn_buf_cur += 2; 2704| | num_bits += 16; 2705| | } 2706| |#endif 2707| 345k| if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) ------------------ | Branch (2707:29): [True: 345k, False: 0] ------------------ 2708| 345k| code_len = sym2 >> 9; 2709| 0| else 2710| 0| { 2711| 0| code_len = TINFL_FAST_LOOKUP_BITS; 2712| 0| do 2713| 0| { 2714| 0| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 2715| 0| } while (sym2 < 0); ------------------ | Branch (2715:38): [True: 0, False: 0] ------------------ 2716| 0| } 2717| 345k| counter = sym2; 2718| 345k| bit_buf >>= code_len; 2719| 345k| num_bits -= code_len; 2720| 345k| if (counter & 256) ------------------ | Branch (2720:29): [True: 345k, False: 618] ------------------ 2721| 345k| break; 2722| | 2723| |#if !TINFL_USE_64BIT_BITBUF 2724| | if (num_bits < 15) 2725| | { 2726| | bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 2727| | pIn_buf_cur += 2; 2728| | num_bits += 16; 2729| | } 2730| |#endif 2731| 618| if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) ------------------ | Branch (2731:29): [True: 618, False: 0] ------------------ 2732| 618| code_len = sym2 >> 9; 2733| 0| else 2734| 0| { 2735| 0| code_len = TINFL_FAST_LOOKUP_BITS; 2736| 0| do 2737| 0| { 2738| 0| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 2739| 0| } while (sym2 < 0); ------------------ | Branch (2739:38): [True: 0, False: 0] ------------------ 2740| 0| } 2741| 618| bit_buf >>= code_len; 2742| 618| num_bits -= code_len; 2743| | 2744| 618| pOut_buf_cur[0] = (mz_uint8)counter; 2745| 618| if (sym2 & 256) ------------------ | Branch (2745:29): [True: 1, False: 617] ------------------ 2746| 1| { 2747| 1| pOut_buf_cur++; 2748| 1| counter = sym2; 2749| 1| break; 2750| 1| } 2751| 617| pOut_buf_cur[1] = (mz_uint8)sym2; 2752| 617| pOut_buf_cur += 2; 2753| 617| } 2754| 345k| } 2755| 345k| if ((counter &= 511) == 256) ------------------ | Branch (2755:21): [True: 547, False: 344k] ------------------ 2756| 547| break; 2757| | 2758| 344k| num_extra = s_length_extra[counter - 257]; 2759| 344k| counter = s_length_base[counter - 257]; 2760| 344k| if (num_extra) ------------------ | Branch (2760:21): [True: 412, False: 344k] ------------------ 2761| 412| { 2762| 412| mz_uint extra_bits; 2763| 412| TINFL_GET_BITS(25, extra_bits, num_extra); ------------------ | | 2346| 412| do \ | | 2347| 412| { \ | | 2348| 412| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 412] | | ------------------ | | 2349| 412| { \ | | 2350| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2351| 0| } \ | | 2352| 412| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 412| bit_buf >>= (n); \ | | 2354| 412| num_bits -= (n); \ | | 2355| 412| } \ | | 2356| 412| MZ_MACRO_END | | ------------------ | | | | 561| 412|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2764| 412| counter += extra_bits; 2765| 412| } 2766| | 2767| 344k| TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); ------------------ | | 2394| 344k| do \ | | 2395| 344k| { \ | | 2396| 344k| int temp; \ | | 2397| 344k| mz_uint code_len, c; \ | | 2398| 344k| if (num_bits < 15) \ | | ------------------ | | | Branch (2398:13): [True: 0, False: 344k] | | ------------------ | | 2399| 344k| { \ | | 2400| 0| if ((pIn_buf_end - pIn_buf_cur) < 2) \ | | ------------------ | | | Branch (2400:17): [True: 0, False: 0] | | ------------------ | | 2401| 0| { \ | | 2402| 0| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 2363| 0| do \ | | | | 2364| 0| { \ | | | | 2365| 0| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 2366| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (2366:13): [True: 0, False: 0] | | | | ------------------ | | | | 2367| 0| { \ | | | | 2368| 0| code_len = temp >> 9; \ | | | | 2369| 0| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (2369:17): [True: 0, False: 0] | | | | | Branch (2369:31): [True: 0, False: 0] | | | | ------------------ | | | | 2370| 0| break; \ | | | | 2371| 0| } \ | | | | 2372| 0| else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ | | | | ------------------ | | | | | Branch (2372:18): [True: 0, False: 0] | | | | ------------------ | | | | 2373| 0| { \ | | | | 2374| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 2375| 0| do \ | | | | 2376| 0| { \ | | | | 2377| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 2378| 0| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (2378:22): [True: 0, False: 0] | | | | | Branch (2378:36): [True: 0, False: 0] | | | | ------------------ | | | | 2379| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (2379:17): [True: 0, False: 0] | | | | ------------------ | | | | 2380| 0| break; \ | | | | 2381| 0| } \ | | | | 2382| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2383| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2384| 0| num_bits += 8; \ | | | | 2385| 0| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (2385:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2403| 0| } \ | | 2404| 0| else \ | | 2405| 0| { \ | | 2406| 0| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 2407| 0| pIn_buf_cur += 2; \ | | 2408| 0| num_bits += 16; \ | | 2409| 0| } \ | | 2410| 0| } \ | | 2411| 344k| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (2411:13): [True: 344k, False: 0] | | ------------------ | | 2412| 344k| code_len = temp >> 9, temp &= 511; \ | | 2413| 344k| else \ | | 2414| 344k| { \ | | 2415| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 2416| 0| do \ | | 2417| 0| { \ | | 2418| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 2419| 0| } while (temp < 0); \ | | ------------------ | | | Branch (2419:22): [True: 0, False: 0] | | ------------------ | | 2420| 0| } \ | | 2421| 344k| sym = temp; \ | | 2422| 344k| bit_buf >>= code_len; \ | | 2423| 344k| num_bits -= code_len; \ | | 2424| 344k| } \ | | 2425| 344k| MZ_MACRO_END | | ------------------ | | | | 561| 344k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2768| 344k| num_extra = s_dist_extra[dist]; 2769| 344k| dist = s_dist_base[dist]; 2770| 344k| if (num_extra) ------------------ | Branch (2770:21): [True: 0, False: 344k] ------------------ 2771| 0| { 2772| 0| mz_uint extra_bits; 2773| 0| TINFL_GET_BITS(27, extra_bits, num_extra); ------------------ | | 2346| 0| do \ | | 2347| 0| { \ | | 2348| 0| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 0] | | ------------------ | | 2349| 0| { \ | | 2350| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2351| 0| } \ | | 2352| 0| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 0| bit_buf >>= (n); \ | | 2354| 0| num_bits -= (n); \ | | 2355| 0| } \ | | 2356| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2774| 0| dist += extra_bits; 2775| 0| } 2776| | 2777| 344k| dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start; 2778| 344k| if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) ------------------ | Branch (2778:22): [True: 0, False: 344k] | Branch (2778:35): [True: 0, False: 344k] | Branch (2778:69): [True: 0, False: 344k] | Branch (2778:102): [True: 0, False: 0] ------------------ 2779| 0| { 2780| 0| TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED); ------------------ | | 2305| 0| do \ | | 2306| 0| { \ | | 2307| 0| for (;;) \ | | 2308| 0| { \ | | 2309| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 0| } \ | | 2311| 0| } \ | | 2312| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2781| 0| } 2782| | 2783| 344k| pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask); 2784| | 2785| 344k| if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) ------------------ | | 594| 344k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (594:23): [True: 344k, False: 0] | | ------------------ ------------------ | Branch (2785:21): [True: 2.56k, False: 342k] ------------------ 2786| 2.56k| { 2787| 651k| while (counter--) ------------------ | Branch (2787:28): [True: 649k, False: 2.56k] ------------------ 2788| 649k| { 2789| 651k| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2789:32): [True: 2.56k, False: 649k] ------------------ 2790| 2.56k| { 2791| 2.56k| TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 2296| 2.56k| do \ | | 2297| 2.56k| { \ | | 2298| 2.56k| status = result; \ | | 2299| 2.56k| r->m_state = state_index; \ | | 2300| 2.56k| goto common_exit; \ | | 2301| 2.56k| case state_index:; \ | | ------------------ | | | Branch (2301:9): [True: 2.56k, False: 548] | | ------------------ | | 2302| 2.56k| } \ | | 2303| 2.56k| MZ_MACRO_END | | ------------------ | | | | 561| 2.56k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2792| 2.56k| } 2793| 649k| *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask]; 2794| 649k| } 2795| 2.56k| continue; 2796| 2.56k| } 2797| |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES 2798| | else if ((counter >= 9) && (counter <= dist)) 2799| | { 2800| | const mz_uint8 *pSrc_end = pSrc + (counter & ~7); 2801| | do 2802| | { 2803| |#ifdef MINIZ_UNALIGNED_USE_MEMCPY 2804| | memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2); 2805| |#else 2806| | ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; 2807| | ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; 2808| |#endif 2809| | pOut_buf_cur += 8; 2810| | } while ((pSrc += 8) < pSrc_end); 2811| | if ((counter &= 7) < 3) 2812| | { 2813| | if (counter) 2814| | { 2815| | pOut_buf_cur[0] = pSrc[0]; 2816| | if (counter > 1) 2817| | pOut_buf_cur[1] = pSrc[1]; 2818| | pOut_buf_cur += counter; 2819| | } 2820| | continue; 2821| | } 2822| | } 2823| |#endif 2824| 29.7M| while(counter>2) ------------------ | Branch (2824:23): [True: 29.4M, False: 342k] ------------------ 2825| 29.4M| { 2826| 29.4M| pOut_buf_cur[0] = pSrc[0]; 2827| 29.4M| pOut_buf_cur[1] = pSrc[1]; 2828| 29.4M| pOut_buf_cur[2] = pSrc[2]; 2829| 29.4M| pOut_buf_cur += 3; 2830| 29.4M| pSrc += 3; 2831| 29.4M| counter -= 3; 2832| 29.4M| } 2833| 342k| if (counter > 0) ------------------ | Branch (2833:21): [True: 408, False: 341k] ------------------ 2834| 408| { 2835| 408| pOut_buf_cur[0] = pSrc[0]; 2836| 408| if (counter > 1) ------------------ | Branch (2836:25): [True: 408, False: 0] ------------------ 2837| 408| pOut_buf_cur[1] = pSrc[1]; 2838| 408| pOut_buf_cur += counter; 2839| 408| } 2840| 342k| } 2841| 547| } 2842| 547| } while (!(r->m_final & 1)); ------------------ | Branch (2842:14): [True: 0, False: 547] ------------------ 2843| | 2844| | /* Ensure byte alignment and put back any bytes from the bitbuf if we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */ 2845| | /* I'm being super conservative here. A number of simplifications can be made to the byte alignment part, and the Adler32 check shouldn't ever need to worry about reading from the bitbuf now. */ 2846| 547| TINFL_SKIP_BITS(32, num_bits & 7); ------------------ | | 2335| 547| do \ | | 2336| 547| { \ | | 2337| 547| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2337:13): [True: 0, False: 547] | | ------------------ | | 2338| 547| { \ | | 2339| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2340| 0| } \ | | 2341| 547| bit_buf >>= (n); \ | | 2342| 547| num_bits -= (n); \ | | 2343| 547| } \ | | 2344| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2847| 3.07k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) ------------------ | Branch (2847:12): [True: 3.04k, False: 33] | Branch (2847:44): [True: 2.53k, False: 514] ------------------ 2848| 2.53k| { 2849| 2.53k| --pIn_buf_cur; 2850| 2.53k| num_bits -= 8; 2851| 2.53k| } 2852| 547| bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits); 2853| 547| MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end of non-deflate/zlib streams with following data (such as gzip streams). */ ------------------ | | 582| 547|#define MZ_ASSERT(x) assert(x) ------------------ 2854| | 2855| 547| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) ------------------ | Branch (2855:9): [True: 547, False: 0] ------------------ 2856| 547| { 2857| 2.73k| for (counter = 0; counter < 4; ++counter) ------------------ | Branch (2857:27): [True: 2.18k, False: 547] ------------------ 2858| 2.18k| { 2859| 2.18k| mz_uint s; 2860| 2.18k| if (num_bits) ------------------ | Branch (2860:17): [True: 0, False: 2.18k] ------------------ 2861| 0| TINFL_GET_BITS(41, s, 8); ------------------ | | 2346| 0| do \ | | 2347| 0| { \ | | 2348| 0| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 0] | | ------------------ | | 2349| 0| { \ | | 2350| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 0| do \ | | | | 2328| 0| { \ | | | | 2329| 0| mz_uint c; \ | | | | 2330| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 0| do \ | | | | | | 2317| 0| { \ | | | | | | 2318| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 2319| 0| { \ | | | | | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 2296| 0| do \ | | | | | | | | 2297| 0| { \ | | | | | | | | 2298| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2298:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 2299| 0| r->m_state = state_index; \ | | | | | | | | 2300| 0| goto common_exit; \ | | | | | | | | 2301| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 0| c = *pIn_buf_cur++; \ | | | | | | 2323| 0| } \ | | | | | | 2324| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 0| num_bits += 8; \ | | | | 2333| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 2351| 0| } \ | | 2352| 0| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 0| bit_buf >>= (n); \ | | 2354| 0| num_bits -= (n); \ | | 2355| 0| } \ | | 2356| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2862| 2.18k| else 2863| 2.18k| TINFL_GET_BYTE(42, s); ------------------ | | 2316| 2.18k| do \ | | 2317| 2.18k| { \ | | 2318| 2.18k| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (2318:16): [True: 0, False: 2.18k] | | ------------------ | | 2319| 2.18k| { \ | | 2320| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 2296| 0| do \ | | | | 2297| 0| { \ | | | | 2298| 0| status = result; \ | | | | ------------------ | | | | | Branch (2298:18): [True: 0, False: 0] | | | | ------------------ | | | | 2299| 0| r->m_state = state_index; \ | | | | 2300| 0| goto common_exit; \ | | | | 2301| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2321| 0| } \ | | 2322| 2.18k| c = *pIn_buf_cur++; \ | | 2323| 2.18k| } \ | | 2324| 2.18k| MZ_MACRO_END | | ------------------ | | | | 561| 2.18k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2864| 2.18k| r->m_z_adler32 = (r->m_z_adler32 << 8) | s; 2865| 2.18k| } 2866| 547| } 2867| 3.10k| TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE); ------------------ | | 2305| 547| do \ | | 2306| 547| { \ | | 2307| 547| for (;;) \ | | 2308| 547| { \ | | 2309| 547| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 547| do \ | | | | 2297| 547| { \ | | | | 2298| 547| status = result; \ | | | | 2299| 547| r->m_state = state_index; \ | | | | 2300| 547| goto common_exit; \ | | | | 2301| 547| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 3.10k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 547| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 547| } \ | | 2311| 547| } \ | | 2312| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2868| | 2869| 3.10k| TINFL_CR_FINISH ------------------ | | 2313| 3.10k|#define TINFL_CR_FINISH } ------------------ 2870| | 2871| 3.10k|common_exit: 2872| | /* As long as we aren't telling the caller that we NEED more input to make forward progress: */ 2873| | /* Put back any bytes from the bitbuf in case we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */ 2874| | /* We need to be very careful here to NOT push back any bytes we definitely know we need to make forward progress, though, or we'll lock the caller up into an inf loop. */ 2875| 3.10k| if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) ------------------ | Branch (2875:9): [True: 3.10k, False: 0] | Branch (2875:54): [True: 3.10k, False: 0] ------------------ 2876| 3.10k| { 2877| 14.3k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) ------------------ | Branch (2877:16): [True: 14.3k, False: 0] | Branch (2877:48): [True: 11.2k, False: 3.10k] ------------------ 2878| 11.2k| { 2879| 11.2k| --pIn_buf_cur; 2880| 11.2k| num_bits -= 8; 2881| 11.2k| } 2882| 3.10k| } 2883| 3.10k| r->m_num_bits = num_bits; 2884| 3.10k| r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits); 2885| 3.10k| r->m_dist = dist; 2886| 3.10k| r->m_counter = counter; 2887| 3.10k| r->m_num_extra = num_extra; 2888| 3.10k| r->m_dist_from_out_buf_start = dist_from_out_buf_start; 2889| 3.10k| *pIn_buf_size = pIn_buf_cur - pIn_buf_next; 2890| 3.10k| *pOut_buf_size = pOut_buf_cur - pOut_buf_next; 2891| 3.10k| if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0)) ------------------ | Branch (2891:9): [True: 3.10k, False: 0] | Branch (2891:89): [True: 3.10k, False: 0] ------------------ 2892| 3.10k| { 2893| 3.10k| const mz_uint8 *ptr = pOut_buf_next; 2894| 3.10k| size_t buf_len = *pOut_buf_size; 2895| 3.10k| mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; 2896| 3.10k| size_t block_len = buf_len % 5552; 2897| 19.7k| while (buf_len) ------------------ | Branch (2897:16): [True: 16.6k, False: 3.10k] ------------------ 2898| 16.6k| { 2899| 11.1M| for (i = 0; i + 7 < block_len; i += 8, ptr += 8) ------------------ | Branch (2899:25): [True: 11.1M, False: 16.6k] ------------------ 2900| 11.1M| { 2901| 11.1M| s1 += ptr[0], s2 += s1; 2902| 11.1M| s1 += ptr[1], s2 += s1; 2903| 11.1M| s1 += ptr[2], s2 += s1; 2904| 11.1M| s1 += ptr[3], s2 += s1; 2905| 11.1M| s1 += ptr[4], s2 += s1; 2906| 11.1M| s1 += ptr[5], s2 += s1; 2907| 11.1M| s1 += ptr[6], s2 += s1; 2908| 11.1M| s1 += ptr[7], s2 += s1; 2909| 11.1M| } 2910| 18.3k| for (; i < block_len; ++i) ------------------ | Branch (2910:20): [True: 1.72k, False: 16.6k] ------------------ 2911| 1.72k| s1 += *ptr++, s2 += s1; 2912| 16.6k| s1 %= 65521U, s2 %= 65521U; 2913| 16.6k| buf_len -= block_len; 2914| 16.6k| block_len = 5552; 2915| 16.6k| } 2916| 3.10k| r->m_check_adler32 = (s2 << 16) + s1; 2917| 3.10k| if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) ------------------ | Branch (2917:13): [True: 547, False: 2.56k] | Branch (2917:46): [True: 547, False: 0] | Branch (2917:95): [True: 0, False: 547] ------------------ 2918| 0| status = TINFL_STATUS_ADLER32_MISMATCH; 2919| 3.10k| } 2920| 3.10k| return status; 2921| 3.10k|} miniz.c:tdefl_flush_output_buffer: 1898| 1.64k|{ 1899| 1.64k| if (d->m_pIn_buf_size) ------------------ | Branch (1899:9): [True: 1.64k, False: 0] ------------------ 1900| 1.64k| { 1901| 1.64k| *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; 1902| 1.64k| } 1903| | 1904| 1.64k| if (d->m_pOut_buf_size) ------------------ | Branch (1904:9): [True: 1.64k, False: 0] ------------------ 1905| 1.64k| { 1906| 1.64k| size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining); ------------------ | | 595| 1.64k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 0, False: 1.64k] | | ------------------ ------------------ 1907| 1.64k| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n); 1908| 1.64k| d->m_output_flush_ofs += (mz_uint)n; 1909| 1.64k| d->m_output_flush_remaining -= (mz_uint)n; 1910| 1.64k| d->m_out_buf_ofs += n; 1911| | 1912| 1.64k| *d->m_pOut_buf_size = d->m_out_buf_ofs; 1913| 1.64k| } 1914| | 1915| 1.64k| return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY; ------------------ | Branch (1915:13): [True: 547, False: 1.09k] | Branch (1915:30): [True: 547, False: 0] ------------------ 1916| 1.64k|} miniz.c:tdefl_compress_normal: 1753| 1.64k|{ 1754| 1.64k| const mz_uint8 *pSrc = d->m_pSrc; 1755| 1.64k| size_t src_buf_left = d->m_src_buf_left; 1756| 1.64k| tdefl_flush flush = d->m_flush; 1757| | 1758| 347k| while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) ------------------ | Branch (1758:12): [True: 345k, False: 2.02k] | Branch (1758:31): [True: 1.47k, False: 548] | Branch (1758:42): [True: 925, False: 547] ------------------ 1759| 346k| { 1760| 346k| mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos; 1761| | /* Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN. */ 1762| 346k| if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) ------------------ | Branch (1762:13): [True: 346k, False: 547] ------------------ 1763| 346k| { 1764| 346k| mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2; 1765| 346k| mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK]; 1766| 346k| mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size); ------------------ | | 595| 346k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 1.44k, False: 344k] | | ------------------ ------------------ 1767| 346k| const mz_uint8 *pSrc_end = pSrc ? pSrc + num_bytes_to_process : NULL; ------------------ | Branch (1767:40): [True: 346k, False: 0] ------------------ 1768| 346k| src_buf_left -= num_bytes_to_process; 1769| 346k| d->m_lookahead_size += num_bytes_to_process; 1770| 89.0M| while (pSrc != pSrc_end) ------------------ | Branch (1770:20): [True: 88.7M, False: 346k] ------------------ 1771| 88.7M| { 1772| 88.7M| mz_uint8 c = *pSrc++; 1773| 88.7M| d->m_dict[dst_pos] = c; 1774| 88.7M| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (1774:21): [True: 645k, False: 88.1M] ------------------ 1775| 645k| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 1776| 88.7M| hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); 1777| 88.7M| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 1778| 88.7M| d->m_hash[hash] = (mz_uint16)(ins_pos); 1779| 88.7M| dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; 1780| 88.7M| ins_pos++; 1781| 88.7M| } 1782| 346k| } 1783| 547| else 1784| 547| { 1785| 138k| while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) ------------------ | Branch (1785:20): [True: 138k, False: 31] | Branch (1785:38): [True: 138k, False: 516] ------------------ 1786| 138k| { 1787| 138k| mz_uint8 c = *pSrc++; 1788| 138k| mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK; 1789| 138k| src_buf_left--; 1790| 138k| d->m_dict[dst_pos] = c; 1791| 138k| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (1791:21): [True: 137k, False: 516] ------------------ 1792| 137k| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 1793| 138k| if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) ------------------ | Branch (1793:21): [True: 137k, False: 1.09k] ------------------ 1794| 137k| { 1795| 137k| mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2; 1796| 137k| mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); 1797| 137k| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 1798| 137k| d->m_hash[hash] = (mz_uint16)(ins_pos); 1799| 137k| } 1800| 138k| } 1801| 547| } 1802| 346k| d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size); ------------------ | | 595| 346k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 303k, False: 43.5k] | | ------------------ ------------------ 1803| 346k| if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) ------------------ | Branch (1803:13): [True: 345k, False: 925] | Branch (1803:25): [True: 546, False: 345k] ------------------ 1804| 546| break; 1805| | 1806| | /* Simple lazy/greedy parsing state machine. */ 1807| 346k| len_to_move = 1; 1808| 346k| cur_match_dist = 0; 1809| 346k| cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); ------------------ | Branch (1809:25): [True: 245, False: 346k] ------------------ 1810| 346k| cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; 1811| 346k| if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) ------------------ | Branch (1811:13): [True: 0, False: 346k] ------------------ 1812| 0| { 1813| 0| if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) ------------------ | Branch (1813:17): [True: 0, False: 0] | Branch (1813:37): [True: 0, False: 0] ------------------ 1814| 0| { 1815| 0| mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK]; 1816| 0| cur_match_len = 0; 1817| 0| while (cur_match_len < d->m_lookahead_size) ------------------ | Branch (1817:24): [True: 0, False: 0] ------------------ 1818| 0| { 1819| 0| if (d->m_dict[cur_pos + cur_match_len] != c) ------------------ | Branch (1819:25): [True: 0, False: 0] ------------------ 1820| 0| break; 1821| 0| cur_match_len++; 1822| 0| } 1823| 0| if (cur_match_len < TDEFL_MIN_MATCH_LEN) ------------------ | Branch (1823:21): [True: 0, False: 0] ------------------ 1824| 0| cur_match_len = 0; 1825| 0| else 1826| 0| cur_match_dist = 1; 1827| 0| } 1828| 0| } 1829| 346k| else 1830| 346k| { 1831| 346k| tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len); 1832| 346k| } 1833| 346k| if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) ------------------ | Branch (1833:14): [True: 0, False: 346k] | Branch (1833:56): [True: 0, False: 0] | Branch (1833:91): [True: 548, False: 345k] | Branch (1833:123): [True: 0, False: 345k] | Branch (1833:162): [True: 0, False: 0] ------------------ 1834| 548| { 1835| 548| cur_match_dist = cur_match_len = 0; 1836| 548| } 1837| 346k| if (d->m_saved_match_len) ------------------ | Branch (1837:13): [True: 245, False: 346k] ------------------ 1838| 245| { 1839| 245| if (cur_match_len > d->m_saved_match_len) ------------------ | Branch (1839:17): [True: 0, False: 245] ------------------ 1840| 0| { 1841| 0| tdefl_record_literal(d, (mz_uint8)d->m_saved_lit); 1842| 0| if (cur_match_len >= 128) ------------------ | Branch (1842:21): [True: 0, False: 0] ------------------ 1843| 0| { 1844| 0| tdefl_record_match(d, cur_match_len, cur_match_dist); 1845| 0| d->m_saved_match_len = 0; 1846| 0| len_to_move = cur_match_len; 1847| 0| } 1848| 0| else 1849| 0| { 1850| 0| d->m_saved_lit = d->m_dict[cur_pos]; 1851| 0| d->m_saved_match_dist = cur_match_dist; 1852| 0| d->m_saved_match_len = cur_match_len; 1853| 0| } 1854| 0| } 1855| 245| else 1856| 245| { 1857| 245| tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); 1858| 245| len_to_move = d->m_saved_match_len - 1; 1859| 245| d->m_saved_match_len = 0; 1860| 245| } 1861| 245| } 1862| 346k| else if (!cur_match_dist) ------------------ | Branch (1862:18): [True: 1.23k, False: 344k] ------------------ 1863| 1.23k| tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); ------------------ | | 595| 1.23k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 1.23k, False: 0] | | ------------------ ------------------ 1864| 344k| else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) ------------------ | Branch (1864:18): [True: 0, False: 344k] | Branch (1864:43): [True: 0, False: 344k] | Branch (1864:79): [True: 344k, False: 245] ------------------ 1865| 344k| { 1866| 344k| tdefl_record_match(d, cur_match_len, cur_match_dist); 1867| 344k| len_to_move = cur_match_len; 1868| 344k| } 1869| 245| else 1870| 245| { 1871| 245| d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; ------------------ | | 595| 245|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 245, False: 0] | | ------------------ ------------------ 1872| 245| d->m_saved_match_dist = cur_match_dist; 1873| 245| d->m_saved_match_len = cur_match_len; 1874| 245| } 1875| | /* Move the lookahead forward by len_to_move bytes. */ 1876| 346k| d->m_lookahead_pos += len_to_move; 1877| 346k| MZ_ASSERT(d->m_lookahead_size >= len_to_move); ------------------ | | 582| 346k|#define MZ_ASSERT(x) assert(x) ------------------ 1878| 346k| d->m_lookahead_size -= len_to_move; 1879| 346k| d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE); ------------------ | | 595| 346k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 42.7k, False: 303k] | | ------------------ ------------------ 1880| | /* Check if it's time to flush the current LZ codes to the internal output buffer. */ 1881| 346k| if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || ------------------ | Branch (1881:13): [True: 0, False: 346k] ------------------ 1882| 346k| ((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))) ------------------ | Branch (1882:14): [True: 304k, False: 41.7k] | Branch (1882:52): [True: 0, False: 304k] | Branch (1882:143): [True: 0, False: 304k] ------------------ 1883| 0| { 1884| 0| int n; 1885| 0| d->m_pSrc = pSrc; 1886| 0| d->m_src_buf_left = src_buf_left; 1887| 0| if ((n = tdefl_flush_block(d, 0)) != 0) ------------------ | Branch (1887:17): [True: 0, False: 0] ------------------ 1888| 0| return (n < 0) ? MZ_FALSE : MZ_TRUE; ------------------ | | 554| 0|#define MZ_FALSE (0) ------------------ return (n < 0) ? MZ_FALSE : MZ_TRUE; ------------------ | | 555| 0|#define MZ_TRUE (1) ------------------ | Branch (1888:24): [True: 0, False: 0] ------------------ 1889| 0| } 1890| 346k| } 1891| | 1892| 1.64k| d->m_pSrc = pSrc; 1893| 1.64k| d->m_src_buf_left = src_buf_left; 1894| 1.64k| return MZ_TRUE; ------------------ | | 555| 1.64k|#define MZ_TRUE (1) ------------------ 1895| 1.64k|} miniz.c:tdefl_find_match: 1482| 346k|{ 1483| 346k| mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len; 1484| 346k| mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; 1485| 346k| const mz_uint8 *s = d->m_dict + pos, *p, *q; 1486| 346k| mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1]; 1487| 346k| MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); ------------------ | | 582| 346k|#define MZ_ASSERT(x) assert(x) ------------------ 1488| 346k| if (max_match_len <= match_len) ------------------ | Branch (1488:9): [True: 387, False: 345k] ------------------ 1489| 387| return; 1490| 345k| for (;;) 1491| 345k| { 1492| 345k| for (;;) 1493| 345k| { 1494| 345k| if (--num_probes_left == 0) ------------------ | Branch (1494:17): [True: 0, False: 345k] ------------------ 1495| 0| return; 1496| 345k|#define TDEFL_PROBE \ 1497| 345k| next_probe_pos = d->m_next[probe_pos]; \ 1498| 345k| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ 1499| 345k| return; \ 1500| 345k| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ 1501| 345k| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ 1502| 345k| break; 1503| 690k| TDEFL_PROBE; ------------------ | | 1497| 345k| next_probe_pos = d->m_next[probe_pos]; \ | | 1498| 345k| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (1498:9): [True: 1.09k, False: 344k] | | | Branch (1498:30): [True: 0, False: 344k] | | ------------------ | | 1499| 345k| return; \ | | 1500| 345k| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 1501| 344k| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (1501:9): [True: 344k, False: 0] | | | Branch (1501:53): [True: 344k, False: 0] | | ------------------ | | 1502| 344k| break; ------------------ 1504| 690k| TDEFL_PROBE; ------------------ | | 1497| 0| next_probe_pos = d->m_next[probe_pos]; \ | | 1498| 0| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (1498:9): [True: 0, False: 0] | | | Branch (1498:30): [True: 0, False: 0] | | ------------------ | | 1499| 0| return; \ | | 1500| 0| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 1501| 0| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (1501:9): [True: 0, False: 0] | | | Branch (1501:53): [True: 0, False: 0] | | ------------------ | | 1502| 0| break; ------------------ 1505| 0| TDEFL_PROBE; ------------------ | | 1497| 0| next_probe_pos = d->m_next[probe_pos]; \ | | 1498| 0| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (1498:9): [True: 0, False: 0] | | | Branch (1498:30): [True: 0, False: 0] | | ------------------ | | 1499| 0| return; \ | | 1500| 0| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 1501| 0| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (1501:9): [True: 0, False: 0] | | | Branch (1501:53): [True: 0, False: 0] | | ------------------ | | 1502| 0| break; ------------------ 1506| 0| } 1507| 344k| if (!dist) ------------------ | Branch (1507:13): [True: 0, False: 344k] ------------------ 1508| 0| break; 1509| 344k| p = s; 1510| 344k| q = d->m_dict + probe_pos; 1511| 89.2M| for (probe_len = 0; probe_len < max_match_len; probe_len++) ------------------ | Branch (1511:29): [True: 88.8M, False: 344k] ------------------ 1512| 88.8M| if (*p++ != *q++) ------------------ | Branch (1512:17): [True: 0, False: 88.8M] ------------------ 1513| 0| break; 1514| 344k| if (probe_len > match_len) ------------------ | Branch (1514:13): [True: 344k, False: 0] ------------------ 1515| 344k| { 1516| 344k| *pMatch_dist = dist; 1517| 344k| if ((*pMatch_len = match_len = probe_len) == max_match_len) ------------------ | Branch (1517:17): [True: 344k, False: 0] ------------------ 1518| 344k| return; 1519| 0| c0 = d->m_dict[pos + match_len]; 1520| 0| c1 = d->m_dict[pos + match_len - 1]; 1521| 0| } 1522| 344k| } 1523| 345k|} miniz.c:tdefl_record_literal: 1712| 1.23k|{ 1713| 1.23k| d->m_total_lz_bytes++; 1714| 1.23k| *d->m_pLZ_code_buf++ = lit; 1715| 1.23k| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); 1716| 1.23k| if (--d->m_num_flags_left == 0) ------------------ | Branch (1716:9): [True: 19, False: 1.21k] ------------------ 1717| 19| { 1718| 19| d->m_num_flags_left = 8; 1719| 19| d->m_pLZ_flags = d->m_pLZ_code_buf++; 1720| 19| } 1721| 1.23k| d->m_huff_count[0][lit]++; 1722| 1.23k|} miniz.c:tdefl_record_match: 1725| 344k|{ 1726| 344k| mz_uint32 s0, s1; 1727| | 1728| 344k| MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE)); ------------------ | | 582| 344k|#define MZ_ASSERT(x) assert(x) ------------------ 1729| | 1730| 344k| d->m_total_lz_bytes += match_len; 1731| | 1732| 344k| d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN); 1733| | 1734| 344k| match_dist -= 1; 1735| 344k| d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF); 1736| 344k| d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); 1737| 344k| d->m_pLZ_code_buf += 3; 1738| | 1739| 344k| *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); 1740| 344k| if (--d->m_num_flags_left == 0) ------------------ | Branch (1740:9): [True: 43.0k, False: 301k] ------------------ 1741| 43.0k| { 1742| 43.0k| d->m_num_flags_left = 8; 1743| 43.0k| d->m_pLZ_flags = d->m_pLZ_code_buf++; 1744| 43.0k| } 1745| | 1746| 344k| s0 = s_tdefl_small_dist_sym[match_dist & 511]; 1747| 344k| s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127]; 1748| 344k| d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; ------------------ | Branch (1748:24): [True: 344k, False: 0] ------------------ 1749| 344k| d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++; 1750| 344k|} miniz.c:tdefl_flush_block: 1257| 547|{ 1258| 547| mz_uint saved_bit_buf, saved_bits_in; 1259| 547| mz_uint8 *pSaved_output_buf; 1260| 547| mz_bool comp_block_succeeded = MZ_FALSE; ------------------ | | 554| 547|#define MZ_FALSE (0) ------------------ 1261| 547| int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size; ------------------ | Branch (1261:28): [True: 0, False: 547] | Branch (1261:80): [True: 0, False: 0] ------------------ 1262| 547| mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf; ------------------ | Branch (1262:36): [True: 547, False: 0] | Branch (1262:68): [True: 129, False: 418] ------------------ 1263| | 1264| 547| d->m_pOutput_buf = pOutput_buf_start; 1265| 547| d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16; 1266| | 1267| 547| MZ_ASSERT(!d->m_output_flush_remaining); ------------------ | | 582| 547|#define MZ_ASSERT(x) assert(x) ------------------ 1268| 547| d->m_output_flush_ofs = 0; 1269| 547| d->m_output_flush_remaining = 0; 1270| | 1271| 547| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left); 1272| 547| d->m_pLZ_code_buf -= (d->m_num_flags_left == 8); 1273| | 1274| 547| if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) ------------------ | Branch (1274:9): [True: 547, False: 0] | Branch (1274:51): [True: 547, False: 0] ------------------ 1275| 547| { 1276| 547| const mz_uint8 cmf = 0x78; 1277| 547| mz_uint8 flg, flevel = 3; 1278| 547| mz_uint header, i, mz_un = sizeof(s_tdefl_num_probes) / sizeof(mz_uint); 1279| | 1280| | /* Determine compression level by reversing the process in tdefl_create_comp_flags_from_zip_params() */ 1281| 5.47k| for (i = 0; i < mz_un; i++) ------------------ | Branch (1281:21): [True: 5.47k, False: 0] ------------------ 1282| 5.47k| if (s_tdefl_num_probes[i] == (d->m_flags & 0xFFF)) break; ------------------ | Branch (1282:17): [True: 547, False: 4.92k] ------------------ 1283| | 1284| 547| if (i < 2) ------------------ | Branch (1284:13): [True: 0, False: 547] ------------------ 1285| 0| flevel = 0; 1286| 547| else if (i < 6) ------------------ | Branch (1286:18): [True: 0, False: 547] ------------------ 1287| 0| flevel = 1; 1288| 547| else if (i == 6) ------------------ | Branch (1288:18): [True: 0, False: 547] ------------------ 1289| 0| flevel = 2; 1290| | 1291| 547| header = cmf << 8 | (flevel << 6); 1292| 547| header += 31 - (header % 31); 1293| 547| flg = header & 0xFF; 1294| | 1295| 547| TDEFL_PUT_BITS(cmf, 8); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 1.09k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 547, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 547| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 547, False: 0] | | ------------------ | | 935| 547| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 547| d->m_bit_buffer >>= 8; \ | | 937| 547| d->m_bits_in -= 8; \ | | 938| 547| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1296| 547| TDEFL_PUT_BITS(flg, 8); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 1.09k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 547, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 547| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 547, False: 0] | | ------------------ | | 935| 547| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 547| d->m_bit_buffer >>= 8; \ | | 937| 547| d->m_bits_in -= 8; \ | | 938| 547| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1297| 547| } 1298| | 1299| 547| TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 547| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1300| | 1301| 547| pSaved_output_buf = d->m_pOutput_buf; 1302| 547| saved_bit_buf = d->m_bit_buffer; 1303| 547| saved_bits_in = d->m_bits_in; 1304| | 1305| 547| if (!use_raw_block) ------------------ | Branch (1305:9): [True: 547, False: 0] ------------------ 1306| 547| comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48)); ------------------ | Branch (1306:56): [True: 0, False: 547] | Branch (1306:104): [True: 0, False: 547] ------------------ 1307| | 1308| | /* If the block gets expanded, forget the current contents of the output buffer and send a raw block instead. */ 1309| 547| if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) && ------------------ | Branch (1309:10): [True: 0, False: 547] | Branch (1309:30): [True: 547, False: 0] | Branch (1309:55): [True: 0, False: 547] ------------------ 1310| 547| ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size)) ------------------ | Branch (1310:9): [True: 0, False: 0] ------------------ 1311| 0| { 1312| 0| mz_uint i; 1313| 0| d->m_pOutput_buf = pSaved_output_buf; 1314| 0| d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; 1315| 0| TDEFL_PUT_BITS(0, 2); ------------------ | | 925| 0| do \ | | 926| 0| { \ | | 927| 0| mz_uint bits = b; \ | | 928| 0| mz_uint len = l; \ | | 929| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 0| d->m_bits_in += len; \ | | 932| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 0] | | ------------------ | | 933| 0| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 0| } \ | | 940| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1316| 0| if (d->m_bits_in) ------------------ | Branch (1316:13): [True: 0, False: 0] ------------------ 1317| 0| { 1318| 0| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 925| 0| do \ | | 926| 0| { \ | | 927| 0| mz_uint bits = b; \ | | 928| 0| mz_uint len = l; \ | | 929| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 0| d->m_bits_in += len; \ | | 932| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 0] | | ------------------ | | 933| 0| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 0| } \ | | 940| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1319| 0| } 1320| 0| for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF) ------------------ | Branch (1320:21): [True: 0, False: 0] ------------------ 1321| 0| { 1322| 0| TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); ------------------ | | 925| 0| do \ | | 926| 0| { \ | | 927| 0| mz_uint bits = b; \ | | 928| 0| mz_uint len = l; \ | | 929| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 0| d->m_bits_in += len; \ | | 932| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 0] | | ------------------ | | 933| 0| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 0| } \ | | 940| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1323| 0| } 1324| 0| for (i = 0; i < d->m_total_lz_bytes; ++i) ------------------ | Branch (1324:21): [True: 0, False: 0] ------------------ 1325| 0| { 1326| 0| TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8); ------------------ | | 925| 0| do \ | | 926| 0| { \ | | 927| 0| mz_uint bits = b; \ | | 928| 0| mz_uint len = l; \ | | 929| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 0| d->m_bits_in += len; \ | | 932| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 0] | | ------------------ | | 933| 0| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 0| } \ | | 940| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1327| 0| } 1328| 0| } 1329| | /* Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes. */ 1330| 547| else if (!comp_block_succeeded) ------------------ | Branch (1330:14): [True: 0, False: 547] ------------------ 1331| 0| { 1332| 0| d->m_pOutput_buf = pSaved_output_buf; 1333| 0| d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; 1334| 0| tdefl_compress_block(d, MZ_TRUE); ------------------ | | 555| 0|#define MZ_TRUE (1) ------------------ 1335| 0| } 1336| | 1337| 547| if (flush) ------------------ | Branch (1337:9): [True: 547, False: 0] ------------------ 1338| 547| { 1339| 547| if (flush == TDEFL_FINISH) ------------------ | Branch (1339:13): [True: 547, False: 0] ------------------ 1340| 547| { 1341| 547| if (d->m_bits_in) ------------------ | Branch (1341:17): [True: 478, False: 69] ------------------ 1342| 478| { 1343| 478| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 925| 478| do \ | | 926| 478| { \ | | 927| 478| mz_uint bits = b; \ | | 928| 478| mz_uint len = l; \ | | 929| 478| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 478|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 478| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 478| d->m_bits_in += len; \ | | 932| 956| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 478, False: 478] | | ------------------ | | 933| 478| { \ | | 934| 478| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 478, False: 0] | | ------------------ | | 935| 478| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 478| d->m_bit_buffer >>= 8; \ | | 937| 478| d->m_bits_in -= 8; \ | | 938| 478| } \ | | 939| 478| } \ | | 940| 478| MZ_MACRO_END | | ------------------ | | | | 561| 478|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1344| 478| } 1345| 547| if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) ------------------ | Branch (1345:17): [True: 547, False: 0] ------------------ 1346| 547| { 1347| 547| mz_uint i, a = d->m_adler32; 1348| 2.73k| for (i = 0; i < 4; i++) ------------------ | Branch (1348:29): [True: 2.18k, False: 547] ------------------ 1349| 2.18k| { 1350| 2.18k| TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); ------------------ | | 925| 2.18k| do \ | | 926| 2.18k| { \ | | 927| 2.18k| mz_uint bits = b; \ | | 928| 2.18k| mz_uint len = l; \ | | 929| 2.18k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 2.18k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 2.18k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 2.18k| d->m_bits_in += len; \ | | 932| 4.37k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 2.18k, False: 2.18k] | | ------------------ | | 933| 2.18k| { \ | | 934| 2.18k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 2.18k, False: 0] | | ------------------ | | 935| 2.18k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 2.18k| d->m_bit_buffer >>= 8; \ | | 937| 2.18k| d->m_bits_in -= 8; \ | | 938| 2.18k| } \ | | 939| 2.18k| } \ | | 940| 2.18k| MZ_MACRO_END | | ------------------ | | | | 561| 2.18k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1351| 2.18k| a <<= 8; 1352| 2.18k| } 1353| 547| } 1354| 547| } 1355| 0| else 1356| 0| { 1357| 0| mz_uint i, z = 0; 1358| 0| TDEFL_PUT_BITS(0, 3); ------------------ | | 925| 0| do \ | | 926| 0| { \ | | 927| 0| mz_uint bits = b; \ | | 928| 0| mz_uint len = l; \ | | 929| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 0| d->m_bits_in += len; \ | | 932| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 0] | | ------------------ | | 933| 0| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 0| } \ | | 940| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1359| 0| if (d->m_bits_in) ------------------ | Branch (1359:17): [True: 0, False: 0] ------------------ 1360| 0| { 1361| 0| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 925| 0| do \ | | 926| 0| { \ | | 927| 0| mz_uint bits = b; \ | | 928| 0| mz_uint len = l; \ | | 929| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 0| d->m_bits_in += len; \ | | 932| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 0] | | ------------------ | | 933| 0| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 0| } \ | | 940| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1362| 0| } 1363| 0| for (i = 2; i; --i, z ^= 0xFFFF) ------------------ | Branch (1363:25): [True: 0, False: 0] ------------------ 1364| 0| { 1365| 0| TDEFL_PUT_BITS(z & 0xFFFF, 16); ------------------ | | 925| 0| do \ | | 926| 0| { \ | | 927| 0| mz_uint bits = b; \ | | 928| 0| mz_uint len = l; \ | | 929| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 0| d->m_bits_in += len; \ | | 932| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 0] | | ------------------ | | 933| 0| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 0| } \ | | 940| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1366| 0| } 1367| 0| } 1368| 547| } 1369| | 1370| 547| MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end); ------------------ | | 582| 547|#define MZ_ASSERT(x) assert(x) ------------------ 1371| | 1372| 547| memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 1373| 547| memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 1374| | 1375| 547| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 1376| 547| d->m_pLZ_flags = d->m_lz_code_buf; 1377| 547| d->m_num_flags_left = 8; 1378| 547| d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; 1379| 547| d->m_total_lz_bytes = 0; 1380| 547| d->m_block_index++; 1381| | 1382| 547| if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) ------------------ | Branch (1382:9): [True: 547, False: 0] ------------------ 1383| 547| { 1384| 547| if (d->m_pPut_buf_func) ------------------ | Branch (1384:13): [True: 0, False: 547] ------------------ 1385| 0| { 1386| 0| *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; 1387| 0| if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user)) ------------------ | Branch (1387:17): [True: 0, False: 0] ------------------ 1388| 0| return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED); 1389| 0| } 1390| 547| else if (pOutput_buf_start == d->m_output_buf) ------------------ | Branch (1390:18): [True: 418, False: 129] ------------------ 1391| 418| { 1392| 418| int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); ------------------ | | 595| 418|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 418, False: 0] | | ------------------ ------------------ 1393| 418| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy); 1394| 418| d->m_out_buf_ofs += bytes_to_copy; 1395| 418| if ((n -= bytes_to_copy) != 0) ------------------ | Branch (1395:17): [True: 0, False: 418] ------------------ 1396| 0| { 1397| 0| d->m_output_flush_ofs = bytes_to_copy; 1398| 0| d->m_output_flush_remaining = n; 1399| 0| } 1400| 418| } 1401| 129| else 1402| 129| { 1403| 129| d->m_out_buf_ofs += n; 1404| 129| } 1405| 547| } 1406| | 1407| 547| return d->m_output_flush_remaining; 1408| 547|} miniz.c:tdefl_compress_block: 1246| 547|{ 1247| 547| if (static_block) ------------------ | Branch (1247:9): [True: 0, False: 547] ------------------ 1248| 0| tdefl_start_static_block(d); 1249| 547| else 1250| 547| tdefl_start_dynamic_block(d); 1251| 547| return tdefl_compress_lz_codes(d); 1252| 547|} miniz.c:tdefl_optimize_huffman_table: 872| 1.64k|{ 873| 1.64k| int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; 874| 1.64k| mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; 875| 1.64k| MZ_CLEAR_ARR(num_codes); ------------------ | | 597| 1.64k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 876| 1.64k| if (static_table) ------------------ | Branch (876:9): [True: 0, False: 1.64k] ------------------ 877| 0| { 878| 0| for (i = 0; i < table_len; i++) ------------------ | Branch (878:21): [True: 0, False: 0] ------------------ 879| 0| num_codes[d->m_huff_code_sizes[table_num][i]]++; 880| 0| } 881| 1.64k| else 882| 1.64k| { 883| 1.64k| tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms; 884| 1.64k| int num_used_syms = 0; 885| 1.64k| const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0]; 886| 187k| for (i = 0; i < table_len; i++) ------------------ | Branch (886:21): [True: 185k, False: 1.64k] ------------------ 887| 185k| if (pSym_count[i]) ------------------ | Branch (887:17): [True: 4.98k, False: 180k] ------------------ 888| 4.98k| { 889| 4.98k| syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; 890| 4.98k| syms0[num_used_syms++].m_sym_index = (mz_uint16)i; 891| 4.98k| } 892| | 893| 1.64k| pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); 894| 1.64k| tdefl_calculate_minimum_redundancy(pSyms, num_used_syms); 895| | 896| 6.62k| for (i = 0; i < num_used_syms; i++) ------------------ | Branch (896:21): [True: 4.98k, False: 1.64k] ------------------ 897| 4.98k| num_codes[pSyms[i].m_key]++; 898| | 899| 1.64k| tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit); 900| | 901| 1.64k| MZ_CLEAR_ARR(d->m_huff_code_sizes[table_num]); ------------------ | | 597| 1.64k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 902| 1.64k| MZ_CLEAR_ARR(d->m_huff_codes[table_num]); ------------------ | | 597| 1.64k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 903| 21.8k| for (i = 1, j = num_used_syms; i <= code_size_limit; i++) ------------------ | Branch (903:40): [True: 20.2k, False: 1.64k] ------------------ 904| 25.2k| for (l = num_codes[i]; l > 0; l--) ------------------ | Branch (904:36): [True: 4.98k, False: 20.2k] ------------------ 905| 4.98k| d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i); 906| 1.64k| } 907| | 908| 1.64k| next_code[1] = 0; 909| 20.2k| for (j = 0, i = 2; i <= code_size_limit; i++) ------------------ | Branch (909:24): [True: 18.5k, False: 1.64k] ------------------ 910| 18.5k| next_code[i] = j = ((j + num_codes[i - 1]) << 1); 911| | 912| 187k| for (i = 0; i < table_len; i++) ------------------ | Branch (912:17): [True: 185k, False: 1.64k] ------------------ 913| 185k| { 914| 185k| mz_uint rev_code = 0, code, code_size; 915| 185k| if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) ------------------ | Branch (915:13): [True: 180k, False: 4.98k] ------------------ 916| 180k| continue; 917| 4.98k| code = next_code[code_size]++; 918| 15.2k| for (l = code_size; l > 0; l--, code >>= 1) ------------------ | Branch (918:29): [True: 10.2k, False: 4.98k] ------------------ 919| 10.2k| rev_code = (rev_code << 1) | (code & 1); 920| 4.98k| d->m_huff_codes[table_num][i] = (mz_uint16)rev_code; 921| 4.98k| } 922| 1.64k|} miniz.c:tdefl_radix_sort_syms: 754| 1.64k|{ 755| 1.64k| mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; 756| 1.64k| tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1; 757| 1.64k| MZ_CLEAR_ARR(hist); ------------------ | | 597| 1.64k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 758| 6.62k| for (i = 0; i < num_syms; i++) ------------------ | Branch (758:17): [True: 4.98k, False: 1.64k] ------------------ 759| 4.98k| { 760| 4.98k| mz_uint freq = pSyms0[i].m_key; 761| 4.98k| hist[freq & 0xFF]++; 762| 4.98k| hist[256 + ((freq >> 8) & 0xFF)]++; 763| 4.98k| } 764| 2.97k| while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) ------------------ | Branch (764:12): [True: 1.64k, False: 1.33k] | Branch (764:34): [True: 1.33k, False: 309] ------------------ 765| 1.33k| total_passes--; 766| 3.59k| for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) ------------------ | Branch (766:36): [True: 1.95k, False: 1.64k] ------------------ 767| 1.95k| { 768| 1.95k| const mz_uint32 *pHist = &hist[pass << 8]; 769| 1.95k| mz_uint offsets[256], cur_ofs = 0; 770| 501k| for (i = 0; i < 256; i++) ------------------ | Branch (770:21): [True: 499k, False: 1.95k] ------------------ 771| 499k| { 772| 499k| offsets[i] = cur_ofs; 773| 499k| cur_ofs += pHist[i]; 774| 499k| } 775| 7.69k| for (i = 0; i < num_syms; i++) ------------------ | Branch (775:21): [True: 5.74k, False: 1.95k] ------------------ 776| 5.74k| pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i]; 777| 1.95k| { 778| 1.95k| tdefl_sym_freq *t = pCur_syms; 779| 1.95k| pCur_syms = pNew_syms; 780| 1.95k| pNew_syms = t; 781| 1.95k| } 782| 1.95k| } 783| 1.64k| return pCur_syms; 784| 1.64k|} miniz.c:tdefl_calculate_minimum_redundancy: 788| 1.64k|{ 789| 1.64k| int root, leaf, next, avbl, used, dpth; 790| 1.64k| if (n == 0) ------------------ | Branch (790:9): [True: 0, False: 1.64k] ------------------ 791| 0| return; 792| 1.64k| else if (n == 1) ------------------ | Branch (792:14): [True: 547, False: 1.09k] ------------------ 793| 547| { 794| 547| A[0].m_key = 1; 795| 547| return; 796| 547| } 797| 1.09k| A[0].m_key += A[1].m_key; 798| 1.09k| root = 0; 799| 1.09k| leaf = 2; 800| 3.34k| for (next = 1; next < n - 1; next++) ------------------ | Branch (800:20): [True: 2.25k, False: 1.09k] ------------------ 801| 2.25k| { 802| 2.25k| if (leaf >= n || A[root].m_key < A[leaf].m_key) ------------------ | Branch (802:13): [True: 387, False: 1.86k] | Branch (802:26): [True: 684, False: 1.17k] ------------------ 803| 1.07k| { 804| 1.07k| A[next].m_key = A[root].m_key; 805| 1.07k| A[root++].m_key = (mz_uint16)next; 806| 1.07k| } 807| 1.17k| else 808| 1.17k| A[next].m_key = A[leaf++].m_key; 809| 2.25k| if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) ------------------ | Branch (809:13): [True: 719, False: 1.53k] | Branch (809:27): [True: 1.05k, False: 473] | Branch (809:42): [True: 460, False: 598] ------------------ 810| 1.17k| { 811| 1.17k| A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); 812| 1.17k| A[root++].m_key = (mz_uint16)next; 813| 1.17k| } 814| 1.07k| else 815| 1.07k| A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key); 816| 2.25k| } 817| 1.09k| A[n - 2].m_key = 0; 818| 3.34k| for (next = n - 3; next >= 0; next--) ------------------ | Branch (818:24): [True: 2.25k, False: 1.09k] ------------------ 819| 2.25k| A[next].m_key = A[A[next].m_key].m_key + 1; 820| 1.09k| avbl = 1; 821| 1.09k| used = dpth = 0; 822| 1.09k| root = n - 2; 823| 1.09k| next = n - 1; 824| 5.14k| while (avbl > 0) ------------------ | Branch (824:12): [True: 4.05k, False: 1.09k] ------------------ 825| 4.05k| { 826| 7.39k| while (root >= 0 && (int)A[root].m_key == dpth) ------------------ | Branch (826:16): [True: 5.20k, False: 2.18k] | Branch (826:29): [True: 3.34k, False: 1.86k] ------------------ 827| 3.34k| { 828| 3.34k| used++; 829| 3.34k| root--; 830| 3.34k| } 831| 8.48k| while (avbl > used) ------------------ | Branch (831:16): [True: 4.43k, False: 4.05k] ------------------ 832| 4.43k| { 833| 4.43k| A[next--].m_key = (mz_uint16)(dpth); 834| 4.43k| avbl--; 835| 4.43k| } 836| 4.05k| avbl = 2 * used; 837| 4.05k| dpth++; 838| 4.05k| used = 0; 839| 4.05k| } 840| 1.09k|} miniz.c:tdefl_huffman_enforce_max_code_size: 848| 1.64k|{ 849| 1.64k| int i; 850| 1.64k| mz_uint32 total = 0; 851| 1.64k| if (code_list_len <= 1) ------------------ | Branch (851:9): [True: 547, False: 1.09k] ------------------ 852| 547| return; 853| 24.0k| for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) ------------------ | Branch (853:33): [True: 22.9k, False: 1.09k] ------------------ 854| 22.9k| pNum_codes[max_code_size] += pNum_codes[i]; 855| 13.1k| for (i = max_code_size; i > 0; i--) ------------------ | Branch (855:29): [True: 12.0k, False: 1.09k] ------------------ 856| 12.0k| total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i)); 857| 1.09k| while (total != (1UL << max_code_size)) ------------------ | Branch (857:12): [True: 0, False: 1.09k] ------------------ 858| 0| { 859| 0| pNum_codes[max_code_size]--; 860| 0| for (i = max_code_size - 1; i > 0; i--) ------------------ | Branch (860:37): [True: 0, False: 0] ------------------ 861| 0| if (pNum_codes[i]) ------------------ | Branch (861:17): [True: 0, False: 0] ------------------ 862| 0| { 863| 0| pNum_codes[i]--; 864| 0| pNum_codes[i + 1] += 2; 865| 0| break; 866| 0| } 867| 0| total--; 868| 0| } 869| 1.09k|} miniz.c:tdefl_start_dynamic_block: 991| 547|{ 992| 547| int num_lit_codes, num_dist_codes, num_bit_lengths; 993| 547| mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index; 994| 547| mz_uint8 code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF; 995| | 996| 547| d->m_huff_count[0][256] = 1; 997| | 998| 547| tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE); ------------------ | | 554| 547|#define MZ_FALSE (0) ------------------ 999| 547| tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE); ------------------ | | 554| 547|#define MZ_FALSE (0) ------------------ 1000| | 1001| 661| for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) ------------------ | Branch (1001:31): [True: 661, False: 0] ------------------ 1002| 661| if (d->m_huff_code_sizes[0][num_lit_codes - 1]) ------------------ | Branch (1002:13): [True: 547, False: 114] ------------------ 1003| 547| break; 1004| 16.4k| for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) ------------------ | Branch (1004:31): [True: 15.8k, False: 547] ------------------ 1005| 15.8k| if (d->m_huff_code_sizes[1][num_dist_codes - 1]) ------------------ | Branch (1005:13): [True: 0, False: 15.8k] ------------------ 1006| 0| break; 1007| | 1008| 547| memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); 1009| 547| memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes); 1010| 547| total_code_sizes_to_pack = num_lit_codes + num_dist_codes; 1011| 547| num_packed_code_sizes = 0; 1012| 547| rle_z_count = 0; 1013| 547| rle_repeat_count = 0; 1014| | 1015| 547| memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2); 1016| 157k| for (i = 0; i < total_code_sizes_to_pack; i++) ------------------ | Branch (1016:17): [True: 156k, False: 547] ------------------ 1017| 156k| { 1018| 156k| mz_uint8 code_size = code_sizes_to_pack[i]; 1019| 156k| if (!code_size) ------------------ | Branch (1019:13): [True: 154k, False: 2.63k] ------------------ 1020| 154k| { 1021| 154k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 943| 154k| { \ | | 944| 154k| if (rle_repeat_count) \ | | ------------------ | | | Branch (944:13): [True: 0, False: 154k] | | ------------------ | | 945| 154k| { \ | | 946| 0| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (946:17): [True: 0, False: 0] | | ------------------ | | 947| 0| { \ | | 948| 0| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 949| 0| while (rle_repeat_count--) \ | | ------------------ | | | Branch (949:24): [True: 0, False: 0] | | ------------------ | | 950| 0| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 951| 0| } \ | | 952| 0| else \ | | 953| 0| { \ | | 954| 0| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 955| 0| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 956| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 957| 0| } \ | | 958| 0| rle_repeat_count = 0; \ | | 959| 0| } \ | | 960| 154k| } ------------------ 1022| 154k| if (++rle_z_count == 138) ------------------ | Branch (1022:17): [True: 547, False: 153k] ------------------ 1023| 547| { 1024| 547| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 963| 547| { \ | | 964| 547| if (rle_z_count) \ | | ------------------ | | | Branch (964:13): [True: 547, False: 0] | | ------------------ | | 965| 547| { \ | | 966| 547| if (rle_z_count < 3) \ | | ------------------ | | | Branch (966:17): [True: 0, False: 547] | | ------------------ | | 967| 547| { \ | | 968| 0| d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 969| 0| while (rle_z_count--) \ | | ------------------ | | | Branch (969:24): [True: 0, False: 0] | | ------------------ | | 970| 0| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 971| 0| } \ | | 972| 547| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (972:22): [True: 0, False: 547] | | ------------------ | | 973| 547| { \ | | 974| 0| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 975| 0| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 976| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ | | 977| 0| } \ | | 978| 547| else \ | | 979| 547| { \ | | 980| 547| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 981| 547| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 982| 547| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 983| 547| } \ | | 984| 547| rle_z_count = 0; \ | | 985| 547| } \ | | 986| 547| } ------------------ 1025| 547| } 1026| 154k| } 1027| 2.63k| else 1028| 2.63k| { 1029| 2.63k| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 963| 2.63k| { \ | | 964| 2.63k| if (rle_z_count) \ | | ------------------ | | | Branch (964:13): [True: 1.47k, False: 1.16k] | | ------------------ | | 965| 2.63k| { \ | | 966| 1.47k| if (rle_z_count < 3) \ | | ------------------ | | | Branch (966:17): [True: 116, False: 1.35k] | | ------------------ | | 967| 1.47k| { \ | | 968| 116| d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 969| 310| while (rle_z_count--) \ | | ------------------ | | | Branch (969:24): [True: 194, False: 116] | | ------------------ | | 970| 194| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 971| 116| } \ | | 972| 1.47k| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (972:22): [True: 196, False: 1.15k] | | ------------------ | | 973| 1.35k| { \ | | 974| 196| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 975| 196| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 976| 196| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ | | 977| 196| } \ | | 978| 1.35k| else \ | | 979| 1.35k| { \ | | 980| 1.15k| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 981| 1.15k| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 982| 1.15k| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 983| 1.15k| } \ | | 984| 1.47k| rle_z_count = 0; \ | | 985| 1.47k| } \ | | 986| 2.63k| } ------------------ 1030| 2.63k| if (code_size != prev_code_size) ------------------ | Branch (1030:17): [True: 2.15k, False: 478] ------------------ 1031| 2.15k| { 1032| 2.15k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 943| 2.15k| { \ | | 944| 2.15k| if (rle_repeat_count) \ | | ------------------ | | | Branch (944:13): [True: 10, False: 2.14k] | | ------------------ | | 945| 2.15k| { \ | | 946| 10| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (946:17): [True: 10, False: 0] | | ------------------ | | 947| 10| { \ | | 948| 10| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 949| 20| while (rle_repeat_count--) \ | | ------------------ | | | Branch (949:24): [True: 10, False: 10] | | ------------------ | | 950| 10| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 951| 10| } \ | | 952| 10| else \ | | 953| 10| { \ | | 954| 0| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 955| 0| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 956| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 957| 0| } \ | | 958| 10| rle_repeat_count = 0; \ | | 959| 10| } \ | | 960| 2.15k| } ------------------ 1033| 2.15k| d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1); 1034| 2.15k| packed_code_sizes[num_packed_code_sizes++] = code_size; 1035| 2.15k| } 1036| 478| else if (++rle_repeat_count == 6) ------------------ | Branch (1036:22): [True: 0, False: 478] ------------------ 1037| 0| { 1038| 0| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 943| 0| { \ | | 944| 0| if (rle_repeat_count) \ | | ------------------ | | | Branch (944:13): [True: 0, False: 0] | | ------------------ | | 945| 0| { \ | | 946| 0| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (946:17): [True: 0, False: 0] | | ------------------ | | 947| 0| { \ | | 948| 0| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 949| 0| while (rle_repeat_count--) \ | | ------------------ | | | Branch (949:24): [True: 0, False: 0] | | ------------------ | | 950| 0| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 951| 0| } \ | | 952| 0| else \ | | 953| 0| { \ | | 954| 0| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 955| 0| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 956| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 957| 0| } \ | | 958| 0| rle_repeat_count = 0; \ | | 959| 0| } \ | | 960| 0| } ------------------ 1039| 0| } 1040| 2.63k| } 1041| 156k| prev_code_size = code_size; 1042| 156k| } 1043| 547| if (rle_repeat_count) ------------------ | Branch (1043:9): [True: 468, False: 79] ------------------ 1044| 468| { 1045| 468| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 943| 468| { \ | | 944| 468| if (rle_repeat_count) \ | | ------------------ | | | Branch (944:13): [True: 468, False: 0] | | ------------------ | | 945| 468| { \ | | 946| 468| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (946:17): [True: 468, False: 0] | | ------------------ | | 947| 468| { \ | | 948| 468| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 949| 936| while (rle_repeat_count--) \ | | ------------------ | | | Branch (949:24): [True: 468, False: 468] | | ------------------ | | 950| 468| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 951| 468| } \ | | 952| 468| else \ | | 953| 468| { \ | | 954| 0| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 955| 0| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 956| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 957| 0| } \ | | 958| 468| rle_repeat_count = 0; \ | | 959| 468| } \ | | 960| 468| } ------------------ 1046| 468| } 1047| 79| else 1048| 79| { 1049| 79| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 963| 79| { \ | | 964| 79| if (rle_z_count) \ | | ------------------ | | | Branch (964:13): [True: 0, False: 79] | | ------------------ | | 965| 79| { \ | | 966| 0| if (rle_z_count < 3) \ | | ------------------ | | | Branch (966:17): [True: 0, False: 0] | | ------------------ | | 967| 0| { \ | | 968| 0| d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 969| 0| while (rle_z_count--) \ | | ------------------ | | | Branch (969:24): [True: 0, False: 0] | | ------------------ | | 970| 0| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 971| 0| } \ | | 972| 0| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (972:22): [True: 0, False: 0] | | ------------------ | | 973| 0| { \ | | 974| 0| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 975| 0| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 976| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ | | 977| 0| } \ | | 978| 0| else \ | | 979| 0| { \ | | 980| 0| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 981| 0| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 982| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 983| 0| } \ | | 984| 0| rle_z_count = 0; \ | | 985| 0| } \ | | 986| 79| } ------------------ 1050| 79| } 1051| | 1052| 547| tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE); ------------------ | | 554| 547|#define MZ_FALSE (0) ------------------ 1053| | 1054| 547| TDEFL_PUT_BITS(2, 2); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 547| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1055| | 1056| 547| TDEFL_PUT_BITS(num_lit_codes - 257, 5); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 1.09k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 547, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 547| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 547, False: 0] | | ------------------ | | 935| 547| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 547| d->m_bit_buffer >>= 8; \ | | 937| 547| d->m_bits_in -= 8; \ | | 938| 547| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1057| 547| TDEFL_PUT_BITS(num_dist_codes - 1, 5); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 547| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1058| | 1059| 1.09k| for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) ------------------ | Branch (1059:32): [True: 1.09k, False: 0] ------------------ 1060| 1.09k| if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) ------------------ | Branch (1060:13): [True: 547, False: 547] ------------------ 1061| 547| break; 1062| 547| num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); ------------------ | | 594| 547|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (594:23): [True: 0, False: 547] | | ------------------ ------------------ 1063| 547| TDEFL_PUT_BITS(num_bit_lengths - 4, 4); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 1.09k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 547, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 547| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 547, False: 0] | | ------------------ | | 935| 547| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 547| d->m_bit_buffer >>= 8; \ | | 937| 547| d->m_bits_in -= 8; \ | | 938| 547| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1064| 10.3k| for (i = 0; (int)i < num_bit_lengths; i++) ------------------ | Branch (1064:17): [True: 9.84k, False: 547] ------------------ 1065| 9.84k| TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); ------------------ | | 925| 10.3k| do \ | | 926| 10.3k| { \ | | 927| 9.84k| mz_uint bits = b; \ | | 928| 9.84k| mz_uint len = l; \ | | 929| 9.84k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 9.84k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 9.84k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 9.84k| d->m_bits_in += len; \ | | 932| 13.1k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 3.28k, False: 9.84k] | | ------------------ | | 933| 9.84k| { \ | | 934| 3.28k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 3.28k, False: 0] | | ------------------ | | 935| 3.28k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 3.28k| d->m_bit_buffer >>= 8; \ | | 937| 3.28k| d->m_bits_in -= 8; \ | | 938| 3.28k| } \ | | 939| 9.84k| } \ | | 940| 10.3k| MZ_MACRO_END | | ------------------ | | | | 561| 9.84k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1066| | 1067| 5.27k| for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;) ------------------ | Branch (1067:39): [True: 4.72k, False: 547] ------------------ 1068| 4.72k| { 1069| 4.72k| mz_uint code = packed_code_sizes[packed_code_sizes_index++]; 1070| 4.72k| MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2); ------------------ | | 582| 4.72k|#define MZ_ASSERT(x) assert(x) ------------------ 1071| 4.72k| TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); ------------------ | | 925| 4.72k| do \ | | 926| 4.72k| { \ | | 927| 4.72k| mz_uint bits = b; \ | | 928| 4.72k| mz_uint len = l; \ | | 929| 4.72k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 4.72k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 4.72k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 4.72k| d->m_bits_in += len; \ | | 932| 6.28k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 1.55k, False: 4.72k] | | ------------------ | | 933| 4.72k| { \ | | 934| 1.55k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 1.55k, False: 0] | | ------------------ | | 935| 1.55k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 1.55k| d->m_bit_buffer >>= 8; \ | | 937| 1.55k| d->m_bits_in -= 8; \ | | 938| 1.55k| } \ | | 939| 4.72k| } \ | | 940| 4.72k| MZ_MACRO_END | | ------------------ | | | | 561| 4.72k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1072| 4.72k| if (code >= 16) ------------------ | Branch (1072:13): [True: 1.90k, False: 2.82k] ------------------ 1073| 1.90k| TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]); ------------------ | | 925| 1.90k| do \ | | 926| 1.90k| { \ | | 927| 1.90k| mz_uint bits = b; \ | | 928| 1.90k| mz_uint len = l; \ | | 929| 1.90k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 1.90k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 1.90k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 1.90k| d->m_bits_in += len; \ | | 932| 3.32k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 1.42k, False: 1.90k] | | ------------------ | | 933| 1.90k| { \ | | 934| 1.42k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 1.42k, False: 0] | | ------------------ | | 935| 1.42k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 1.42k| d->m_bit_buffer >>= 8; \ | | 937| 1.42k| d->m_bits_in -= 8; \ | | 938| 1.42k| } \ | | 939| 1.90k| } \ | | 940| 1.90k| MZ_MACRO_END | | ------------------ | | | | 561| 1.90k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1074| 4.72k| } 1075| 547|} miniz.c:tdefl_compress_lz_codes: 1198| 547|{ 1199| 547| mz_uint flags; 1200| 547| mz_uint8 *pLZ_codes; 1201| | 1202| 547| flags = 1; 1203| 346k| for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1) ------------------ | Branch (1203:40): [True: 346k, False: 547] ------------------ 1204| 346k| { 1205| 346k| if (flags == 1) ------------------ | Branch (1205:13): [True: 43.5k, False: 302k] ------------------ 1206| 43.5k| flags = *pLZ_codes++ | 0x100; 1207| 346k| if (flags & 1) ------------------ | Branch (1207:13): [True: 344k, False: 1.23k] ------------------ 1208| 344k| { 1209| 344k| mz_uint sym, num_extra_bits; 1210| 344k| mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); 1211| 344k| pLZ_codes += 3; 1212| | 1213| 344k| MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); ------------------ | | 582| 344k|#define MZ_ASSERT(x) assert(x) ------------------ 1214| 344k| TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); ------------------ | | 925| 344k| do \ | | 926| 344k| { \ | | 927| 344k| mz_uint bits = b; \ | | 928| 344k| mz_uint len = l; \ | | 929| 344k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 344k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 344k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 344k| d->m_bits_in += len; \ | | 932| 406k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 61.7k, False: 344k] | | ------------------ | | 933| 344k| { \ | | 934| 61.7k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 61.7k, False: 0] | | ------------------ | | 935| 61.7k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 61.7k| d->m_bit_buffer >>= 8; \ | | 937| 61.7k| d->m_bits_in -= 8; \ | | 938| 61.7k| } \ | | 939| 344k| } \ | | 940| 344k| MZ_MACRO_END | | ------------------ | | | | 561| 344k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1215| 344k| TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]); ------------------ | | 925| 344k| do \ | | 926| 344k| { \ | | 927| 344k| mz_uint bits = b; \ | | 928| 344k| mz_uint len = l; \ | | 929| 344k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 344k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 344k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 344k| d->m_bits_in += len; \ | | 932| 344k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 178, False: 344k] | | ------------------ | | 933| 344k| { \ | | 934| 178| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 178, False: 0] | | ------------------ | | 935| 178| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 178| d->m_bit_buffer >>= 8; \ | | 937| 178| d->m_bits_in -= 8; \ | | 938| 178| } \ | | 939| 344k| } \ | | 940| 344k| MZ_MACRO_END | | ------------------ | | | | 561| 344k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1216| | 1217| 344k| if (match_dist < 512) ------------------ | Branch (1217:17): [True: 344k, False: 0] ------------------ 1218| 344k| { 1219| 344k| sym = s_tdefl_small_dist_sym[match_dist]; 1220| 344k| num_extra_bits = s_tdefl_small_dist_extra[match_dist]; 1221| 344k| } 1222| 0| else 1223| 0| { 1224| 0| sym = s_tdefl_large_dist_sym[match_dist >> 8]; 1225| 0| num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8]; 1226| 0| } 1227| 344k| MZ_ASSERT(d->m_huff_code_sizes[1][sym]); ------------------ | | 582| 344k|#define MZ_ASSERT(x) assert(x) ------------------ 1228| 344k| TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); ------------------ | | 925| 344k| do \ | | 926| 344k| { \ | | 927| 344k| mz_uint bits = b; \ | | 928| 344k| mz_uint len = l; \ | | 929| 344k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 344k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 344k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 344k| d->m_bits_in += len; \ | | 932| 369k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 24.6k, False: 344k] | | ------------------ | | 933| 344k| { \ | | 934| 24.6k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 24.6k, False: 0] | | ------------------ | | 935| 24.6k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 24.6k| d->m_bit_buffer >>= 8; \ | | 937| 24.6k| d->m_bits_in -= 8; \ | | 938| 24.6k| } \ | | 939| 344k| } \ | | 940| 344k| MZ_MACRO_END | | ------------------ | | | | 561| 344k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1229| 344k| TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); ------------------ | | 925| 344k| do \ | | 926| 344k| { \ | | 927| 344k| mz_uint bits = b; \ | | 928| 344k| mz_uint len = l; \ | | 929| 344k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 344k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 344k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 344k| d->m_bits_in += len; \ | | 932| 344k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 344k] | | ------------------ | | 933| 344k| { \ | | 934| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 0, False: 0] | | ------------------ | | 935| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 0| d->m_bit_buffer >>= 8; \ | | 937| 0| d->m_bits_in -= 8; \ | | 938| 0| } \ | | 939| 344k| } \ | | 940| 344k| MZ_MACRO_END | | ------------------ | | | | 561| 344k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1230| 344k| } 1231| 1.23k| else 1232| 1.23k| { 1233| 1.23k| mz_uint lit = *pLZ_codes++; 1234| 1.23k| MZ_ASSERT(d->m_huff_code_sizes[0][lit]); ------------------ | | 582| 1.23k|#define MZ_ASSERT(x) assert(x) ------------------ 1235| 1.23k| TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); ------------------ | | 925| 1.23k| do \ | | 926| 1.23k| { \ | | 927| 1.23k| mz_uint bits = b; \ | | 928| 1.23k| mz_uint len = l; \ | | 929| 1.23k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 1.23k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 1.23k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 1.23k| d->m_bits_in += len; \ | | 932| 1.52k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 287, False: 1.23k] | | ------------------ | | 933| 1.23k| { \ | | 934| 287| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 287, False: 0] | | ------------------ | | 935| 287| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 287| d->m_bit_buffer >>= 8; \ | | 937| 287| d->m_bits_in -= 8; \ | | 938| 287| } \ | | 939| 1.23k| } \ | | 940| 1.23k| MZ_MACRO_END | | ------------------ | | | | 561| 1.23k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1236| 1.23k| } 1237| 346k| } 1238| | 1239| 547| TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); ------------------ | | 925| 547| do \ | | 926| 547| { \ | | 927| 547| mz_uint bits = b; \ | | 928| 547| mz_uint len = l; \ | | 929| 547| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 547|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 547| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 547| d->m_bits_in += len; \ | | 932| 736| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 189, False: 547] | | ------------------ | | 933| 547| { \ | | 934| 189| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 189, False: 0] | | ------------------ | | 935| 189| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 189| d->m_bit_buffer >>= 8; \ | | 937| 189| d->m_bits_in -= 8; \ | | 938| 189| } \ | | 939| 547| } \ | | 940| 547| MZ_MACRO_END | | ------------------ | | | | 561| 547|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1240| | 1241| 547| return (d->m_pOutput_buf < d->m_pOutput_buf_end); 1242| 547|} miniz.c:tinfl_clear_tree: 2428| 1.64k|{ 2429| 1.64k| if (r->m_type == 0) ------------------ | Branch (2429:9): [True: 547, False: 1.09k] ------------------ 2430| 547| MZ_CLEAR_ARR(r->m_tree_0); ------------------ | | 597| 547|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2431| 1.09k| else if (r->m_type == 1) ------------------ | Branch (2431:14): [True: 547, False: 547] ------------------ 2432| 547| MZ_CLEAR_ARR(r->m_tree_1); ------------------ | | 597| 547|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2433| 547| else 2434| 547| MZ_CLEAR_ARR(r->m_tree_2); ------------------ | | 597| 547|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2435| 1.64k|} test_large_deflate: 30| 547|{ 31| 547| z_stream c_stream; /* compression stream */ ------------------ | | 487| 547|#define z_stream mz_stream ------------------ 32| 547| int err; 33| | 34| 547| c_stream.zalloc = zalloc; 35| 547| c_stream.zfree = zfree; 36| 547| c_stream.opaque = NULL; 37| | 38| 547| err = deflateInit(&c_stream, Z_BEST_COMPRESSION); ------------------ | | 490| 547|#define deflateInit mz_deflateInit ------------------ err = deflateInit(&c_stream, Z_BEST_COMPRESSION); ------------------ | | 475| 547|#define Z_BEST_COMPRESSION MZ_BEST_COMPRESSION ------------------ 39| 547| CHECK_ERR(err, "deflateInit"); ------------------ | | 14| 547|#define CHECK_ERR(err, msg) { \ | | 15| 547| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.09k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 547] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 547|} ------------------ 40| | 41| 547| c_stream.next_out = compr; 42| 547| c_stream.avail_out = (unsigned int)comprLen; 43| | 44| | /* At this point, uncompr is still mostly zeroes, so it should compress 45| | * very well: 46| | */ 47| 547| c_stream.next_in = uncompr; 48| 547| c_stream.avail_in = (unsigned int)uncomprLen; 49| 547| err = deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 493| 547|#define deflate mz_deflate ------------------ err = deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 457| 547|#define Z_NO_FLUSH MZ_NO_FLUSH ------------------ 50| 547| CHECK_ERR(err, "deflate large 1"); ------------------ | | 14| 547|#define CHECK_ERR(err, msg) { \ | | 15| 547| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.09k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 547] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 547|} ------------------ 51| | 52| 547| if (c_stream.avail_in != 0) ------------------ | Branch (52:9): [True: 0, False: 547] ------------------ 53| 0| { 54| 0| fprintf(stderr, "deflate not greedy\n"); 55| 0| exit(1); 56| 0| } 57| | 58| | /* Feed in already compressed data: */ 59| 547| c_stream.next_in = compr; 60| 547| diff = (unsigned int)(c_stream.next_out - compr); 61| 547| c_stream.avail_in = diff; 62| | 63| 547| deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 493| 547|#define deflate mz_deflate ------------------ deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 457| 547|#define Z_NO_FLUSH MZ_NO_FLUSH ------------------ 64| 547| err = deflate(&c_stream, Z_FINISH); ------------------ | | 493| 547|#define deflate mz_deflate ------------------ err = deflate(&c_stream, Z_FINISH); ------------------ | | 461| 547|#define Z_FINISH MZ_FINISH ------------------ 65| | 66| 547| if (err != Z_STREAM_END) ------------------ | | 464| 547|#define Z_STREAM_END MZ_STREAM_END ------------------ | Branch (66:9): [True: 0, False: 547] ------------------ 67| 0| { 68| 0| fprintf(stderr, "deflate large should report Z_STREAM_END\n"); 69| 0| exit(1); 70| 0| } 71| 547| err = deflateEnd(&c_stream); ------------------ | | 494| 547|#define deflateEnd mz_deflateEnd ------------------ 72| 547| CHECK_ERR(err, "deflateEnd"); ------------------ | | 14| 547|#define CHECK_ERR(err, msg) { \ | | 15| 547| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.09k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 547] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 547|} ------------------ 73| 547|} test_large_inflate: 78| 547|{ 79| 547| int err; 80| 547| z_stream d_stream; /* decompression stream */ ------------------ | | 487| 547|#define z_stream mz_stream ------------------ 81| | 82| 547| d_stream.zalloc = zalloc; 83| 547| d_stream.zfree = zfree; 84| 547| d_stream.opaque = NULL; 85| | 86| 547| d_stream.next_in = compr; 87| 547| d_stream.avail_in = (unsigned int)comprLen; 88| | 89| 547| err = inflateInit(&d_stream); ------------------ | | 502| 547|#define inflateInit mz_inflateInit ------------------ 90| 547| CHECK_ERR(err, "inflateInit"); ------------------ | | 14| 547|#define CHECK_ERR(err, msg) { \ | | 15| 547| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.09k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 547] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 547|} ------------------ 91| | 92| 547| for (;;) 93| 547| { 94| 547| d_stream.next_out = uncompr; /* discard the output */ 95| 547| d_stream.avail_out = (unsigned int)uncomprLen; 96| 547| err = inflate(&d_stream, Z_NO_FLUSH); ------------------ | | 505| 547|#define inflate mz_inflate ------------------ err = inflate(&d_stream, Z_NO_FLUSH); ------------------ | | 457| 547|#define Z_NO_FLUSH MZ_NO_FLUSH ------------------ 97| 547| if (err == Z_STREAM_END) break; ------------------ | | 464| 547|#define Z_STREAM_END MZ_STREAM_END ------------------ | Branch (97:13): [True: 547, False: 0] ------------------ 98| | 99| 0| CHECK_ERR(err, "large inflate"); ------------------ | | 14| 0|#define CHECK_ERR(err, msg) { \ | | 15| 0| if (err != Z_OK) { \ | | ------------------ | | | | 463| 0|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 0] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 0|} ------------------ 100| 0| } 101| | 102| 547| err = inflateEnd(&d_stream); ------------------ | | 506| 547|#define inflateEnd mz_inflateEnd ------------------ 103| 547| CHECK_ERR(err, "inflateEnd"); ------------------ | | 14| 547|#define CHECK_ERR(err, msg) { \ | | 15| 547| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.09k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 547] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 547|} ------------------ 104| 547|} LLVMFuzzerTestOneInput: 107| 551|{ 108| 551| size_t comprLen = 100 + 3 * size; 109| 551| size_t uncomprLen = comprLen; 110| 551| uint8_t *compr, *uncompr; 111| | 112| | /* Discard inputs larger than 512Kb. */ 113| 551| static size_t kMaxSize = 512 * 1024; 114| | 115| 551| if (size < 1 || size > kMaxSize) ------------------ | Branch (115:9): [True: 0, False: 551] | Branch (115:21): [True: 4, False: 547] ------------------ 116| 4| return 0; 117| | 118| 547| data = d; 119| 547| dataLen = size; 120| 547| compr = calloc(1, comprLen); 121| 547| uncompr = calloc(1, uncomprLen); 122| | 123| 547| test_large_deflate(compr, comprLen, uncompr, uncomprLen); 124| 547| test_large_inflate(compr, comprLen, uncompr, uncomprLen); 125| | 126| 547| free(compr); 127| 547| free(uncompr); 128| | 129| 547| return 0; 130| 551|}