mz_adler32: 41| 1.59k|{ 42| 1.59k| mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16); 43| 1.59k| size_t block_len = buf_len % 5552; 44| 1.59k| if (!ptr) ------------------ | Branch (44:9): [True: 0, False: 1.59k] ------------------ 45| 0| return MZ_ADLER32_INIT; ------------------ | | 240| 0|#define MZ_ADLER32_INIT (1) ------------------ 46| 16.6k| while (buf_len) ------------------ | Branch (46:12): [True: 15.0k, False: 1.59k] ------------------ 47| 15.0k| { 48| 10.2M| for (i = 0; i + 7 < block_len; i += 8, ptr += 8) ------------------ | Branch (48:21): [True: 10.2M, False: 15.0k] ------------------ 49| 10.2M| { 50| 10.2M| s1 += ptr[0], s2 += s1; 51| 10.2M| s1 += ptr[1], s2 += s1; 52| 10.2M| s1 += ptr[2], s2 += s1; 53| 10.2M| s1 += ptr[3], s2 += s1; 54| 10.2M| s1 += ptr[4], s2 += s1; 55| 10.2M| s1 += ptr[5], s2 += s1; 56| 10.2M| s1 += ptr[6], s2 += s1; 57| 10.2M| s1 += ptr[7], s2 += s1; 58| 10.2M| } 59| 16.7k| for (; i < block_len; ++i) ------------------ | Branch (59:16): [True: 1.70k, False: 15.0k] ------------------ 60| 1.70k| s1 += *ptr++, s2 += s1; 61| 15.0k| s1 %= 65521U, s2 %= 65521U; 62| 15.0k| buf_len -= block_len; 63| 15.0k| block_len = 5552; 64| 15.0k| } 65| 1.59k| return (s2 << 16) + s1; 66| 1.59k|} miniz_def_alloc_func: 168| 1.06k|{ 169| 1.06k| (void)opaque, (void)items, (void)size; 170| 1.06k| return MZ_MALLOC(items * size); ------------------ | | 589| 1.06k|#define MZ_MALLOC(x) malloc(x) ------------------ 171| 1.06k|} miniz_def_free_func: 173| 1.06k|{ 174| 1.06k| (void)opaque, (void)address; 175| 1.06k| MZ_FREE(address); ------------------ | | 590| 1.06k|#define MZ_FREE(x) free(x) ------------------ 176| 1.06k|} mz_deflateInit: 193| 530|{ 194| 530| return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY); ------------------ | | 259| 530|#define MZ_DEFLATED 8 ------------------ return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY); ------------------ | | 314| 530|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ 195| 530|} mz_deflateInit2: 198| 530|{ 199| 530| tdefl_compressor *pComp; 200| 530| mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy); 201| | 202| 530| if (!pStream) ------------------ | Branch (202:9): [True: 0, False: 530] ------------------ 203| 0| return MZ_STREAM_ERROR; 204| 530| if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) ------------------ | | 259| 530|#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| 530|#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: 530] | Branch (204:37): [True: 0, False: 530] | Branch (204:56): [True: 0, False: 530] | Branch (204:77): [True: 0, False: 530] | Branch (204:120): [True: 0, False: 0] ------------------ 205| 0| return MZ_PARAM_ERROR; 206| | 207| 530| pStream->data_type = 0; 208| 530| pStream->adler = MZ_ADLER32_INIT; ------------------ | | 240| 530|#define MZ_ADLER32_INIT (1) ------------------ 209| 530| pStream->msg = NULL; 210| 530| pStream->reserved = 0; 211| 530| pStream->total_in = 0; 212| 530| pStream->total_out = 0; 213| 530| if (!pStream->zalloc) ------------------ | Branch (213:9): [True: 530, False: 0] ------------------ 214| 530| pStream->zalloc = miniz_def_alloc_func; 215| 530| if (!pStream->zfree) ------------------ | Branch (215:9): [True: 530, False: 0] ------------------ 216| 530| pStream->zfree = miniz_def_free_func; 217| | 218| 530| pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor)); 219| 530| if (!pComp) ------------------ | Branch (219:9): [True: 0, False: 530] ------------------ 220| 0| return MZ_MEM_ERROR; 221| | 222| 530| pStream->state = (struct mz_internal_state *)pComp; 223| | 224| 530| if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY) ------------------ | Branch (224:9): [True: 0, False: 530] ------------------ 225| 0| { 226| 0| mz_deflateEnd(pStream); 227| 0| return MZ_PARAM_ERROR; 228| 0| } 229| | 230| 530| return MZ_OK; 231| 530|} mz_deflate: 243| 1.59k|{ 244| 1.59k| size_t in_bytes, out_bytes; 245| 1.59k| mz_ulong orig_total_in, orig_total_out; 246| 1.59k| int mz_status = MZ_OK; 247| | 248| 1.59k| if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) ------------------ | Branch (248:9): [True: 0, False: 1.59k] | Branch (248:23): [True: 0, False: 1.59k] | Branch (248:44): [True: 0, False: 1.59k] | Branch (248:59): [True: 0, False: 1.59k] | Branch (248:82): [True: 0, False: 1.59k] ------------------ 249| 0| return MZ_STREAM_ERROR; 250| 1.59k| if (!pStream->avail_out) ------------------ | Branch (250:9): [True: 0, False: 1.59k] ------------------ 251| 0| return MZ_BUF_ERROR; 252| | 253| 1.59k| if (flush == MZ_PARTIAL_FLUSH) ------------------ | Branch (253:9): [True: 0, False: 1.59k] ------------------ 254| 0| flush = MZ_SYNC_FLUSH; 255| | 256| 1.59k| if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE) ------------------ | Branch (256:9): [True: 0, False: 1.59k] ------------------ 257| 0| return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR; ------------------ | Branch (257:16): [True: 0, False: 0] ------------------ 258| | 259| 1.59k| orig_total_in = pStream->total_in; 260| 1.59k| orig_total_out = pStream->total_out; 261| 1.59k| for (;;) 262| 1.59k| { 263| 1.59k| tdefl_status defl_status; 264| 1.59k| in_bytes = pStream->avail_in; 265| 1.59k| out_bytes = pStream->avail_out; 266| | 267| 1.59k| defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush); 268| 1.59k| pStream->next_in += (mz_uint)in_bytes; 269| 1.59k| pStream->avail_in -= (mz_uint)in_bytes; 270| 1.59k| pStream->total_in += (mz_uint)in_bytes; 271| 1.59k| pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state); 272| | 273| 1.59k| pStream->next_out += (mz_uint)out_bytes; 274| 1.59k| pStream->avail_out -= (mz_uint)out_bytes; 275| 1.59k| pStream->total_out += (mz_uint)out_bytes; 276| | 277| 1.59k| if (defl_status < 0) ------------------ | Branch (277:13): [True: 0, False: 1.59k] ------------------ 278| 0| { 279| 0| mz_status = MZ_STREAM_ERROR; 280| 0| break; 281| 0| } 282| 1.59k| else if (defl_status == TDEFL_STATUS_DONE) ------------------ | Branch (282:18): [True: 530, False: 1.06k] ------------------ 283| 530| { 284| 530| mz_status = MZ_STREAM_END; 285| 530| break; 286| 530| } 287| 1.06k| else if (!pStream->avail_out) ------------------ | Branch (287:18): [True: 0, False: 1.06k] ------------------ 288| 0| break; 289| 1.06k| else if ((!pStream->avail_in) && (flush != MZ_FINISH)) ------------------ | Branch (289:18): [True: 1.06k, False: 0] | Branch (289:42): [True: 1.06k, False: 0] ------------------ 290| 1.06k| { 291| 1.06k| if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) ------------------ | Branch (291:17): [True: 0, False: 1.06k] | Branch (291:28): [True: 530, False: 530] | Branch (291:68): [True: 0, False: 530] ------------------ 292| 530| break; 293| 530| return MZ_BUF_ERROR; /* Can't make forward progress without some input. 294| | */ 295| 1.06k| } 296| 1.59k| } 297| 1.06k| return mz_status; 298| 1.59k|} mz_deflateEnd: 301| 530|{ 302| 530| if (!pStream) ------------------ | Branch (302:9): [True: 0, False: 530] ------------------ 303| 0| return MZ_STREAM_ERROR; 304| 530| if (pStream->state) ------------------ | Branch (304:9): [True: 530, False: 0] ------------------ 305| 530| { 306| 530| pStream->zfree(pStream->opaque, pStream->state); 307| 530| pStream->state = NULL; 308| 530| } 309| 530| return MZ_OK; 310| 530|} mz_inflateInit2: 373| 530|{ 374| 530| inflate_state *pDecomp; 375| 530| if (!pStream) ------------------ | Branch (375:9): [True: 0, False: 530] ------------------ 376| 0| return MZ_STREAM_ERROR; 377| 530| if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) ------------------ | | 314| 530|#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: 530] | Branch (377:52): [True: 0, False: 0] ------------------ 378| 0| return MZ_PARAM_ERROR; 379| | 380| 530| pStream->data_type = 0; 381| 530| pStream->adler = 0; 382| 530| pStream->msg = NULL; 383| 530| pStream->total_in = 0; 384| 530| pStream->total_out = 0; 385| 530| pStream->reserved = 0; 386| 530| if (!pStream->zalloc) ------------------ | Branch (386:9): [True: 530, False: 0] ------------------ 387| 530| pStream->zalloc = miniz_def_alloc_func; 388| 530| if (!pStream->zfree) ------------------ | Branch (388:9): [True: 530, False: 0] ------------------ 389| 530| pStream->zfree = miniz_def_free_func; 390| | 391| 530| pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state)); 392| 530| if (!pDecomp) ------------------ | Branch (392:9): [True: 0, False: 530] ------------------ 393| 0| return MZ_MEM_ERROR; 394| | 395| 530| pStream->state = (struct mz_internal_state *)pDecomp; 396| | 397| 530| tinfl_init(&pDecomp->m_decomp); ------------------ | | 918| 530| do \ | | 919| 530| { \ | | 920| 530| (r)->m_state = 0; \ | | 921| 530| } \ | | 922| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 398| 530| pDecomp->m_dict_ofs = 0; 399| 530| pDecomp->m_dict_avail = 0; 400| 530| pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; 401| 530| pDecomp->m_first_call = 1; 402| 530| pDecomp->m_has_flushed = 0; 403| 530| pDecomp->m_window_bits = window_bits; 404| | 405| 530| return MZ_OK; 406| 530|} mz_inflateInit: 409| 530|{ 410| 530| return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS); ------------------ | | 314| 530|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ 411| 530|} mz_inflate: 440| 530|{ 441| 530| inflate_state *pState; 442| 530| mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32; 443| 530| size_t in_bytes, out_bytes, orig_avail_in; 444| 530| tinfl_status status; 445| | 446| 530| if ((!pStream) || (!pStream->state)) ------------------ | Branch (446:9): [True: 0, False: 530] | Branch (446:23): [True: 0, False: 530] ------------------ 447| 0| return MZ_STREAM_ERROR; 448| 530| if (flush == MZ_PARTIAL_FLUSH) ------------------ | Branch (448:9): [True: 0, False: 530] ------------------ 449| 0| flush = MZ_SYNC_FLUSH; 450| 530| if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) ------------------ | Branch (450:9): [True: 0, False: 530] | Branch (450:20): [True: 0, False: 0] | Branch (450:48): [True: 0, False: 0] ------------------ 451| 0| return MZ_STREAM_ERROR; 452| | 453| 530| pState = (inflate_state *)pStream->state; 454| 530| if (pState->m_window_bits > 0) ------------------ | Branch (454:9): [True: 530, False: 0] ------------------ 455| 530| decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER; 456| 530| orig_avail_in = pStream->avail_in; 457| | 458| 530| first_call = pState->m_first_call; 459| 530| pState->m_first_call = 0; 460| 530| if (pState->m_last_status < 0) ------------------ | Branch (460:9): [True: 0, False: 530] ------------------ 461| 0| return MZ_DATA_ERROR; 462| | 463| 530| if (pState->m_has_flushed && (flush != MZ_FINISH)) ------------------ | Branch (463:9): [True: 0, False: 530] | Branch (463:34): [True: 0, False: 0] ------------------ 464| 0| return MZ_STREAM_ERROR; 465| 530| pState->m_has_flushed |= (flush == MZ_FINISH); 466| | 467| 530| if ((flush == MZ_FINISH) && (first_call)) ------------------ | Branch (467:9): [True: 0, False: 530] | 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| 530| if (flush != MZ_FINISH) ------------------ | Branch (493:9): [True: 530, False: 0] ------------------ 494| 530| decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT; 495| | 496| 530| if (pState->m_dict_avail) ------------------ | Branch (496:9): [True: 0, False: 530] ------------------ 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| 530| for (;;) 509| 2.88k| { 510| 2.88k| in_bytes = pStream->avail_in; 511| 2.88k| out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs; ------------------ | | 880| 2.88k|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 512| | 513| 2.88k| 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| 2.88k| pState->m_last_status = status; 515| | 516| 2.88k| pStream->next_in += (mz_uint)in_bytes; 517| 2.88k| pStream->avail_in -= (mz_uint)in_bytes; 518| 2.88k| pStream->total_in += (mz_uint)in_bytes; 519| 2.88k| pStream->adler = tinfl_get_adler32(&pState->m_decomp); ------------------ | | 923| 2.88k|#define tinfl_get_adler32(r) (r)->m_check_adler32 ------------------ 520| | 521| 2.88k| pState->m_dict_avail = (mz_uint)out_bytes; 522| | 523| 2.88k| n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); ------------------ | | 595| 2.88k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 2.35k, False: 530] | | ------------------ ------------------ 524| 2.88k| memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); 525| 2.88k| pStream->next_out += n; 526| 2.88k| pStream->avail_out -= n; 527| 2.88k| pStream->total_out += n; 528| 2.88k| pState->m_dict_avail -= n; 529| 2.88k| pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); ------------------ | | 880| 2.88k|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 530| | 531| 2.88k| if (status < 0) ------------------ | Branch (531:13): [True: 0, False: 2.88k] ------------------ 532| 0| return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */ 533| 2.88k| else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) ------------------ | Branch (533:18): [True: 0, False: 2.88k] | 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| 2.88k| else if (flush == MZ_FINISH) ------------------ | Branch (535:18): [True: 0, False: 2.88k] ------------------ 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| 2.88k| else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) ------------------ | Branch (544:18): [True: 530, False: 2.35k] | Branch (544:51): [True: 0, False: 2.35k] | Branch (544:75): [True: 0, False: 2.35k] | Branch (544:100): [True: 0, False: 2.35k] ------------------ 545| 530| break; 546| 2.88k| } 547| | 548| 530| return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; ------------------ | Branch (548:13): [True: 530, False: 0] | Branch (548:46): [True: 530, False: 0] ------------------ 549| 530|} mz_inflateEnd: 552| 530|{ 553| 530| if (!pStream) ------------------ | Branch (553:9): [True: 0, False: 530] ------------------ 554| 0| return MZ_STREAM_ERROR; 555| 530| if (pStream->state) ------------------ | Branch (555:9): [True: 530, False: 0] ------------------ 556| 530| { 557| 530| pStream->zfree(pStream->opaque, pStream->state); 558| 530| pStream->state = NULL; 559| 530| } 560| 530| return MZ_OK; 561| 530|} tdefl_compress: 1919| 1.59k|{ 1920| 1.59k| if (!d) ------------------ | Branch (1920:9): [True: 0, False: 1.59k] ------------------ 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.59k| d->m_pIn_buf = pIn_buf; 1930| 1.59k| d->m_pIn_buf_size = pIn_buf_size; 1931| 1.59k| d->m_pOut_buf = pOut_buf; 1932| 1.59k| d->m_pOut_buf_size = pOut_buf_size; 1933| 1.59k| d->m_pSrc = (const mz_uint8 *)(pIn_buf); 1934| 1.59k| d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; ------------------ | Branch (1934:25): [True: 1.59k, False: 0] ------------------ 1935| 1.59k| d->m_out_buf_ofs = 0; 1936| 1.59k| d->m_flush = flush; 1937| | 1938| 1.59k| 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.59k] | Branch (1938:43): [True: 1.59k, False: 0] | Branch (1938:65): [True: 0, False: 0] | Branch (1938:94): [True: 0, False: 1.59k] ------------------ 1939| 1.59k| (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.59k] | Branch (1939:34): [True: 0, False: 0] | Branch (1939:63): [True: 1.59k, False: 0] | Branch (1939:79): [True: 530, False: 1.06k] | Branch (1939:96): [True: 0, False: 530] | Branch (1939:110): [True: 1.59k, False: 0] | Branch (1939:127): [True: 1.59k, False: 0] | Branch (1939:145): [True: 0, False: 1.59k] ------------------ 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.59k| d->m_wants_to_finish |= (flush == TDEFL_FINISH); 1948| | 1949| 1.59k| if ((d->m_output_flush_remaining) || (d->m_finished)) ------------------ | Branch (1949:9): [True: 0, False: 1.59k] | Branch (1949:42): [True: 0, False: 1.59k] ------------------ 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.59k| { 1963| 1.59k| if (!tdefl_compress_normal(d)) ------------------ | Branch (1963:13): [True: 0, False: 1.59k] ------------------ 1964| 0| return d->m_prev_return_status; 1965| 1.59k| } 1966| | 1967| 1.59k| if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf)) ------------------ | Branch (1967:9): [True: 1.59k, False: 0] | Branch (1967:77): [True: 1.59k, False: 0] ------------------ 1968| 1.59k| 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.59k| if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) ------------------ | Branch (1970:9): [True: 530, False: 1.06k] | Branch (1970:20): [True: 530, False: 0] | Branch (1970:46): [True: 530, False: 0] | Branch (1970:70): [True: 530, False: 0] ------------------ 1971| 530| { 1972| 530| if (tdefl_flush_block(d, flush) < 0) ------------------ | Branch (1972:13): [True: 0, False: 530] ------------------ 1973| 0| return d->m_prev_return_status; 1974| 530| d->m_finished = (flush == TDEFL_FINISH); 1975| 530| if (flush == TDEFL_FULL_FLUSH) ------------------ | Branch (1975:13): [True: 0, False: 530] ------------------ 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| 530| } 1982| | 1983| 1.59k| return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); 1984| 1.59k|} tdefl_init: 1993| 530|{ 1994| 530| d->m_pPut_buf_func = pPut_buf_func; 1995| 530| d->m_pPut_buf_user = pPut_buf_user; 1996| 530| d->m_flags = (mz_uint)(flags); 1997| 530| d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; 1998| 530| d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0; 1999| 530| d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3; 2000| 530| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (2000:9): [True: 530, False: 0] ------------------ 2001| 530| MZ_CLEAR_ARR(d->m_hash); ------------------ | | 597| 530|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2002| 530| 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| 530| 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| 530| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 2005| 530| d->m_pLZ_flags = d->m_lz_code_buf; 2006| 530| *d->m_pLZ_flags = 0; 2007| 530| d->m_num_flags_left = 8; 2008| 530| d->m_pOutput_buf = d->m_output_buf; 2009| 530| d->m_pOutput_buf_end = d->m_output_buf; 2010| 530| d->m_prev_return_status = TDEFL_STATUS_OKAY; 2011| 530| d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; 2012| 530| d->m_adler32 = 1; 2013| 530| d->m_pIn_buf = NULL; 2014| 530| d->m_pOut_buf = NULL; 2015| 530| d->m_pIn_buf_size = NULL; 2016| 530| d->m_pOut_buf_size = NULL; 2017| 530| d->m_flush = TDEFL_NO_FLUSH; 2018| 530| d->m_pSrc = NULL; 2019| 530| d->m_src_buf_left = 0; 2020| 530| d->m_out_buf_ofs = 0; 2021| 530| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (2021:9): [True: 530, False: 0] ------------------ 2022| 530| MZ_CLEAR_ARR(d->m_dict); ------------------ | | 597| 530|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2023| 530| memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 2024| 530| memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 2025| 530| return TDEFL_STATUS_OKAY; 2026| 530|} tdefl_get_adler32: 2034| 1.59k|{ 2035| 1.59k| return d->m_adler32; 2036| 1.59k|} tdefl_create_comp_flags_from_zip_params: 2117| 530|{ 2118| 530| 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| 530|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 0, False: 530] | | ------------------ ------------------ | Branch (2118:45): [True: 530, False: 0] | Branch (2118:101): [True: 0, False: 530] ------------------ 2119| 530| if (window_bits > 0) ------------------ | Branch (2119:9): [True: 530, False: 0] ------------------ 2120| 530| comp_flags |= TDEFL_WRITE_ZLIB_HEADER; 2121| | 2122| 530| if (!level) ------------------ | Branch (2122:9): [True: 0, False: 530] ------------------ 2123| 0| comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; 2124| 530| else if (strategy == MZ_FILTERED) ------------------ | Branch (2124:14): [True: 0, False: 530] ------------------ 2125| 0| comp_flags |= TDEFL_FILTER_MATCHES; 2126| 530| else if (strategy == MZ_HUFFMAN_ONLY) ------------------ | Branch (2126:14): [True: 0, False: 530] ------------------ 2127| 0| comp_flags &= ~TDEFL_MAX_PROBES_MASK; 2128| 530| else if (strategy == MZ_FIXED) ------------------ | Branch (2128:14): [True: 0, False: 530] ------------------ 2129| 0| comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS; 2130| 530| else if (strategy == MZ_RLE) ------------------ | Branch (2130:14): [True: 0, False: 530] ------------------ 2131| 0| comp_flags |= TDEFL_RLE_MATCHES; 2132| | 2133| 530| return comp_flags; 2134| 530|} tinfl_decompress: 2438| 2.88k|{ 2439| 2.88k| 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| 2.88k| 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| 2.88k| 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| 2.88k| 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| 2.88k| 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| 2.88k| static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 }; 2445| | 2446| 2.88k| mz_int16 *pTrees[3]; 2447| 2.88k| mz_uint8 *pCode_sizes[3]; 2448| | 2449| 2.88k| tinfl_status status = TINFL_STATUS_FAILED; 2450| 2.88k| mz_uint32 num_bits, dist, counter, num_extra; 2451| 2.88k| tinfl_bit_buf_t bit_buf; 2452| 2.88k| const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size; 2453| 2.88k| 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: 2.88k, False: 0] ------------------ 2454| 2.88k| 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: 2.88k] ------------------ 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| 2.88k| if ((!pOut_buf_start) || (!pOut_buf_next) || (!pIn_buf_size) || (!pOut_buf_size)) ------------------ | Branch (2457:9): [True: 0, False: 2.88k] | Branch (2457:30): [True: 0, False: 2.88k] | Branch (2457:50): [True: 0, False: 2.88k] | Branch (2457:69): [True: 0, False: 2.88k] ------------------ 2458| 0| { 2459| 0| return TINFL_STATUS_BAD_PARAM; 2460| 0| } 2461| 2.88k| if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) ------------------ | Branch (2461:9): [True: 0, False: 2.88k] | Branch (2461:58): [True: 0, False: 2.88k] ------------------ 2462| 0| { 2463| 0| *pIn_buf_size = *pOut_buf_size = 0; 2464| 0| return TINFL_STATUS_BAD_PARAM; 2465| 0| } 2466| | 2467| 2.88k| pTrees[0] = r->m_tree_0; 2468| 2.88k| pTrees[1] = r->m_tree_1; 2469| 2.88k| pTrees[2] = r->m_tree_2; 2470| 2.88k| pCode_sizes[0] = r->m_code_size_0; 2471| 2.88k| pCode_sizes[1] = r->m_code_size_1; 2472| 2.88k| pCode_sizes[2] = r->m_code_size_2; 2473| | 2474| 2.88k| num_bits = r->m_num_bits; 2475| 2.88k| bit_buf = r->m_bit_buf; 2476| 2.88k| dist = r->m_dist; 2477| 2.88k| counter = r->m_counter; 2478| 2.88k| num_extra = r->m_num_extra; 2479| 2.88k| dist_from_out_buf_start = r->m_dist_from_out_buf_start; 2480| 2.88k| TINFL_CR_BEGIN ------------------ | | 2292| 5.77k| switch (r->m_state) \ | | ------------------ | | | Branch (2292:13): [True: 0, False: 2.88k] | | ------------------ | | 2293| 5.77k| { \ | | 2294| 530| case 0: | | ------------------ | | | Branch (2294:9): [True: 530, False: 2.35k] | | ------------------ ------------------ 2481| | 2482| 530| bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; 2483| 530| r->m_z_adler32 = r->m_check_adler32 = 1; 2484| 530| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) ------------------ | Branch (2484:9): [True: 530, False: 0] ------------------ 2485| 530| { 2486| 530| TINFL_GET_BYTE(1, r->m_zhdr0); ------------------ | | 2316| 530| do \ | | 2317| 530| { \ | | 2318| 530| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (2318:16): [True: 0, False: 530] | | ------------------ | | 2319| 530| { \ | | 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: 2.88k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2321| 0| } \ | | 2322| 530| c = *pIn_buf_cur++; \ | | 2323| 530| } \ | | 2324| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2487| 530| TINFL_GET_BYTE(2, r->m_zhdr1); ------------------ | | 2316| 530| do \ | | 2317| 530| { \ | | 2318| 530| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (2318:16): [True: 0, False: 530] | | ------------------ | | 2319| 530| { \ | | 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: 2.88k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2321| 0| } \ | | 2322| 530| c = *pIn_buf_cur++; \ | | 2323| 530| } \ | | 2324| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2488| 530| counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); ------------------ | Branch (2488:20): [True: 0, False: 530] | Branch (2488:67): [True: 0, False: 530] | Branch (2488:88): [True: 0, False: 530] ------------------ 2489| 530| if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) ------------------ | Branch (2489:13): [True: 530, False: 0] ------------------ 2490| 530| counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4))))); ------------------ | Branch (2490:25): [True: 0, False: 530] | Branch (2490:72): [True: 0, False: 530] ------------------ 2491| 530| if (counter) ------------------ | Branch (2491:13): [True: 0, False: 530] ------------------ 2492| 0| { 2493| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2494| 0| } 2495| 530| } 2496| | 2497| 530| do 2498| 530| { 2499| 530| TINFL_GET_BITS(3, r->m_final, 3); ------------------ | | 2346| 530| do \ | | 2347| 530| { \ | | 2348| 530| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 530, False: 0] | | ------------------ | | 2349| 530| { \ | | 2350| 530| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 530| do \ | | | | 2328| 530| { \ | | | | 2329| 530| mz_uint c; \ | | | | 2330| 530| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 530| do \ | | | | | | 2317| 530| { \ | | | | | | 2318| 530| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 530] | | | | | | ------------------ | | | | | | 2319| 530| { \ | | | | | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 530| c = *pIn_buf_cur++; \ | | | | | | 2323| 530| } \ | | | | | | 2324| 530| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 530| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 530| num_bits += 8; \ | | | | 2333| 530| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 530] | | | | ------------------ | | ------------------ | | 2351| 530| } \ | | 2352| 530| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 530| bit_buf >>= (n); \ | | 2354| 530| num_bits -= (n); \ | | 2355| 530| } \ | | 2356| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2500| 530| r->m_type = r->m_final >> 1; 2501| 530| if (r->m_type == 0) ------------------ | Branch (2501:13): [True: 0, False: 530] ------------------ 2502| 0| { 2503| 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2504| 0| for (counter = 0; counter < 4; ++counter) ------------------ | Branch (2504:31): [True: 0, False: 0] ------------------ 2505| 0| { 2506| 0| if (num_bits) ------------------ | Branch (2506:21): [True: 0, False: 0] ------------------ 2507| 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2508| 0| else 2509| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2510| 0| } 2511| 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 (2511:17): [True: 0, False: 0] ------------------ 2512| 0| { 2513| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2514| 0| } 2515| 0| while ((counter) && (num_bits)) ------------------ | Branch (2515:20): [True: 0, False: 0] | Branch (2515:33): [True: 0, False: 0] ------------------ 2516| 0| { 2517| 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2518| 0| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2518:24): [True: 0, False: 0] ------------------ 2519| 0| { 2520| 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: 2.88k] | | ------------------ | | 2302| 0| } \ | | 2303| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2521| 0| } 2522| 0| *pOut_buf_cur++ = (mz_uint8)dist; 2523| 0| counter--; 2524| 0| } 2525| 0| while (counter) ------------------ | Branch (2525:20): [True: 0, False: 0] ------------------ 2526| 0| { 2527| 0| size_t n; 2528| 0| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2528:24): [True: 0, False: 0] ------------------ 2529| 0| { 2530| 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: 2.88k] | | ------------------ | | 2302| 0| } \ | | 2303| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2531| 0| } 2532| 0| while (pIn_buf_cur >= pIn_buf_end) ------------------ | Branch (2532:24): [True: 0, False: 0] ------------------ 2533| 0| { 2534| 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: 2.88k] | | ------------------ | | 2302| 0| } \ | | 2303| 0| MZ_MACRO_END | | ------------------ | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2535| 0| } 2536| 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] | | ------------------ ------------------ 2537| 0| TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); ------------------ | | 2288| 0|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 2538| 0| pIn_buf_cur += n; 2539| 0| pOut_buf_cur += n; 2540| 0| counter -= (mz_uint)n; 2541| 0| } 2542| 0| } 2543| 530| else if (r->m_type == 3) ------------------ | Branch (2543:18): [True: 0, False: 530] ------------------ 2544| 0| { 2545| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2546| 0| } 2547| 530| else 2548| 530| { 2549| 530| if (r->m_type == 1) ------------------ | Branch (2549:17): [True: 0, False: 530] ------------------ 2550| 0| { 2551| 0| mz_uint8 *p = r->m_code_size_0; 2552| 0| mz_uint i; 2553| 0| r->m_table_sizes[0] = 288; 2554| 0| r->m_table_sizes[1] = 32; 2555| 0| TINFL_MEMSET(r->m_code_size_1, 5, 32); ------------------ | | 2289| 0|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 2556| 0| for (i = 0; i <= 143; ++i) ------------------ | Branch (2556:29): [True: 0, False: 0] ------------------ 2557| 0| *p++ = 8; 2558| 0| for (; i <= 255; ++i) ------------------ | Branch (2558:24): [True: 0, False: 0] ------------------ 2559| 0| *p++ = 9; 2560| 0| for (; i <= 279; ++i) ------------------ | Branch (2560:24): [True: 0, False: 0] ------------------ 2561| 0| *p++ = 7; 2562| 0| for (; i <= 287; ++i) ------------------ | Branch (2562:24): [True: 0, False: 0] ------------------ 2563| 0| *p++ = 8; 2564| 0| } 2565| 530| else 2566| 530| { 2567| 2.12k| for (counter = 0; counter < 3; counter++) ------------------ | Branch (2567:35): [True: 1.59k, False: 530] ------------------ 2568| 1.59k| { 2569| 1.59k| TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); ------------------ | | 2346| 1.59k| do \ | | 2347| 1.59k| { \ | | 2348| 1.59k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 1.06k, False: 530] | | ------------------ | | 2349| 1.59k| { \ | | 2350| 1.06k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 1.06k| do \ | | | | 2328| 1.06k| { \ | | | | 2329| 1.06k| mz_uint c; \ | | | | 2330| 1.06k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 1.06k| do \ | | | | | | 2317| 1.06k| { \ | | | | | | 2318| 1.06k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 1.06k] | | | | | | ------------------ | | | | | | 2319| 1.06k| { \ | | | | | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 1.06k| c = *pIn_buf_cur++; \ | | | | | | 2323| 1.06k| } \ | | | | | | 2324| 1.06k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 1.06k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 1.06k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 1.06k| num_bits += 8; \ | | | | 2333| 1.06k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 1.06k] | | | | ------------------ | | ------------------ | | 2351| 1.06k| } \ | | 2352| 1.59k| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 1.59k| bit_buf >>= (n); \ | | 2354| 1.59k| num_bits -= (n); \ | | 2355| 1.59k| } \ | | 2356| 1.59k| MZ_MACRO_END | | ------------------ | | | | 561| 1.59k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2570| 1.59k| r->m_table_sizes[counter] += s_min_table_sizes[counter]; 2571| 1.59k| } 2572| 530| MZ_CLEAR_ARR(r->m_code_size_2); ------------------ | | 597| 530|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2573| 10.0k| for (counter = 0; counter < r->m_table_sizes[2]; counter++) ------------------ | Branch (2573:35): [True: 9.54k, False: 530] ------------------ 2574| 9.54k| { 2575| 9.54k| mz_uint s; 2576| 9.54k| TINFL_GET_BITS(14, s, 3); ------------------ | | 2346| 9.54k| do \ | | 2347| 9.54k| { \ | | 2348| 9.54k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 3.18k, False: 6.36k] | | ------------------ | | 2349| 9.54k| { \ | | 2350| 3.18k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 2327| 3.18k| do \ | | | | 2328| 3.18k| { \ | | | | 2329| 3.18k| mz_uint c; \ | | | | 2330| 3.18k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 2316| 3.18k| do \ | | | | | | 2317| 3.18k| { \ | | | | | | 2318| 3.18k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (2318:16): [True: 0, False: 3.18k] | | | | | | ------------------ | | | | | | 2319| 3.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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 2302| 0| } \ | | | | | | | | 2303| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2321| 0| } \ | | | | | | 2322| 3.18k| c = *pIn_buf_cur++; \ | | | | | | 2323| 3.18k| } \ | | | | | | 2324| 3.18k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 561| 3.18k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 2331| 3.18k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 2332| 3.18k| num_bits += 8; \ | | | | 2333| 3.18k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (2333:14): [True: 0, False: 3.18k] | | | | ------------------ | | ------------------ | | 2351| 3.18k| } \ | | 2352| 9.54k| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 9.54k| bit_buf >>= (n); \ | | 2354| 9.54k| num_bits -= (n); \ | | 2355| 9.54k| } \ | | 2356| 9.54k| MZ_MACRO_END | | ------------------ | | | | 561| 9.54k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2577| 9.54k| r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s; 2578| 9.54k| } 2579| 530| r->m_table_sizes[2] = 19; 2580| 530| } 2581| 2.12k| for (; (int)r->m_type >= 0; r->m_type--) ------------------ | Branch (2581:20): [True: 1.59k, False: 530] ------------------ 2582| 1.59k| { 2583| 1.59k| int tree_next, tree_cur; 2584| 1.59k| mz_int16 *pLookUp; 2585| 1.59k| mz_int16 *pTree; 2586| 1.59k| mz_uint8 *pCode_size; 2587| 1.59k| mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; 2588| 1.59k| pLookUp = r->m_look_up[r->m_type]; 2589| 1.59k| pTree = pTrees[r->m_type]; 2590| 1.59k| pCode_size = pCode_sizes[r->m_type]; 2591| 1.59k| MZ_CLEAR_ARR(total_syms); ------------------ | | 597| 1.59k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2592| 1.59k| TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0])); ------------------ | | 2289| 1.59k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 2593| 1.59k| tinfl_clear_tree(r); 2594| 163k| for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) ------------------ | Branch (2594:29): [True: 162k, False: 1.59k] ------------------ 2595| 162k| total_syms[pCode_size[i]]++; 2596| 1.59k| used_syms = 0, total = 0; 2597| 1.59k| next_code[0] = next_code[1] = 0; 2598| 25.4k| for (i = 1; i <= 15; ++i) ------------------ | Branch (2598:29): [True: 23.8k, False: 1.59k] ------------------ 2599| 23.8k| { 2600| 23.8k| used_syms += total_syms[i]; 2601| 23.8k| next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); 2602| 23.8k| } 2603| 1.59k| if ((65536 != total) && (used_syms > 1)) ------------------ | Branch (2603:21): [True: 530, False: 1.06k] | Branch (2603:41): [True: 0, False: 530] ------------------ 2604| 0| { 2605| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2606| 0| } 2607| 163k| for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index) ------------------ | Branch (2607:53): [True: 162k, False: 1.59k] ------------------ 2608| 162k| { 2609| 162k| mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index]; 2610| 162k| if (!code_size) ------------------ | Branch (2610:25): [True: 157k, False: 4.82k] ------------------ 2611| 157k| continue; 2612| 4.82k| cur_code = next_code[code_size]++; 2613| 14.7k| for (l = code_size; l > 0; l--, cur_code >>= 1) ------------------ | Branch (2613:41): [True: 9.90k, False: 4.82k] ------------------ 2614| 9.90k| rev_code = (rev_code << 1) | (cur_code & 1); 2615| 4.82k| if (code_size <= TINFL_FAST_LOOKUP_BITS) ------------------ | Branch (2615:25): [True: 4.82k, False: 0] ------------------ 2616| 4.82k| { 2617| 4.82k| mz_int16 k = (mz_int16)((code_size << 9) | sym_index); 2618| 1.36M| while (rev_code < TINFL_FAST_LOOKUP_SIZE) ------------------ | Branch (2618:32): [True: 1.35M, False: 4.82k] ------------------ 2619| 1.35M| { 2620| 1.35M| pLookUp[rev_code] = k; 2621| 1.35M| rev_code += (1 << code_size); 2622| 1.35M| } 2623| 4.82k| continue; 2624| 4.82k| } 2625| 0| if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) ------------------ | Branch (2625:25): [True: 0, False: 0] ------------------ 2626| 0| { 2627| 0| pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; 2628| 0| tree_cur = tree_next; 2629| 0| tree_next -= 2; 2630| 0| } 2631| 0| rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1); 2632| 0| for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) ------------------ | Branch (2632:41): [True: 0, False: 0] ------------------ 2633| 0| { 2634| 0| tree_cur -= ((rev_code >>= 1) & 1); 2635| 0| if (!pTree[-tree_cur - 1]) ------------------ | Branch (2635:29): [True: 0, False: 0] ------------------ 2636| 0| { 2637| 0| pTree[-tree_cur - 1] = (mz_int16)tree_next; 2638| 0| tree_cur = tree_next; 2639| 0| tree_next -= 2; 2640| 0| } 2641| 0| else 2642| 0| tree_cur = pTree[-tree_cur - 1]; 2643| 0| } 2644| 0| tree_cur -= ((rev_code >>= 1) & 1); 2645| 0| pTree[-tree_cur - 1] = (mz_int16)sym_index; 2646| 0| } 2647| 1.59k| if (r->m_type == 2) ------------------ | Branch (2647:21): [True: 530, False: 1.06k] ------------------ 2648| 530| { 2649| 5.10k| for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) ------------------ | Branch (2649:39): [True: 4.57k, False: 530] ------------------ 2650| 4.57k| { 2651| 4.57k| mz_uint s; 2652| 4.57k| TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); ------------------ | | 2394| 4.57k| do \ | | 2395| 4.57k| { \ | | 2396| 4.57k| int temp; \ | | 2397| 4.57k| mz_uint code_len, c; \ | | 2398| 4.57k| if (num_bits < 15) \ | | ------------------ | | | Branch (2398:13): [True: 2.00k, False: 2.56k] | | ------------------ | | 2399| 4.57k| { \ | | 2400| 2.00k| if ((pIn_buf_end - pIn_buf_cur) < 2) \ | | ------------------ | | | Branch (2400:17): [True: 0, False: 2.00k] | | ------------------ | | 2401| 2.00k| { \ | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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.00k| else \ | | 2405| 2.00k| { \ | | 2406| 2.00k| 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.00k| pIn_buf_cur += 2; \ | | 2408| 2.00k| num_bits += 16; \ | | 2409| 2.00k| } \ | | 2410| 2.00k| } \ | | 2411| 4.57k| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (2411:13): [True: 4.57k, False: 0] | | ------------------ | | 2412| 4.57k| code_len = temp >> 9, temp &= 511; \ | | 2413| 4.57k| else \ | | 2414| 4.57k| { \ | | 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.57k| sym = temp; \ | | 2422| 4.57k| bit_buf >>= code_len; \ | | 2423| 4.57k| num_bits -= code_len; \ | | 2424| 4.57k| } \ | | 2425| 4.57k| MZ_MACRO_END | | ------------------ | | | | 561| 4.57k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2653| 4.57k| if (dist < 16) ------------------ | Branch (2653:29): [True: 2.72k, False: 1.85k] ------------------ 2654| 2.72k| { 2655| 2.72k| r->m_len_codes[counter++] = (mz_uint8)dist; 2656| 2.72k| continue; 2657| 2.72k| } 2658| 1.85k| if ((dist == 16) && (!counter)) ------------------ | Branch (2658:29): [True: 0, False: 1.85k] | Branch (2658:45): [True: 0, False: 0] ------------------ 2659| 0| { 2660| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2661| 0| } 2662| 1.85k| num_extra = "\02\03\07"[dist - 16]; 2663| 1.85k| TINFL_GET_BITS(18, s, num_extra); ------------------ | | 2346| 1.85k| do \ | | 2347| 1.85k| { \ | | 2348| 1.85k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 1.85k] | | ------------------ | | 2349| 1.85k| { \ | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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.85k| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 1.85k| bit_buf >>= (n); \ | | 2354| 1.85k| num_bits -= (n); \ | | 2355| 1.85k| } \ | | 2356| 1.85k| MZ_MACRO_END | | ------------------ | | | | 561| 1.85k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2664| 1.85k| s += "\03\03\013"[dist - 16]; 2665| 1.85k| TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); ------------------ | | 2289| 3.70k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) | | ------------------ | | | Branch (2289:41): [True: 0, False: 1.85k] | | ------------------ ------------------ 2666| 1.85k| counter += s; 2667| 1.85k| } 2668| 530| if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) ------------------ | Branch (2668:25): [True: 0, False: 530] ------------------ 2669| 0| { 2670| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2671| 0| } 2672| 530| TINFL_MEMCPY(r->m_code_size_0, r->m_len_codes, r->m_table_sizes[0]); ------------------ | | 2288| 530|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 2673| 530| TINFL_MEMCPY(r->m_code_size_1, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]); ------------------ | | 2288| 530|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 2674| 530| } 2675| 1.59k| } 2676| 530| for (;;) 2677| 318k| { 2678| 318k| mz_uint8 *pSrc; 2679| 318k| for (;;) 2680| 319k| { 2681| 319k| if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) ------------------ | Branch (2681:25): [True: 0, False: 319k] | Branch (2681:62): [True: 252, False: 318k] ------------------ 2682| 252| { 2683| 252| TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); ------------------ | | 2394| 252| do \ | | 2395| 252| { \ | | 2396| 252| int temp; \ | | 2397| 252| mz_uint code_len, c; \ | | 2398| 252| if (num_bits < 15) \ | | ------------------ | | | Branch (2398:13): [True: 0, False: 252] | | ------------------ | | 2399| 252| { \ | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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| 252| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (2411:13): [True: 252, False: 0] | | ------------------ | | 2412| 252| code_len = temp >> 9, temp &= 511; \ | | 2413| 252| else \ | | 2414| 252| { \ | | 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| 252| sym = temp; \ | | 2422| 252| bit_buf >>= code_len; \ | | 2423| 252| num_bits -= code_len; \ | | 2424| 252| } \ | | 2425| 252| MZ_MACRO_END | | ------------------ | | | | 561| 252|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2684| 252| if (counter >= 256) ------------------ | Branch (2684:29): [True: 251, False: 1] ------------------ 2685| 251| break; 2686| 2| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2686:32): [True: 1, False: 1] ------------------ 2687| 1| { 2688| 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: 2.88k] | | ------------------ | | 2302| 1| } \ | | 2303| 1| MZ_MACRO_END | | ------------------ | | | | 561| 1|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2689| 1| } 2690| 1| *pOut_buf_cur++ = (mz_uint8)counter; 2691| 1| } 2692| 318k| else 2693| 318k| { 2694| 318k| int sym2; 2695| 318k| mz_uint code_len; 2696| 318k|#if TINFL_USE_64BIT_BITBUF 2697| 318k| if (num_bits < 30) ------------------ | Branch (2697:29): [True: 22.9k, False: 296k] ------------------ 2698| 22.9k| { 2699| 22.9k| bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); ------------------ | | 605| 22.9k|#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)) ------------------ 2700| 22.9k| pIn_buf_cur += 4; 2701| 22.9k| num_bits += 32; 2702| 22.9k| } 2703| |#else 2704| | if (num_bits < 15) 2705| | { 2706| | bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 2707| | pIn_buf_cur += 2; 2708| | num_bits += 16; 2709| | } 2710| |#endif 2711| 318k| if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) ------------------ | Branch (2711:29): [True: 318k, False: 0] ------------------ 2712| 318k| code_len = sym2 >> 9; 2713| 0| else 2714| 0| { 2715| 0| code_len = TINFL_FAST_LOOKUP_BITS; 2716| 0| do 2717| 0| { 2718| 0| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 2719| 0| } while (sym2 < 0); ------------------ | Branch (2719:38): [True: 0, False: 0] ------------------ 2720| 0| } 2721| 318k| counter = sym2; 2722| 318k| bit_buf >>= code_len; 2723| 318k| num_bits -= code_len; 2724| 318k| if (counter & 256) ------------------ | Branch (2724:29): [True: 318k, False: 601] ------------------ 2725| 318k| break; 2726| | 2727| |#if !TINFL_USE_64BIT_BITBUF 2728| | if (num_bits < 15) 2729| | { 2730| | bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 2731| | pIn_buf_cur += 2; 2732| | num_bits += 16; 2733| | } 2734| |#endif 2735| 601| if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) ------------------ | Branch (2735:29): [True: 601, False: 0] ------------------ 2736| 601| code_len = sym2 >> 9; 2737| 0| else 2738| 0| { 2739| 0| code_len = TINFL_FAST_LOOKUP_BITS; 2740| 0| do 2741| 0| { 2742| 0| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 2743| 0| } while (sym2 < 0); ------------------ | Branch (2743:38): [True: 0, False: 0] ------------------ 2744| 0| } 2745| 601| bit_buf >>= code_len; 2746| 601| num_bits -= code_len; 2747| | 2748| 601| pOut_buf_cur[0] = (mz_uint8)counter; 2749| 601| if (sym2 & 256) ------------------ | Branch (2749:29): [True: 1, False: 600] ------------------ 2750| 1| { 2751| 1| pOut_buf_cur++; 2752| 1| counter = sym2; 2753| 1| break; 2754| 1| } 2755| 600| pOut_buf_cur[1] = (mz_uint8)sym2; 2756| 600| pOut_buf_cur += 2; 2757| 600| } 2758| 319k| } 2759| 318k| if ((counter &= 511) == 256) ------------------ | Branch (2759:21): [True: 530, False: 318k] ------------------ 2760| 530| break; 2761| | 2762| 318k| num_extra = s_length_extra[counter - 257]; 2763| 318k| counter = s_length_base[counter - 257]; 2764| 318k| if (num_extra) ------------------ | Branch (2764:21): [True: 398, False: 317k] ------------------ 2765| 398| { 2766| 398| mz_uint extra_bits; 2767| 398| TINFL_GET_BITS(25, extra_bits, num_extra); ------------------ | | 2346| 398| do \ | | 2347| 398| { \ | | 2348| 398| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2348:13): [True: 0, False: 398] | | ------------------ | | 2349| 398| { \ | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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| 398| b = bit_buf & ((1 << (n)) - 1); \ | | 2353| 398| bit_buf >>= (n); \ | | 2354| 398| num_bits -= (n); \ | | 2355| 398| } \ | | 2356| 398| MZ_MACRO_END | | ------------------ | | | | 561| 398|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2768| 398| counter += extra_bits; 2769| 398| } 2770| | 2771| 318k| TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); ------------------ | | 2394| 318k| do \ | | 2395| 318k| { \ | | 2396| 318k| int temp; \ | | 2397| 318k| mz_uint code_len, c; \ | | 2398| 318k| if (num_bits < 15) \ | | ------------------ | | | Branch (2398:13): [True: 0, False: 318k] | | ------------------ | | 2399| 318k| { \ | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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| 318k| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (2411:13): [True: 318k, False: 0] | | ------------------ | | 2412| 318k| code_len = temp >> 9, temp &= 511; \ | | 2413| 318k| else \ | | 2414| 318k| { \ | | 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| 318k| sym = temp; \ | | 2422| 318k| bit_buf >>= code_len; \ | | 2423| 318k| num_bits -= code_len; \ | | 2424| 318k| } \ | | 2425| 318k| MZ_MACRO_END | | ------------------ | | | | 561| 318k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2772| 318k| num_extra = s_dist_extra[dist]; 2773| 318k| dist = s_dist_base[dist]; 2774| 318k| if (num_extra) ------------------ | Branch (2774:21): [True: 0, False: 318k] ------------------ 2775| 0| { 2776| 0| mz_uint extra_bits; 2777| 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2778| 0| dist += extra_bits; 2779| 0| } 2780| | 2781| 318k| dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start; 2782| 318k| 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 (2782:22): [True: 0, False: 318k] | Branch (2782:35): [True: 0, False: 318k] | Branch (2782:69): [True: 0, False: 318k] | Branch (2782:102): [True: 0, False: 0] ------------------ 2783| 0| { 2784| 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: 2.88k] | | | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2785| 0| } 2786| | 2787| 318k| pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask); 2788| | 2789| 318k| if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) ------------------ | | 594| 318k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (594:23): [True: 318k, False: 0] | | ------------------ ------------------ | Branch (2789:21): [True: 2.35k, False: 315k] ------------------ 2790| 2.35k| { 2791| 598k| while (counter--) ------------------ | Branch (2791:28): [True: 595k, False: 2.35k] ------------------ 2792| 595k| { 2793| 598k| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (2793:32): [True: 2.35k, False: 595k] ------------------ 2794| 2.35k| { 2795| 2.35k| TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 2296| 2.35k| do \ | | 2297| 2.35k| { \ | | 2298| 2.35k| status = result; \ | | 2299| 2.35k| r->m_state = state_index; \ | | 2300| 2.35k| goto common_exit; \ | | 2301| 2.35k| case state_index:; \ | | ------------------ | | | Branch (2301:9): [True: 2.35k, False: 531] | | ------------------ | | 2302| 2.35k| } \ | | 2303| 2.35k| MZ_MACRO_END | | ------------------ | | | | 561| 2.35k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2796| 2.35k| } 2797| 595k| *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask]; 2798| 595k| } 2799| 2.35k| continue; 2800| 2.35k| } 2801| |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES 2802| | else if ((counter >= 9) && (counter <= dist)) 2803| | { 2804| | const mz_uint8 *pSrc_end = pSrc + (counter & ~7); 2805| | do 2806| | { 2807| |#ifdef MINIZ_UNALIGNED_USE_MEMCPY 2808| | memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2); 2809| |#else 2810| | ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; 2811| | ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; 2812| |#endif 2813| | pOut_buf_cur += 8; 2814| | } while ((pSrc += 8) < pSrc_end); 2815| | if ((counter &= 7) < 3) 2816| | { 2817| | if (counter) 2818| | { 2819| | pOut_buf_cur[0] = pSrc[0]; 2820| | if (counter > 1) 2821| | pOut_buf_cur[1] = pSrc[1]; 2822| | pOut_buf_cur += counter; 2823| | } 2824| | continue; 2825| | } 2826| | } 2827| |#endif 2828| 27.4M| while(counter>2) ------------------ | Branch (2828:23): [True: 27.1M, False: 315k] ------------------ 2829| 27.1M| { 2830| 27.1M| pOut_buf_cur[0] = pSrc[0]; 2831| 27.1M| pOut_buf_cur[1] = pSrc[1]; 2832| 27.1M| pOut_buf_cur[2] = pSrc[2]; 2833| 27.1M| pOut_buf_cur += 3; 2834| 27.1M| pSrc += 3; 2835| 27.1M| counter -= 3; 2836| 27.1M| } 2837| 315k| if (counter > 0) ------------------ | Branch (2837:21): [True: 392, False: 315k] ------------------ 2838| 392| { 2839| 392| pOut_buf_cur[0] = pSrc[0]; 2840| 392| if (counter > 1) ------------------ | Branch (2840:25): [True: 392, False: 0] ------------------ 2841| 392| pOut_buf_cur[1] = pSrc[1]; 2842| 392| pOut_buf_cur += counter; 2843| 392| } 2844| 315k| } 2845| 530| } 2846| 530| } while (!(r->m_final & 1)); ------------------ | Branch (2846:14): [True: 0, False: 530] ------------------ 2847| | 2848| | /* 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. */ 2849| | /* 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. */ 2850| 530| TINFL_SKIP_BITS(32, num_bits & 7); ------------------ | | 2335| 530| do \ | | 2336| 530| { \ | | 2337| 530| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (2337:13): [True: 0, False: 530] | | ------------------ | | 2338| 530| { \ | | 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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| 530| bit_buf >>= (n); \ | | 2342| 530| num_bits -= (n); \ | | 2343| 530| } \ | | 2344| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2851| 2.96k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) ------------------ | Branch (2851:12): [True: 2.93k, False: 35] | Branch (2851:44): [True: 2.43k, False: 495] ------------------ 2852| 2.43k| { 2853| 2.43k| --pIn_buf_cur; 2854| 2.43k| num_bits -= 8; 2855| 2.43k| } 2856| 530| bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits); 2857| 530| 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| 530|#define MZ_ASSERT(x) assert(x) ------------------ 2858| | 2859| 530| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) ------------------ | Branch (2859:9): [True: 530, False: 0] ------------------ 2860| 530| { 2861| 2.65k| for (counter = 0; counter < 4; ++counter) ------------------ | Branch (2861:27): [True: 2.12k, False: 530] ------------------ 2862| 2.12k| { 2863| 2.12k| mz_uint s; 2864| 2.12k| if (num_bits) ------------------ | Branch (2864:17): [True: 0, False: 2.12k] ------------------ 2865| 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: 2.88k] | | | | | | | | ------------------ | | | | | | | | 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] | | | | ------------------ | | ------------------ ------------------ 2866| 2.12k| else 2867| 2.12k| TINFL_GET_BYTE(42, s); ------------------ | | 2316| 2.12k| do \ | | 2317| 2.12k| { \ | | 2318| 2.12k| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (2318:16): [True: 0, False: 2.12k] | | ------------------ | | 2319| 2.12k| { \ | | 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: 2.88k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2321| 0| } \ | | 2322| 2.12k| c = *pIn_buf_cur++; \ | | 2323| 2.12k| } \ | | 2324| 2.12k| MZ_MACRO_END | | ------------------ | | | | 561| 2.12k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2868| 2.12k| r->m_z_adler32 = (r->m_z_adler32 << 8) | s; 2869| 2.12k| } 2870| 530| } 2871| 2.88k| TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE); ------------------ | | 2305| 530| do \ | | 2306| 530| { \ | | 2307| 530| for (;;) \ | | 2308| 530| { \ | | 2309| 530| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 2296| 530| do \ | | | | 2297| 530| { \ | | | | 2298| 530| status = result; \ | | | | 2299| 530| r->m_state = state_index; \ | | | | 2300| 530| goto common_exit; \ | | | | 2301| 530| case state_index:; \ | | | | ------------------ | | | | | Branch (2301:9): [True: 0, False: 2.88k] | | | | ------------------ | | | | 2302| 0| } \ | | | | 2303| 530| MZ_MACRO_END | | | | ------------------ | | | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (561:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 2310| 530| } \ | | 2311| 530| } \ | | 2312| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2872| | 2873| 2.88k| TINFL_CR_FINISH ------------------ | | 2313| 2.88k|#define TINFL_CR_FINISH } ------------------ 2874| | 2875| 2.88k|common_exit: 2876| | /* As long as we aren't telling the caller that we NEED more input to make forward progress: */ 2877| | /* 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. */ 2878| | /* 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. */ 2879| 2.88k| if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) ------------------ | Branch (2879:9): [True: 2.88k, False: 0] | Branch (2879:54): [True: 2.88k, False: 0] ------------------ 2880| 2.88k| { 2881| 13.2k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) ------------------ | Branch (2881:16): [True: 13.2k, False: 0] | Branch (2881:48): [True: 10.3k, False: 2.88k] ------------------ 2882| 10.3k| { 2883| 10.3k| --pIn_buf_cur; 2884| 10.3k| num_bits -= 8; 2885| 10.3k| } 2886| 2.88k| } 2887| 2.88k| r->m_num_bits = num_bits; 2888| 2.88k| r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits); 2889| 2.88k| r->m_dist = dist; 2890| 2.88k| r->m_counter = counter; 2891| 2.88k| r->m_num_extra = num_extra; 2892| 2.88k| r->m_dist_from_out_buf_start = dist_from_out_buf_start; 2893| 2.88k| *pIn_buf_size = pIn_buf_cur - pIn_buf_next; 2894| 2.88k| *pOut_buf_size = pOut_buf_cur - pOut_buf_next; 2895| 2.88k| if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0)) ------------------ | Branch (2895:9): [True: 2.88k, False: 0] | Branch (2895:89): [True: 2.88k, False: 0] ------------------ 2896| 2.88k| { 2897| 2.88k| const mz_uint8 *ptr = pOut_buf_next; 2898| 2.88k| size_t buf_len = *pOut_buf_size; 2899| 2.88k| mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; 2900| 2.88k| size_t block_len = buf_len % 5552; 2901| 18.2k| while (buf_len) ------------------ | Branch (2901:16): [True: 15.3k, False: 2.88k] ------------------ 2902| 15.3k| { 2903| 10.2M| for (i = 0; i + 7 < block_len; i += 8, ptr += 8) ------------------ | Branch (2903:25): [True: 10.2M, False: 15.3k] ------------------ 2904| 10.2M| { 2905| 10.2M| s1 += ptr[0], s2 += s1; 2906| 10.2M| s1 += ptr[1], s2 += s1; 2907| 10.2M| s1 += ptr[2], s2 += s1; 2908| 10.2M| s1 += ptr[3], s2 += s1; 2909| 10.2M| s1 += ptr[4], s2 += s1; 2910| 10.2M| s1 += ptr[5], s2 += s1; 2911| 10.2M| s1 += ptr[6], s2 += s1; 2912| 10.2M| s1 += ptr[7], s2 += s1; 2913| 10.2M| } 2914| 17.0k| for (; i < block_len; ++i) ------------------ | Branch (2914:20): [True: 1.70k, False: 15.3k] ------------------ 2915| 1.70k| s1 += *ptr++, s2 += s1; 2916| 15.3k| s1 %= 65521U, s2 %= 65521U; 2917| 15.3k| buf_len -= block_len; 2918| 15.3k| block_len = 5552; 2919| 15.3k| } 2920| 2.88k| r->m_check_adler32 = (s2 << 16) + s1; 2921| 2.88k| if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) ------------------ | Branch (2921:13): [True: 530, False: 2.35k] | Branch (2921:46): [True: 530, False: 0] | Branch (2921:95): [True: 0, False: 530] ------------------ 2922| 0| status = TINFL_STATUS_ADLER32_MISMATCH; 2923| 2.88k| } 2924| 2.88k| return status; 2925| 2.88k|} miniz.c:tdefl_flush_output_buffer: 1898| 1.59k|{ 1899| 1.59k| if (d->m_pIn_buf_size) ------------------ | Branch (1899:9): [True: 1.59k, False: 0] ------------------ 1900| 1.59k| { 1901| 1.59k| *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; 1902| 1.59k| } 1903| | 1904| 1.59k| if (d->m_pOut_buf_size) ------------------ | Branch (1904:9): [True: 1.59k, False: 0] ------------------ 1905| 1.59k| { 1906| 1.59k| size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining); ------------------ | | 595| 1.59k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 0, False: 1.59k] | | ------------------ ------------------ 1907| 1.59k| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n); 1908| 1.59k| d->m_output_flush_ofs += (mz_uint)n; 1909| 1.59k| d->m_output_flush_remaining -= (mz_uint)n; 1910| 1.59k| d->m_out_buf_ofs += n; 1911| | 1912| 1.59k| *d->m_pOut_buf_size = d->m_out_buf_ofs; 1913| 1.59k| } 1914| | 1915| 1.59k| return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY; ------------------ | Branch (1915:13): [True: 530, False: 1.06k] | Branch (1915:30): [True: 530, False: 0] ------------------ 1916| 1.59k|} miniz.c:tdefl_compress_normal: 1753| 1.59k|{ 1754| 1.59k| const mz_uint8 *pSrc = d->m_pSrc; 1755| 1.59k| size_t src_buf_left = d->m_src_buf_left; 1756| 1.59k| tdefl_flush flush = d->m_flush; 1757| | 1758| 321k| while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) ------------------ | Branch (1758:12): [True: 319k, False: 1.96k] | Branch (1758:31): [True: 1.43k, False: 531] | Branch (1758:42): [True: 906, False: 530] ------------------ 1759| 320k| { 1760| 320k| 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| 320k| if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) ------------------ | Branch (1762:13): [True: 319k, False: 530] ------------------ 1763| 319k| { 1764| 319k| 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| 319k| 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| 319k| mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size); ------------------ | | 595| 319k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 1.40k, False: 318k] | | ------------------ ------------------ 1767| 319k| const mz_uint8 *pSrc_end = pSrc ? pSrc + num_bytes_to_process : NULL; ------------------ | Branch (1767:40): [True: 319k, False: 0] ------------------ 1768| 319k| src_buf_left -= num_bytes_to_process; 1769| 319k| d->m_lookahead_size += num_bytes_to_process; 1770| 82.1M| while (pSrc != pSrc_end) ------------------ | Branch (1770:20): [True: 81.8M, False: 319k] ------------------ 1771| 81.8M| { 1772| 81.8M| mz_uint8 c = *pSrc++; 1773| 81.8M| d->m_dict[dst_pos] = c; 1774| 81.8M| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (1774:21): [True: 592k, False: 81.2M] ------------------ 1775| 592k| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 1776| 81.8M| hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); 1777| 81.8M| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 1778| 81.8M| d->m_hash[hash] = (mz_uint16)(ins_pos); 1779| 81.8M| dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; 1780| 81.8M| ins_pos++; 1781| 81.8M| } 1782| 319k| } 1783| 530| else 1784| 530| { 1785| 134k| while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) ------------------ | Branch (1785:20): [True: 134k, False: 31] | Branch (1785:38): [True: 133k, False: 499] ------------------ 1786| 133k| { 1787| 133k| mz_uint8 c = *pSrc++; 1788| 133k| mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK; 1789| 133k| src_buf_left--; 1790| 133k| d->m_dict[dst_pos] = c; 1791| 133k| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (1791:21): [True: 133k, False: 499] ------------------ 1792| 133k| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 1793| 133k| if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) ------------------ | Branch (1793:21): [True: 132k, False: 1.06k] ------------------ 1794| 132k| { 1795| 132k| mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2; 1796| 132k| 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| 132k| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 1798| 132k| d->m_hash[hash] = (mz_uint16)(ins_pos); 1799| 132k| } 1800| 133k| } 1801| 530| } 1802| 320k| d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size); ------------------ | | 595| 320k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 278k, False: 41.9k] | | ------------------ ------------------ 1803| 320k| if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) ------------------ | Branch (1803:13): [True: 319k, False: 906] | Branch (1803:25): [True: 529, False: 318k] ------------------ 1804| 529| break; 1805| | 1806| | /* Simple lazy/greedy parsing state machine. */ 1807| 319k| len_to_move = 1; 1808| 319k| cur_match_dist = 0; 1809| 319k| cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); ------------------ | Branch (1809:25): [True: 243, False: 319k] ------------------ 1810| 319k| cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; 1811| 319k| if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) ------------------ | Branch (1811:13): [True: 0, False: 319k] ------------------ 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| 319k| else 1830| 319k| { 1831| 319k| tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len); 1832| 319k| } 1833| 319k| 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: 319k] | Branch (1833:56): [True: 0, False: 0] | Branch (1833:91): [True: 531, False: 319k] | Branch (1833:123): [True: 0, False: 319k] | Branch (1833:162): [True: 0, False: 0] ------------------ 1834| 531| { 1835| 531| cur_match_dist = cur_match_len = 0; 1836| 531| } 1837| 319k| if (d->m_saved_match_len) ------------------ | Branch (1837:13): [True: 243, False: 319k] ------------------ 1838| 243| { 1839| 243| if (cur_match_len > d->m_saved_match_len) ------------------ | Branch (1839:17): [True: 0, False: 243] ------------------ 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| 243| else 1856| 243| { 1857| 243| tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); 1858| 243| len_to_move = d->m_saved_match_len - 1; 1859| 243| d->m_saved_match_len = 0; 1860| 243| } 1861| 243| } 1862| 319k| else if (!cur_match_dist) ------------------ | Branch (1862:18): [True: 1.20k, False: 318k] ------------------ 1863| 1.20k| tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); ------------------ | | 595| 1.20k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 1.20k, False: 0] | | ------------------ ------------------ 1864| 318k| else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) ------------------ | Branch (1864:18): [True: 0, False: 318k] | Branch (1864:43): [True: 0, False: 318k] | Branch (1864:79): [True: 317k, False: 243] ------------------ 1865| 317k| { 1866| 317k| tdefl_record_match(d, cur_match_len, cur_match_dist); 1867| 317k| len_to_move = cur_match_len; 1868| 317k| } 1869| 243| else 1870| 243| { 1871| 243| d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; ------------------ | | 595| 243|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 243, False: 0] | | ------------------ ------------------ 1872| 243| d->m_saved_match_dist = cur_match_dist; 1873| 243| d->m_saved_match_len = cur_match_len; 1874| 243| } 1875| | /* Move the lookahead forward by len_to_move bytes. */ 1876| 319k| d->m_lookahead_pos += len_to_move; 1877| 319k| MZ_ASSERT(d->m_lookahead_size >= len_to_move); ------------------ | | 582| 319k|#define MZ_ASSERT(x) assert(x) ------------------ 1878| 319k| d->m_lookahead_size -= len_to_move; 1879| 319k| d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE); ------------------ | | 595| 319k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 41.2k, False: 278k] | | ------------------ ------------------ 1880| | /* Check if it's time to flush the current LZ codes to the internal output buffer. */ 1881| 319k| if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || ------------------ | Branch (1881:13): [True: 0, False: 319k] ------------------ 1882| 319k| ((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: 279k, False: 40.2k] | Branch (1882:52): [True: 0, False: 279k] | Branch (1882:143): [True: 0, False: 279k] ------------------ 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| 319k| } 1891| | 1892| 1.59k| d->m_pSrc = pSrc; 1893| 1.59k| d->m_src_buf_left = src_buf_left; 1894| 1.59k| return MZ_TRUE; ------------------ | | 555| 1.59k|#define MZ_TRUE (1) ------------------ 1895| 1.59k|} miniz.c:tdefl_find_match: 1482| 319k|{ 1483| 319k| mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len; 1484| 319k| mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; 1485| 319k| const mz_uint8 *s = d->m_dict + pos, *p, *q; 1486| 319k| mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1]; 1487| 319k| MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); ------------------ | | 582| 319k|#define MZ_ASSERT(x) assert(x) ------------------ 1488| 319k| if (max_match_len <= match_len) ------------------ | Branch (1488:9): [True: 385, False: 319k] ------------------ 1489| 385| return; 1490| 319k| for (;;) 1491| 319k| { 1492| 319k| for (;;) 1493| 319k| { 1494| 319k| if (--num_probes_left == 0) ------------------ | Branch (1494:17): [True: 0, False: 319k] ------------------ 1495| 0| return; 1496| 319k|#define TDEFL_PROBE \ 1497| 319k| next_probe_pos = d->m_next[probe_pos]; \ 1498| 319k| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ 1499| 319k| return; \ 1500| 319k| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ 1501| 319k| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ 1502| 319k| break; 1503| 637k| TDEFL_PROBE; ------------------ | | 1497| 319k| next_probe_pos = d->m_next[probe_pos]; \ | | 1498| 319k| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (1498:9): [True: 1.06k, False: 318k] | | | Branch (1498:30): [True: 0, False: 318k] | | ------------------ | | 1499| 319k| return; \ | | 1500| 319k| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 1501| 318k| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (1501:9): [True: 318k, False: 0] | | | Branch (1501:53): [True: 318k, False: 0] | | ------------------ | | 1502| 318k| break; ------------------ 1504| 637k| 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| 318k| if (!dist) ------------------ | Branch (1507:13): [True: 0, False: 318k] ------------------ 1508| 0| break; 1509| 318k| p = s; 1510| 318k| q = d->m_dict + probe_pos; 1511| 82.3M| for (probe_len = 0; probe_len < max_match_len; probe_len++) ------------------ | Branch (1511:29): [True: 82.0M, False: 318k] ------------------ 1512| 82.0M| if (*p++ != *q++) ------------------ | Branch (1512:17): [True: 0, False: 82.0M] ------------------ 1513| 0| break; 1514| 318k| if (probe_len > match_len) ------------------ | Branch (1514:13): [True: 318k, False: 0] ------------------ 1515| 318k| { 1516| 318k| *pMatch_dist = dist; 1517| 318k| if ((*pMatch_len = match_len = probe_len) == max_match_len) ------------------ | Branch (1517:17): [True: 318k, False: 0] ------------------ 1518| 318k| return; 1519| 0| c0 = d->m_dict[pos + match_len]; 1520| 0| c1 = d->m_dict[pos + match_len - 1]; 1521| 0| } 1522| 318k| } 1523| 319k|} miniz.c:tdefl_record_literal: 1712| 1.20k|{ 1713| 1.20k| d->m_total_lz_bytes++; 1714| 1.20k| *d->m_pLZ_code_buf++ = lit; 1715| 1.20k| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); 1716| 1.20k| if (--d->m_num_flags_left == 0) ------------------ | Branch (1716:9): [True: 19, False: 1.18k] ------------------ 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.20k| d->m_huff_count[0][lit]++; 1722| 1.20k|} miniz.c:tdefl_record_match: 1725| 318k|{ 1726| 318k| mz_uint32 s0, s1; 1727| | 1728| 318k| MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE)); ------------------ | | 582| 318k|#define MZ_ASSERT(x) assert(x) ------------------ 1729| | 1730| 318k| d->m_total_lz_bytes += match_len; 1731| | 1732| 318k| d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN); 1733| | 1734| 318k| match_dist -= 1; 1735| 318k| d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF); 1736| 318k| d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); 1737| 318k| d->m_pLZ_code_buf += 3; 1738| | 1739| 318k| *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); 1740| 318k| if (--d->m_num_flags_left == 0) ------------------ | Branch (1740:9): [True: 39.6k, False: 278k] ------------------ 1741| 39.6k| { 1742| 39.6k| d->m_num_flags_left = 8; 1743| 39.6k| d->m_pLZ_flags = d->m_pLZ_code_buf++; 1744| 39.6k| } 1745| | 1746| 318k| s0 = s_tdefl_small_dist_sym[match_dist & 511]; 1747| 318k| s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127]; 1748| 318k| d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; ------------------ | Branch (1748:24): [True: 318k, False: 0] ------------------ 1749| 318k| d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++; 1750| 318k|} miniz.c:tdefl_flush_block: 1257| 530|{ 1258| 530| mz_uint saved_bit_buf, saved_bits_in; 1259| 530| mz_uint8 *pSaved_output_buf; 1260| 530| mz_bool comp_block_succeeded = MZ_FALSE; ------------------ | | 554| 530|#define MZ_FALSE (0) ------------------ 1261| 530| 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: 530] | Branch (1261:80): [True: 0, False: 0] ------------------ 1262| 530| 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: 530, False: 0] | Branch (1262:68): [True: 122, False: 408] ------------------ 1263| | 1264| 530| d->m_pOutput_buf = pOutput_buf_start; 1265| 530| d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16; 1266| | 1267| 530| MZ_ASSERT(!d->m_output_flush_remaining); ------------------ | | 582| 530|#define MZ_ASSERT(x) assert(x) ------------------ 1268| 530| d->m_output_flush_ofs = 0; 1269| 530| d->m_output_flush_remaining = 0; 1270| | 1271| 530| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left); 1272| 530| d->m_pLZ_code_buf -= (d->m_num_flags_left == 8); 1273| | 1274| 530| if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) ------------------ | Branch (1274:9): [True: 530, False: 0] | Branch (1274:51): [True: 530, False: 0] ------------------ 1275| 530| { 1276| 530| const mz_uint8 cmf = 0x78; 1277| 530| mz_uint8 flg, flevel = 3; 1278| 530| 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.30k| for (i = 0; i < mz_un; i++) ------------------ | Branch (1281:21): [True: 5.30k, False: 0] ------------------ 1282| 5.30k| if (s_tdefl_num_probes[i] == (d->m_flags & 0xFFF)) break; ------------------ | Branch (1282:17): [True: 530, False: 4.77k] ------------------ 1283| | 1284| 530| if (i < 2) ------------------ | Branch (1284:13): [True: 0, False: 530] ------------------ 1285| 0| flevel = 0; 1286| 530| else if (i < 6) ------------------ | Branch (1286:18): [True: 0, False: 530] ------------------ 1287| 0| flevel = 1; 1288| 530| else if (i == 6) ------------------ | Branch (1288:18): [True: 0, False: 530] ------------------ 1289| 0| flevel = 2; 1290| | 1291| 530| header = cmf << 8 | (flevel << 6); 1292| 530| header += 31 - (header % 31); 1293| 530| flg = header & 0xFF; 1294| | 1295| 530| TDEFL_PUT_BITS(cmf, 8); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 1.06k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 530, False: 530] | | ------------------ | | 933| 530| { \ | | 934| 530| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 530, False: 0] | | ------------------ | | 935| 530| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 530| d->m_bit_buffer >>= 8; \ | | 937| 530| d->m_bits_in -= 8; \ | | 938| 530| } \ | | 939| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1296| 530| TDEFL_PUT_BITS(flg, 8); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 1.06k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 530, False: 530] | | ------------------ | | 933| 530| { \ | | 934| 530| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 530, False: 0] | | ------------------ | | 935| 530| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 530| d->m_bit_buffer >>= 8; \ | | 937| 530| d->m_bits_in -= 8; \ | | 938| 530| } \ | | 939| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1297| 530| } 1298| | 1299| 530| TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 530| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 530] | | ------------------ | | 933| 530| { \ | | 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| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1300| | 1301| 530| pSaved_output_buf = d->m_pOutput_buf; 1302| 530| saved_bit_buf = d->m_bit_buffer; 1303| 530| saved_bits_in = d->m_bits_in; 1304| | 1305| 530| if (!use_raw_block) ------------------ | Branch (1305:9): [True: 530, False: 0] ------------------ 1306| 530| 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: 530] | Branch (1306:104): [True: 0, False: 530] ------------------ 1307| | 1308| | /* If the block gets expanded, forget the current contents of the output buffer and send a raw block instead. */ 1309| 530| 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: 530] | Branch (1309:30): [True: 530, False: 0] | Branch (1309:55): [True: 0, False: 530] ------------------ 1310| 530| ((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| 530| else if (!comp_block_succeeded) ------------------ | Branch (1330:14): [True: 0, False: 530] ------------------ 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| 530| if (flush) ------------------ | Branch (1337:9): [True: 530, False: 0] ------------------ 1338| 530| { 1339| 530| if (flush == TDEFL_FINISH) ------------------ | Branch (1339:13): [True: 530, False: 0] ------------------ 1340| 530| { 1341| 530| if (d->m_bits_in) ------------------ | Branch (1341:17): [True: 469, False: 61] ------------------ 1342| 469| { 1343| 469| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 925| 469| do \ | | 926| 469| { \ | | 927| 469| mz_uint bits = b; \ | | 928| 469| mz_uint len = l; \ | | 929| 469| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 469|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 469| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 469| d->m_bits_in += len; \ | | 932| 938| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 469, False: 469] | | ------------------ | | 933| 469| { \ | | 934| 469| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 469, False: 0] | | ------------------ | | 935| 469| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 469| d->m_bit_buffer >>= 8; \ | | 937| 469| d->m_bits_in -= 8; \ | | 938| 469| } \ | | 939| 469| } \ | | 940| 469| MZ_MACRO_END | | ------------------ | | | | 561| 469|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1344| 469| } 1345| 530| if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) ------------------ | Branch (1345:17): [True: 530, False: 0] ------------------ 1346| 530| { 1347| 530| mz_uint i, a = d->m_adler32; 1348| 2.65k| for (i = 0; i < 4; i++) ------------------ | Branch (1348:29): [True: 2.12k, False: 530] ------------------ 1349| 2.12k| { 1350| 2.12k| TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); ------------------ | | 925| 2.12k| do \ | | 926| 2.12k| { \ | | 927| 2.12k| mz_uint bits = b; \ | | 928| 2.12k| mz_uint len = l; \ | | 929| 2.12k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 2.12k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 2.12k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 2.12k| d->m_bits_in += len; \ | | 932| 4.24k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 2.12k, False: 2.12k] | | ------------------ | | 933| 2.12k| { \ | | 934| 2.12k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 2.12k, False: 0] | | ------------------ | | 935| 2.12k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 2.12k| d->m_bit_buffer >>= 8; \ | | 937| 2.12k| d->m_bits_in -= 8; \ | | 938| 2.12k| } \ | | 939| 2.12k| } \ | | 940| 2.12k| MZ_MACRO_END | | ------------------ | | | | 561| 2.12k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1351| 2.12k| a <<= 8; 1352| 2.12k| } 1353| 530| } 1354| 530| } 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| 530| } 1369| | 1370| 530| MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end); ------------------ | | 582| 530|#define MZ_ASSERT(x) assert(x) ------------------ 1371| | 1372| 530| memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 1373| 530| memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 1374| | 1375| 530| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 1376| 530| d->m_pLZ_flags = d->m_lz_code_buf; 1377| 530| d->m_num_flags_left = 8; 1378| 530| d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; 1379| 530| d->m_total_lz_bytes = 0; 1380| 530| d->m_block_index++; 1381| | 1382| 530| if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) ------------------ | Branch (1382:9): [True: 530, False: 0] ------------------ 1383| 530| { 1384| 530| if (d->m_pPut_buf_func) ------------------ | Branch (1384:13): [True: 0, False: 530] ------------------ 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| 530| else if (pOutput_buf_start == d->m_output_buf) ------------------ | Branch (1390:18): [True: 408, False: 122] ------------------ 1391| 408| { 1392| 408| int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); ------------------ | | 595| 408|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (595:23): [True: 408, False: 0] | | ------------------ ------------------ 1393| 408| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy); 1394| 408| d->m_out_buf_ofs += bytes_to_copy; 1395| 408| if ((n -= bytes_to_copy) != 0) ------------------ | Branch (1395:17): [True: 0, False: 408] ------------------ 1396| 0| { 1397| 0| d->m_output_flush_ofs = bytes_to_copy; 1398| 0| d->m_output_flush_remaining = n; 1399| 0| } 1400| 408| } 1401| 122| else 1402| 122| { 1403| 122| d->m_out_buf_ofs += n; 1404| 122| } 1405| 530| } 1406| | 1407| 530| return d->m_output_flush_remaining; 1408| 530|} miniz.c:tdefl_compress_block: 1246| 530|{ 1247| 530| if (static_block) ------------------ | Branch (1247:9): [True: 0, False: 530] ------------------ 1248| 0| tdefl_start_static_block(d); 1249| 530| else 1250| 530| tdefl_start_dynamic_block(d); 1251| 530| return tdefl_compress_lz_codes(d); 1252| 530|} miniz.c:tdefl_optimize_huffman_table: 872| 1.59k|{ 873| 1.59k| int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; 874| 1.59k| mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; 875| 1.59k| MZ_CLEAR_ARR(num_codes); ------------------ | | 597| 1.59k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 876| 1.59k| if (static_table) ------------------ | Branch (876:9): [True: 0, False: 1.59k] ------------------ 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.59k| else 882| 1.59k| { 883| 1.59k| tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms; 884| 1.59k| int num_used_syms = 0; 885| 1.59k| const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0]; 886| 181k| for (i = 0; i < table_len; i++) ------------------ | Branch (886:21): [True: 179k, False: 1.59k] ------------------ 887| 179k| if (pSym_count[i]) ------------------ | Branch (887:17): [True: 4.82k, False: 174k] ------------------ 888| 4.82k| { 889| 4.82k| syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; 890| 4.82k| syms0[num_used_syms++].m_sym_index = (mz_uint16)i; 891| 4.82k| } 892| | 893| 1.59k| pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); 894| 1.59k| tdefl_calculate_minimum_redundancy(pSyms, num_used_syms); 895| | 896| 6.41k| for (i = 0; i < num_used_syms; i++) ------------------ | Branch (896:21): [True: 4.82k, False: 1.59k] ------------------ 897| 4.82k| num_codes[pSyms[i].m_key]++; 898| | 899| 1.59k| tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit); 900| | 901| 1.59k| MZ_CLEAR_ARR(d->m_huff_code_sizes[table_num]); ------------------ | | 597| 1.59k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 902| 1.59k| MZ_CLEAR_ARR(d->m_huff_codes[table_num]); ------------------ | | 597| 1.59k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 903| 21.2k| for (i = 1, j = num_used_syms; i <= code_size_limit; i++) ------------------ | Branch (903:40): [True: 19.6k, False: 1.59k] ------------------ 904| 24.4k| for (l = num_codes[i]; l > 0; l--) ------------------ | Branch (904:36): [True: 4.82k, False: 19.6k] ------------------ 905| 4.82k| d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i); 906| 1.59k| } 907| | 908| 1.59k| next_code[1] = 0; 909| 19.6k| for (j = 0, i = 2; i <= code_size_limit; i++) ------------------ | Branch (909:24): [True: 18.0k, False: 1.59k] ------------------ 910| 18.0k| next_code[i] = j = ((j + num_codes[i - 1]) << 1); 911| | 912| 181k| for (i = 0; i < table_len; i++) ------------------ | Branch (912:17): [True: 179k, False: 1.59k] ------------------ 913| 179k| { 914| 179k| mz_uint rev_code = 0, code, code_size; 915| 179k| if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) ------------------ | Branch (915:13): [True: 174k, False: 4.82k] ------------------ 916| 174k| continue; 917| 4.82k| code = next_code[code_size]++; 918| 14.7k| for (l = code_size; l > 0; l--, code >>= 1) ------------------ | Branch (918:29): [True: 9.90k, False: 4.82k] ------------------ 919| 9.90k| rev_code = (rev_code << 1) | (code & 1); 920| 4.82k| d->m_huff_codes[table_num][i] = (mz_uint16)rev_code; 921| 4.82k| } 922| 1.59k|} miniz.c:tdefl_radix_sort_syms: 754| 1.59k|{ 755| 1.59k| mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; 756| 1.59k| tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1; 757| 1.59k| MZ_CLEAR_ARR(hist); ------------------ | | 597| 1.59k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 758| 6.41k| for (i = 0; i < num_syms; i++) ------------------ | Branch (758:17): [True: 4.82k, False: 1.59k] ------------------ 759| 4.82k| { 760| 4.82k| mz_uint freq = pSyms0[i].m_key; 761| 4.82k| hist[freq & 0xFF]++; 762| 4.82k| hist[256 + ((freq >> 8) & 0xFF)]++; 763| 4.82k| } 764| 2.88k| while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) ------------------ | Branch (764:12): [True: 1.59k, False: 1.29k] | Branch (764:34): [True: 1.29k, False: 295] ------------------ 765| 1.29k| total_passes--; 766| 3.47k| for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) ------------------ | Branch (766:36): [True: 1.88k, False: 1.59k] ------------------ 767| 1.88k| { 768| 1.88k| const mz_uint32 *pHist = &hist[pass << 8]; 769| 1.88k| mz_uint offsets[256], cur_ofs = 0; 770| 484k| for (i = 0; i < 256; i++) ------------------ | Branch (770:21): [True: 482k, False: 1.88k] ------------------ 771| 482k| { 772| 482k| offsets[i] = cur_ofs; 773| 482k| cur_ofs += pHist[i]; 774| 482k| } 775| 7.42k| for (i = 0; i < num_syms; i++) ------------------ | Branch (775:21): [True: 5.54k, False: 1.88k] ------------------ 776| 5.54k| pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i]; 777| 1.88k| { 778| 1.88k| tdefl_sym_freq *t = pCur_syms; 779| 1.88k| pCur_syms = pNew_syms; 780| 1.88k| pNew_syms = t; 781| 1.88k| } 782| 1.88k| } 783| 1.59k| return pCur_syms; 784| 1.59k|} miniz.c:tdefl_calculate_minimum_redundancy: 788| 1.59k|{ 789| 1.59k| int root, leaf, next, avbl, used, dpth; 790| 1.59k| if (n == 0) ------------------ | Branch (790:9): [True: 0, False: 1.59k] ------------------ 791| 0| return; 792| 1.59k| else if (n == 1) ------------------ | Branch (792:14): [True: 530, False: 1.06k] ------------------ 793| 530| { 794| 530| A[0].m_key = 1; 795| 530| return; 796| 530| } 797| 1.06k| A[0].m_key += A[1].m_key; 798| 1.06k| root = 0; 799| 1.06k| leaf = 2; 800| 3.23k| for (next = 1; next < n - 1; next++) ------------------ | Branch (800:20): [True: 2.17k, False: 1.06k] ------------------ 801| 2.17k| { 802| 2.17k| if (leaf >= n || A[root].m_key < A[leaf].m_key) ------------------ | Branch (802:13): [True: 368, False: 1.80k] | Branch (802:26): [True: 663, False: 1.13k] ------------------ 803| 1.03k| { 804| 1.03k| A[next].m_key = A[root].m_key; 805| 1.03k| A[root++].m_key = (mz_uint16)next; 806| 1.03k| } 807| 1.13k| else 808| 1.13k| A[next].m_key = A[leaf++].m_key; 809| 2.17k| if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) ------------------ | Branch (809:13): [True: 692, False: 1.47k] | Branch (809:27): [True: 1.02k, False: 456] | Branch (809:42): [True: 447, False: 575] ------------------ 810| 1.13k| { 811| 1.13k| A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); 812| 1.13k| A[root++].m_key = (mz_uint16)next; 813| 1.13k| } 814| 1.03k| else 815| 1.03k| A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key); 816| 2.17k| } 817| 1.06k| A[n - 2].m_key = 0; 818| 3.23k| for (next = n - 3; next >= 0; next--) ------------------ | Branch (818:24): [True: 2.17k, False: 1.06k] ------------------ 819| 2.17k| A[next].m_key = A[A[next].m_key].m_key + 1; 820| 1.06k| avbl = 1; 821| 1.06k| used = dpth = 0; 822| 1.06k| root = n - 2; 823| 1.06k| next = n - 1; 824| 4.98k| while (avbl > 0) ------------------ | Branch (824:12): [True: 3.92k, False: 1.06k] ------------------ 825| 3.92k| { 826| 7.15k| while (root >= 0 && (int)A[root].m_key == dpth) ------------------ | Branch (826:16): [True: 5.03k, False: 2.12k] | Branch (826:29): [True: 3.23k, False: 1.80k] ------------------ 827| 3.23k| { 828| 3.23k| used++; 829| 3.23k| root--; 830| 3.23k| } 831| 8.21k| while (avbl > used) ------------------ | Branch (831:16): [True: 4.29k, False: 3.92k] ------------------ 832| 4.29k| { 833| 4.29k| A[next--].m_key = (mz_uint16)(dpth); 834| 4.29k| avbl--; 835| 4.29k| } 836| 3.92k| avbl = 2 * used; 837| 3.92k| dpth++; 838| 3.92k| used = 0; 839| 3.92k| } 840| 1.06k|} miniz.c:tdefl_huffman_enforce_max_code_size: 848| 1.59k|{ 849| 1.59k| int i; 850| 1.59k| mz_uint32 total = 0; 851| 1.59k| if (code_list_len <= 1) ------------------ | Branch (851:9): [True: 530, False: 1.06k] ------------------ 852| 530| return; 853| 23.3k| for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) ------------------ | Branch (853:33): [True: 22.2k, False: 1.06k] ------------------ 854| 22.2k| pNum_codes[max_code_size] += pNum_codes[i]; 855| 12.7k| for (i = max_code_size; i > 0; i--) ------------------ | Branch (855:29): [True: 11.6k, False: 1.06k] ------------------ 856| 11.6k| total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i)); 857| 1.06k| while (total != (1UL << max_code_size)) ------------------ | Branch (857:12): [True: 0, False: 1.06k] ------------------ 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.06k|} miniz.c:tdefl_start_dynamic_block: 991| 530|{ 992| 530| int num_lit_codes, num_dist_codes, num_bit_lengths; 993| 530| mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index; 994| 530| 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| 530| d->m_huff_count[0][256] = 1; 997| | 998| 530| tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE); ------------------ | | 554| 530|#define MZ_FALSE (0) ------------------ 999| 530| tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE); ------------------ | | 554| 530|#define MZ_FALSE (0) ------------------ 1000| | 1001| 644| for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) ------------------ | Branch (1001:31): [True: 644, False: 0] ------------------ 1002| 644| if (d->m_huff_code_sizes[0][num_lit_codes - 1]) ------------------ | Branch (1002:13): [True: 530, False: 114] ------------------ 1003| 530| break; 1004| 15.9k| for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) ------------------ | Branch (1004:31): [True: 15.3k, False: 530] ------------------ 1005| 15.3k| if (d->m_huff_code_sizes[1][num_dist_codes - 1]) ------------------ | Branch (1005:13): [True: 0, False: 15.3k] ------------------ 1006| 0| break; 1007| | 1008| 530| memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); 1009| 530| memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes); 1010| 530| total_code_sizes_to_pack = num_lit_codes + num_dist_codes; 1011| 530| num_packed_code_sizes = 0; 1012| 530| rle_z_count = 0; 1013| 530| rle_repeat_count = 0; 1014| | 1015| 530| memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2); 1016| 152k| for (i = 0; i < total_code_sizes_to_pack; i++) ------------------ | Branch (1016:17): [True: 151k, False: 530] ------------------ 1017| 151k| { 1018| 151k| mz_uint8 code_size = code_sizes_to_pack[i]; 1019| 151k| if (!code_size) ------------------ | Branch (1019:13): [True: 149k, False: 2.54k] ------------------ 1020| 149k| { 1021| 149k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 943| 149k| { \ | | 944| 149k| if (rle_repeat_count) \ | | ------------------ | | | Branch (944:13): [True: 0, False: 149k] | | ------------------ | | 945| 149k| { \ | | 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| 149k| } ------------------ 1022| 149k| if (++rle_z_count == 138) ------------------ | Branch (1022:17): [True: 530, False: 148k] ------------------ 1023| 530| { 1024| 530| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 963| 530| { \ | | 964| 530| if (rle_z_count) \ | | ------------------ | | | Branch (964:13): [True: 530, False: 0] | | ------------------ | | 965| 530| { \ | | 966| 530| if (rle_z_count < 3) \ | | ------------------ | | | Branch (966:17): [True: 0, False: 530] | | ------------------ | | 967| 530| { \ | | 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| 530| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (972:22): [True: 0, False: 530] | | ------------------ | | 973| 530| { \ | | 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| 530| else \ | | 979| 530| { \ | | 980| 530| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 981| 530| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 982| 530| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 983| 530| } \ | | 984| 530| rle_z_count = 0; \ | | 985| 530| } \ | | 986| 530| } ------------------ 1025| 530| } 1026| 149k| } 1027| 2.54k| else 1028| 2.54k| { 1029| 2.54k| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 963| 2.54k| { \ | | 964| 2.54k| if (rle_z_count) \ | | ------------------ | | | Branch (964:13): [True: 1.42k, False: 1.12k] | | ------------------ | | 965| 2.54k| { \ | | 966| 1.42k| if (rle_z_count < 3) \ | | ------------------ | | | Branch (966:17): [True: 105, False: 1.32k] | | ------------------ | | 967| 1.42k| { \ | | 968| 105| d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 969| 280| while (rle_z_count--) \ | | ------------------ | | | Branch (969:24): [True: 175, False: 105] | | ------------------ | | 970| 175| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 971| 105| } \ | | 972| 1.42k| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (972:22): [True: 193, False: 1.12k] | | ------------------ | | 973| 1.32k| { \ | | 974| 193| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 975| 193| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 976| 193| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ | | 977| 193| } \ | | 978| 1.32k| else \ | | 979| 1.32k| { \ | | 980| 1.12k| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 981| 1.12k| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 982| 1.12k| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 983| 1.12k| } \ | | 984| 1.42k| rle_z_count = 0; \ | | 985| 1.42k| } \ | | 986| 2.54k| } ------------------ 1030| 2.54k| if (code_size != prev_code_size) ------------------ | Branch (1030:17): [True: 2.08k, False: 463] ------------------ 1031| 2.08k| { 1032| 2.08k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 943| 2.08k| { \ | | 944| 2.08k| if (rle_repeat_count) \ | | ------------------ | | | Branch (944:13): [True: 10, False: 2.07k] | | ------------------ | | 945| 2.08k| { \ | | 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.08k| } ------------------ 1033| 2.08k| d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1); 1034| 2.08k| packed_code_sizes[num_packed_code_sizes++] = code_size; 1035| 2.08k| } 1036| 463| else if (++rle_repeat_count == 6) ------------------ | Branch (1036:22): [True: 0, False: 463] ------------------ 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.54k| } 1041| 151k| prev_code_size = code_size; 1042| 151k| } 1043| 530| if (rle_repeat_count) ------------------ | Branch (1043:9): [True: 453, False: 77] ------------------ 1044| 453| { 1045| 453| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 943| 453| { \ | | 944| 453| if (rle_repeat_count) \ | | ------------------ | | | Branch (944:13): [True: 453, False: 0] | | ------------------ | | 945| 453| { \ | | 946| 453| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (946:17): [True: 453, False: 0] | | ------------------ | | 947| 453| { \ | | 948| 453| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 949| 906| while (rle_repeat_count--) \ | | ------------------ | | | Branch (949:24): [True: 453, False: 453] | | ------------------ | | 950| 453| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 951| 453| } \ | | 952| 453| else \ | | 953| 453| { \ | | 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| 453| rle_repeat_count = 0; \ | | 959| 453| } \ | | 960| 453| } ------------------ 1046| 453| } 1047| 77| else 1048| 77| { 1049| 77| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 963| 77| { \ | | 964| 77| if (rle_z_count) \ | | ------------------ | | | Branch (964:13): [True: 0, False: 77] | | ------------------ | | 965| 77| { \ | | 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| 77| } ------------------ 1050| 77| } 1051| | 1052| 530| tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE); ------------------ | | 554| 530|#define MZ_FALSE (0) ------------------ 1053| | 1054| 530| TDEFL_PUT_BITS(2, 2); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 530| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 530] | | ------------------ | | 933| 530| { \ | | 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| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1055| | 1056| 530| TDEFL_PUT_BITS(num_lit_codes - 257, 5); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 1.06k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 530, False: 530] | | ------------------ | | 933| 530| { \ | | 934| 530| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 530, False: 0] | | ------------------ | | 935| 530| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 530| d->m_bit_buffer >>= 8; \ | | 937| 530| d->m_bits_in -= 8; \ | | 938| 530| } \ | | 939| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1057| 530| TDEFL_PUT_BITS(num_dist_codes - 1, 5); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 530| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 530] | | ------------------ | | 933| 530| { \ | | 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| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1058| | 1059| 1.06k| for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) ------------------ | Branch (1059:32): [True: 1.06k, False: 0] ------------------ 1060| 1.06k| if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) ------------------ | Branch (1060:13): [True: 530, False: 530] ------------------ 1061| 530| break; 1062| 530| num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); ------------------ | | 594| 530|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (594:23): [True: 0, False: 530] | | ------------------ ------------------ 1063| 530| TDEFL_PUT_BITS(num_bit_lengths - 4, 4); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 1.06k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 530, False: 530] | | ------------------ | | 933| 530| { \ | | 934| 530| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 530, False: 0] | | ------------------ | | 935| 530| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 530| d->m_bit_buffer >>= 8; \ | | 937| 530| d->m_bits_in -= 8; \ | | 938| 530| } \ | | 939| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1064| 10.0k| for (i = 0; (int)i < num_bit_lengths; i++) ------------------ | Branch (1064:17): [True: 9.54k, False: 530] ------------------ 1065| 9.54k| TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); ------------------ | | 925| 10.0k| do \ | | 926| 10.0k| { \ | | 927| 9.54k| mz_uint bits = b; \ | | 928| 9.54k| mz_uint len = l; \ | | 929| 9.54k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 9.54k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 9.54k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 9.54k| d->m_bits_in += len; \ | | 932| 12.7k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 3.18k, False: 9.54k] | | ------------------ | | 933| 9.54k| { \ | | 934| 3.18k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 3.18k, False: 0] | | ------------------ | | 935| 3.18k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 3.18k| d->m_bit_buffer >>= 8; \ | | 937| 3.18k| d->m_bits_in -= 8; \ | | 938| 3.18k| } \ | | 939| 9.54k| } \ | | 940| 10.0k| MZ_MACRO_END | | ------------------ | | | | 561| 9.54k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1066| | 1067| 5.10k| for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;) ------------------ | Branch (1067:39): [True: 4.57k, False: 530] ------------------ 1068| 4.57k| { 1069| 4.57k| mz_uint code = packed_code_sizes[packed_code_sizes_index++]; 1070| 4.57k| MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2); ------------------ | | 582| 4.57k|#define MZ_ASSERT(x) assert(x) ------------------ 1071| 4.57k| TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); ------------------ | | 925| 4.57k| do \ | | 926| 4.57k| { \ | | 927| 4.57k| mz_uint bits = b; \ | | 928| 4.57k| mz_uint len = l; \ | | 929| 4.57k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 4.57k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 4.57k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 4.57k| d->m_bits_in += len; \ | | 932| 6.07k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 1.50k, False: 4.57k] | | ------------------ | | 933| 4.57k| { \ | | 934| 1.50k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 1.50k, False: 0] | | ------------------ | | 935| 1.50k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 1.50k| d->m_bit_buffer >>= 8; \ | | 937| 1.50k| d->m_bits_in -= 8; \ | | 938| 1.50k| } \ | | 939| 4.57k| } \ | | 940| 4.57k| MZ_MACRO_END | | ------------------ | | | | 561| 4.57k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1072| 4.57k| if (code >= 16) ------------------ | Branch (1072:13): [True: 1.85k, False: 2.72k] ------------------ 1073| 1.85k| TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]); ------------------ | | 925| 1.85k| do \ | | 926| 1.85k| { \ | | 927| 1.85k| mz_uint bits = b; \ | | 928| 1.85k| mz_uint len = l; \ | | 929| 1.85k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 1.85k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 1.85k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 1.85k| d->m_bits_in += len; \ | | 932| 3.23k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 1.38k, False: 1.85k] | | ------------------ | | 933| 1.85k| { \ | | 934| 1.38k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 1.38k, False: 0] | | ------------------ | | 935| 1.38k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 1.38k| d->m_bit_buffer >>= 8; \ | | 937| 1.38k| d->m_bits_in -= 8; \ | | 938| 1.38k| } \ | | 939| 1.85k| } \ | | 940| 1.85k| MZ_MACRO_END | | ------------------ | | | | 561| 1.85k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1074| 4.57k| } 1075| 530|} miniz.c:tdefl_compress_lz_codes: 1198| 530|{ 1199| 530| mz_uint flags; 1200| 530| mz_uint8 *pLZ_codes; 1201| | 1202| 530| flags = 1; 1203| 319k| for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1) ------------------ | Branch (1203:40): [True: 319k, False: 530] ------------------ 1204| 319k| { 1205| 319k| if (flags == 1) ------------------ | Branch (1205:13): [True: 40.1k, False: 279k] ------------------ 1206| 40.1k| flags = *pLZ_codes++ | 0x100; 1207| 319k| if (flags & 1) ------------------ | Branch (1207:13): [True: 318k, False: 1.20k] ------------------ 1208| 318k| { 1209| 318k| mz_uint sym, num_extra_bits; 1210| 318k| mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); 1211| 318k| pLZ_codes += 3; 1212| | 1213| 318k| MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); ------------------ | | 582| 318k|#define MZ_ASSERT(x) assert(x) ------------------ 1214| 318k| 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| 318k| do \ | | 926| 318k| { \ | | 927| 318k| mz_uint bits = b; \ | | 928| 318k| mz_uint len = l; \ | | 929| 318k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 318k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 318k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 318k| d->m_bits_in += len; \ | | 932| 373k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 55.1k, False: 318k] | | ------------------ | | 933| 318k| { \ | | 934| 55.1k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 55.1k, False: 0] | | ------------------ | | 935| 55.1k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 55.1k| d->m_bit_buffer >>= 8; \ | | 937| 55.1k| d->m_bits_in -= 8; \ | | 938| 55.1k| } \ | | 939| 318k| } \ | | 940| 318k| MZ_MACRO_END | | ------------------ | | | | 561| 318k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1215| 318k| TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]); ------------------ | | 925| 318k| do \ | | 926| 318k| { \ | | 927| 318k| mz_uint bits = b; \ | | 928| 318k| mz_uint len = l; \ | | 929| 318k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 318k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 318k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 318k| d->m_bits_in += len; \ | | 932| 318k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 168, False: 318k] | | ------------------ | | 933| 318k| { \ | | 934| 168| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 168, False: 0] | | ------------------ | | 935| 168| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 168| d->m_bit_buffer >>= 8; \ | | 937| 168| d->m_bits_in -= 8; \ | | 938| 168| } \ | | 939| 318k| } \ | | 940| 318k| MZ_MACRO_END | | ------------------ | | | | 561| 318k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1216| | 1217| 318k| if (match_dist < 512) ------------------ | Branch (1217:17): [True: 318k, False: 0] ------------------ 1218| 318k| { 1219| 318k| sym = s_tdefl_small_dist_sym[match_dist]; 1220| 318k| num_extra_bits = s_tdefl_small_dist_extra[match_dist]; 1221| 318k| } 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| 318k| MZ_ASSERT(d->m_huff_code_sizes[1][sym]); ------------------ | | 582| 318k|#define MZ_ASSERT(x) assert(x) ------------------ 1228| 318k| TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); ------------------ | | 925| 318k| do \ | | 926| 318k| { \ | | 927| 318k| mz_uint bits = b; \ | | 928| 318k| mz_uint len = l; \ | | 929| 318k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 318k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 318k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 318k| d->m_bits_in += len; \ | | 932| 342k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 24.5k, False: 318k] | | ------------------ | | 933| 318k| { \ | | 934| 24.5k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 24.5k, False: 0] | | ------------------ | | 935| 24.5k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 24.5k| d->m_bit_buffer >>= 8; \ | | 937| 24.5k| d->m_bits_in -= 8; \ | | 938| 24.5k| } \ | | 939| 318k| } \ | | 940| 318k| MZ_MACRO_END | | ------------------ | | | | 561| 318k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1229| 318k| TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); ------------------ | | 925| 318k| do \ | | 926| 318k| { \ | | 927| 318k| mz_uint bits = b; \ | | 928| 318k| mz_uint len = l; \ | | 929| 318k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 318k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 318k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 318k| d->m_bits_in += len; \ | | 932| 318k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 0, False: 318k] | | ------------------ | | 933| 318k| { \ | | 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| 318k| } \ | | 940| 318k| MZ_MACRO_END | | ------------------ | | | | 561| 318k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1230| 318k| } 1231| 1.20k| else 1232| 1.20k| { 1233| 1.20k| mz_uint lit = *pLZ_codes++; 1234| 1.20k| MZ_ASSERT(d->m_huff_code_sizes[0][lit]); ------------------ | | 582| 1.20k|#define MZ_ASSERT(x) assert(x) ------------------ 1235| 1.20k| TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); ------------------ | | 925| 1.20k| do \ | | 926| 1.20k| { \ | | 927| 1.20k| mz_uint bits = b; \ | | 928| 1.20k| mz_uint len = l; \ | | 929| 1.20k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 1.20k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 1.20k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 1.20k| d->m_bits_in += len; \ | | 932| 1.48k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 282, False: 1.20k] | | ------------------ | | 933| 1.20k| { \ | | 934| 282| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 282, False: 0] | | ------------------ | | 935| 282| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 282| d->m_bit_buffer >>= 8; \ | | 937| 282| d->m_bits_in -= 8; \ | | 938| 282| } \ | | 939| 1.20k| } \ | | 940| 1.20k| MZ_MACRO_END | | ------------------ | | | | 561| 1.20k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1236| 1.20k| } 1237| 319k| } 1238| | 1239| 530| TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); ------------------ | | 925| 530| do \ | | 926| 530| { \ | | 927| 530| mz_uint bits = b; \ | | 928| 530| mz_uint len = l; \ | | 929| 530| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 582| 530|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 930| 530| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 931| 530| d->m_bits_in += len; \ | | 932| 709| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (932:16): [True: 179, False: 530] | | ------------------ | | 933| 530| { \ | | 934| 179| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (934:17): [True: 179, False: 0] | | ------------------ | | 935| 179| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 936| 179| d->m_bit_buffer >>= 8; \ | | 937| 179| d->m_bits_in -= 8; \ | | 938| 179| } \ | | 939| 530| } \ | | 940| 530| MZ_MACRO_END | | ------------------ | | | | 561| 530|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (561:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1240| | 1241| 530| return (d->m_pOutput_buf < d->m_pOutput_buf_end); 1242| 530|} miniz.c:tinfl_clear_tree: 2428| 1.59k|{ 2429| 1.59k| if (r->m_type == 0) ------------------ | Branch (2429:9): [True: 530, False: 1.06k] ------------------ 2430| 530| MZ_CLEAR_ARR(r->m_tree_0); ------------------ | | 597| 530|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2431| 1.06k| else if (r->m_type == 1) ------------------ | Branch (2431:14): [True: 530, False: 530] ------------------ 2432| 530| MZ_CLEAR_ARR(r->m_tree_1); ------------------ | | 597| 530|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2433| 530| else 2434| 530| MZ_CLEAR_ARR(r->m_tree_2); ------------------ | | 597| 530|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 2435| 1.59k|} test_large_deflate: 30| 530|{ 31| 530| z_stream c_stream; /* compression stream */ ------------------ | | 487| 530|#define z_stream mz_stream ------------------ 32| 530| int err; 33| | 34| 530| c_stream.zalloc = zalloc; 35| 530| c_stream.zfree = zfree; 36| 530| c_stream.opaque = NULL; 37| | 38| 530| err = deflateInit(&c_stream, Z_BEST_COMPRESSION); ------------------ | | 490| 530|#define deflateInit mz_deflateInit ------------------ err = deflateInit(&c_stream, Z_BEST_COMPRESSION); ------------------ | | 475| 530|#define Z_BEST_COMPRESSION MZ_BEST_COMPRESSION ------------------ 39| 530| CHECK_ERR(err, "deflateInit"); ------------------ | | 14| 530|#define CHECK_ERR(err, msg) { \ | | 15| 530| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.06k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 530] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 530|} ------------------ 40| | 41| 530| c_stream.next_out = compr; 42| 530| 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| 530| c_stream.next_in = uncompr; 48| 530| c_stream.avail_in = (unsigned int)uncomprLen; 49| 530| err = deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 493| 530|#define deflate mz_deflate ------------------ err = deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 457| 530|#define Z_NO_FLUSH MZ_NO_FLUSH ------------------ 50| 530| CHECK_ERR(err, "deflate large 1"); ------------------ | | 14| 530|#define CHECK_ERR(err, msg) { \ | | 15| 530| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.06k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 530] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 530|} ------------------ 51| | 52| 530| if (c_stream.avail_in != 0) ------------------ | Branch (52:9): [True: 0, False: 530] ------------------ 53| 0| { 54| 0| fprintf(stderr, "deflate not greedy\n"); 55| 0| exit(1); 56| 0| } 57| | 58| | /* Feed in already compressed data: */ 59| 530| c_stream.next_in = compr; 60| 530| diff = (unsigned int)(c_stream.next_out - compr); 61| 530| c_stream.avail_in = diff; 62| | 63| 530| deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 493| 530|#define deflate mz_deflate ------------------ deflate(&c_stream, Z_NO_FLUSH); ------------------ | | 457| 530|#define Z_NO_FLUSH MZ_NO_FLUSH ------------------ 64| 530| err = deflate(&c_stream, Z_FINISH); ------------------ | | 493| 530|#define deflate mz_deflate ------------------ err = deflate(&c_stream, Z_FINISH); ------------------ | | 461| 530|#define Z_FINISH MZ_FINISH ------------------ 65| | 66| 530| if (err != Z_STREAM_END) ------------------ | | 464| 530|#define Z_STREAM_END MZ_STREAM_END ------------------ | Branch (66:9): [True: 0, False: 530] ------------------ 67| 0| { 68| 0| fprintf(stderr, "deflate large should report Z_STREAM_END\n"); 69| 0| exit(1); 70| 0| } 71| 530| err = deflateEnd(&c_stream); ------------------ | | 494| 530|#define deflateEnd mz_deflateEnd ------------------ 72| 530| CHECK_ERR(err, "deflateEnd"); ------------------ | | 14| 530|#define CHECK_ERR(err, msg) { \ | | 15| 530| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.06k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 530] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 530|} ------------------ 73| 530|} test_large_inflate: 78| 530|{ 79| 530| int err; 80| 530| z_stream d_stream; /* decompression stream */ ------------------ | | 487| 530|#define z_stream mz_stream ------------------ 81| | 82| 530| d_stream.zalloc = zalloc; 83| 530| d_stream.zfree = zfree; 84| 530| d_stream.opaque = NULL; 85| | 86| 530| d_stream.next_in = compr; 87| 530| d_stream.avail_in = (unsigned int)comprLen; 88| | 89| 530| err = inflateInit(&d_stream); ------------------ | | 502| 530|#define inflateInit mz_inflateInit ------------------ 90| 530| CHECK_ERR(err, "inflateInit"); ------------------ | | 14| 530|#define CHECK_ERR(err, msg) { \ | | 15| 530| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.06k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 530] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 530|} ------------------ 91| | 92| 530| for (;;) 93| 530| { 94| 530| d_stream.next_out = uncompr; /* discard the output */ 95| 530| d_stream.avail_out = (unsigned int)uncomprLen; 96| 530| err = inflate(&d_stream, Z_NO_FLUSH); ------------------ | | 505| 530|#define inflate mz_inflate ------------------ err = inflate(&d_stream, Z_NO_FLUSH); ------------------ | | 457| 530|#define Z_NO_FLUSH MZ_NO_FLUSH ------------------ 97| 530| if (err == Z_STREAM_END) break; ------------------ | | 464| 530|#define Z_STREAM_END MZ_STREAM_END ------------------ | Branch (97:13): [True: 530, 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| 530| err = inflateEnd(&d_stream); ------------------ | | 506| 530|#define inflateEnd mz_inflateEnd ------------------ 103| 530| CHECK_ERR(err, "inflateEnd"); ------------------ | | 14| 530|#define CHECK_ERR(err, msg) { \ | | 15| 530| if (err != Z_OK) { \ | | ------------------ | | | | 463| 1.06k|#define Z_OK MZ_OK | | ------------------ | | | Branch (15:9): [True: 0, False: 530] | | ------------------ | | 16| 0| fprintf(stderr, "%s error: %d\n", msg, err); \ | | 17| 0| exit(1); \ | | 18| 0| } \ | | 19| 530|} ------------------ 104| 530|} LLVMFuzzerTestOneInput: 107| 534|{ 108| 534| size_t comprLen = 100 + 3 * size; 109| 534| size_t uncomprLen = comprLen; 110| 534| uint8_t *compr, *uncompr; 111| | 112| | /* Discard inputs larger than 512Kb. */ 113| 534| static size_t kMaxSize = 512 * 1024; 114| | 115| 534| if (size < 1 || size > kMaxSize) ------------------ | Branch (115:9): [True: 0, False: 534] | Branch (115:21): [True: 4, False: 530] ------------------ 116| 4| return 0; 117| | 118| 530| data = d; 119| 530| dataLen = size; 120| 530| compr = calloc(1, comprLen); 121| 530| uncompr = calloc(1, uncomprLen); 122| | 123| 530| test_large_deflate(compr, comprLen, uncompr, uncomprLen); 124| 530| test_large_inflate(compr, comprLen, uncompr, uncomprLen); 125| | 126| 530| free(compr); 127| 530| free(uncompr); 128| | 129| 530| return 0; 130| 534|}