Lines Matching refs:d
850 static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int cod… in tdefl_optimize_huffman_table() argument
858 num_codes[d->m_huff_code_sizes[table_num][i]]++; in tdefl_optimize_huffman_table()
864 const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0]; in tdefl_optimize_huffman_table()
880 MZ_CLEAR_OBJ(d->m_huff_code_sizes[table_num]); in tdefl_optimize_huffman_table()
881 MZ_CLEAR_OBJ(d->m_huff_codes[table_num]); in tdefl_optimize_huffman_table()
884 d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i); in tdefl_optimize_huffman_table()
894 if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) in tdefl_optimize_huffman_table()
899 d->m_huff_codes[table_num][i] = (mz_uint16)rev_code; in tdefl_optimize_huffman_table()
909 d->m_bit_buffer |= (bits << d->m_bits_in); \
910 d->m_bits_in += len; \
911 while (d->m_bits_in >= 8) \
913 if (d->m_pOutput_buf < d->m_pOutput_buf_end) \
914 *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \
915 d->m_bit_buffer >>= 8; \
916 d->m_bits_in -= 8; \
927 …d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_c…
933 …d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); …
947 d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \
953 d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \
959 d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \
969 static void tdefl_start_dynamic_block(tdefl_compressor *d) in tdefl_start_dynamic_block() argument
975 d->m_huff_count[0][256] = 1; in tdefl_start_dynamic_block()
977 tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE); in tdefl_start_dynamic_block()
978 tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE); in tdefl_start_dynamic_block()
981 if (d->m_huff_code_sizes[0][num_lit_codes - 1]) in tdefl_start_dynamic_block()
984 if (d->m_huff_code_sizes[1][num_dist_codes - 1]) in tdefl_start_dynamic_block()
987 memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); in tdefl_start_dynamic_block()
988 memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes); in tdefl_start_dynamic_block()
994 memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2); in tdefl_start_dynamic_block()
1012 d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1); in tdefl_start_dynamic_block()
1031 tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE); in tdefl_start_dynamic_block()
1039 if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) in tdefl_start_dynamic_block()
1044 TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); in tdefl_start_dynamic_block()
1050 TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); in tdefl_start_dynamic_block()
1056 static void tdefl_start_static_block(tdefl_compressor *d) in tdefl_start_static_block() argument
1059 mz_uint8 *p = &d->m_huff_code_sizes[0][0]; in tdefl_start_static_block()
1070 memset(d->m_huff_code_sizes[1], 5, 32); in tdefl_start_static_block()
1072 tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE); in tdefl_start_static_block()
1073 tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE); in tdefl_start_static_block()
1081 static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d) in tdefl_compress_lz_codes() argument
1085 mz_uint8 *pOutput_buf = d->m_pOutput_buf; in tdefl_compress_lz_codes()
1086 mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf; in tdefl_compress_lz_codes()
1087 mz_uint64 bit_buffer = d->m_bit_buffer; in tdefl_compress_lz_codes()
1088 mz_uint bits_in = d->m_bits_in; in tdefl_compress_lz_codes()
1097 for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1) in tdefl_compress_lz_codes()
1108 MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); in tdefl_compress_lz_codes()
1109 …TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdef… in tdefl_compress_lz_codes()
1120 MZ_ASSERT(d->m_huff_code_sizes[1][sym]); in tdefl_compress_lz_codes()
1121 TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); in tdefl_compress_lz_codes()
1127 MZ_ASSERT(d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1128 TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1134 MZ_ASSERT(d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1135 TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1141 MZ_ASSERT(d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1142 TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1147 if (pOutput_buf >= d->m_pOutput_buf_end) in tdefl_compress_lz_codes()
1158 d->m_pOutput_buf = pOutput_buf; in tdefl_compress_lz_codes()
1159 d->m_bits_in = 0; in tdefl_compress_lz_codes()
1160 d->m_bit_buffer = 0; in tdefl_compress_lz_codes()
1170 TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); in tdefl_compress_lz_codes()
1172 return (d->m_pOutput_buf < d->m_pOutput_buf_end); in tdefl_compress_lz_codes()
1175 static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d) in tdefl_compress_lz_codes() argument
1181 for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1) in tdefl_compress_lz_codes()
1191 MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); in tdefl_compress_lz_codes()
1192 …TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len… in tdefl_compress_lz_codes()
1205 MZ_ASSERT(d->m_huff_code_sizes[1][sym]); in tdefl_compress_lz_codes()
1206 TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); in tdefl_compress_lz_codes()
1212 MZ_ASSERT(d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1213 TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); in tdefl_compress_lz_codes()
1217 TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); in tdefl_compress_lz_codes()
1219 return (d->m_pOutput_buf < d->m_pOutput_buf_end); in tdefl_compress_lz_codes()
1223 static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block) in tdefl_compress_block() argument
1226 tdefl_start_static_block(d); in tdefl_compress_block()
1228 tdefl_start_dynamic_block(d); in tdefl_compress_block()
1229 return tdefl_compress_lz_codes(d); in tdefl_compress_block()
1232 static int tdefl_flush_block(tdefl_compressor *d, int flush) in tdefl_flush_block() argument
1237 …int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d… in tdefl_flush_block()
1238 …((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE))… in tdefl_flush_block()
1240 d->m_pOutput_buf = pOutput_buf_start; in tdefl_flush_block()
1241 d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16; in tdefl_flush_block()
1243 MZ_ASSERT(!d->m_output_flush_remaining); in tdefl_flush_block()
1244 d->m_output_flush_ofs = 0; in tdefl_flush_block()
1245 d->m_output_flush_remaining = 0; in tdefl_flush_block()
1247 *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left); in tdefl_flush_block()
1248 d->m_pLZ_code_buf -= (d->m_num_flags_left == 8); in tdefl_flush_block()
1250 if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) in tdefl_flush_block()
1258 pSaved_output_buf = d->m_pOutput_buf; in tdefl_flush_block()
1259 saved_bit_buf = d->m_bit_buffer; in tdefl_flush_block()
1260 saved_bits_in = d->m_bits_in; in tdefl_flush_block()
1263 …comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d-… in tdefl_flush_block()
1266 …if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= … in tdefl_flush_block()
1267 ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size)) in tdefl_flush_block()
1270 d->m_pOutput_buf = pSaved_output_buf; in tdefl_flush_block()
1271 d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; in tdefl_flush_block()
1273 if (d->m_bits_in) in tdefl_flush_block()
1275 TDEFL_PUT_BITS(0, 8 - d->m_bits_in); in tdefl_flush_block()
1277 for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF) in tdefl_flush_block()
1279 TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); in tdefl_flush_block()
1281 for (i = 0; i < d->m_total_lz_bytes; ++i) in tdefl_flush_block()
1283 TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8); in tdefl_flush_block()
1289 d->m_pOutput_buf = pSaved_output_buf; in tdefl_flush_block()
1290 d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; in tdefl_flush_block()
1291 tdefl_compress_block(d, MZ_TRUE); in tdefl_flush_block()
1298 if (d->m_bits_in) in tdefl_flush_block()
1300 TDEFL_PUT_BITS(0, 8 - d->m_bits_in); in tdefl_flush_block()
1302 if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) in tdefl_flush_block()
1304 mz_uint i, a = d->m_adler32; in tdefl_flush_block()
1316 if (d->m_bits_in) in tdefl_flush_block()
1318 TDEFL_PUT_BITS(0, 8 - d->m_bits_in); in tdefl_flush_block()
1327 MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end); in tdefl_flush_block()
1329 memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); in tdefl_flush_block()
1330 memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); in tdefl_flush_block()
1332 d->m_pLZ_code_buf = d->m_lz_code_buf + 1; in tdefl_flush_block()
1333 d->m_pLZ_flags = d->m_lz_code_buf; in tdefl_flush_block()
1334 d->m_num_flags_left = 8; in tdefl_flush_block()
1335 d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; in tdefl_flush_block()
1336 d->m_total_lz_bytes = 0; in tdefl_flush_block()
1337 d->m_block_index++; in tdefl_flush_block()
1339 if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) in tdefl_flush_block()
1341 if (d->m_pPut_buf_func) in tdefl_flush_block()
1343 *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; in tdefl_flush_block()
1344 if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user)) in tdefl_flush_block()
1345 return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED); in tdefl_flush_block()
1347 else if (pOutput_buf_start == d->m_output_buf) in tdefl_flush_block()
1349 … int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); in tdefl_flush_block()
1350 memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy); in tdefl_flush_block()
1351 d->m_out_buf_ofs += bytes_to_copy; in tdefl_flush_block()
1354 d->m_output_flush_ofs = bytes_to_copy; in tdefl_flush_block()
1355 d->m_output_flush_remaining = n; in tdefl_flush_block()
1360 d->m_out_buf_ofs += n; in tdefl_flush_block()
1364 return d->m_output_flush_remaining; in tdefl_flush_block()
1385 static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max… in tdefl_find_match() argument
1388 mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; in tdefl_find_match()
1389 const mz_uint16 *s = (const mz_uint16 *)(d->m_dict + pos), *p, *q; in tdefl_find_match()
1390 …mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), s01 = TDEFL_READ_UNALI… in tdefl_find_match()
1401 next_probe_pos = d->m_next[probe_pos]; \ in tdefl_find_match()
1405 if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01) \ in tdefl_find_match()
1413 q = (const mz_uint16 *)(d->m_dict + probe_pos); in tdefl_find_match()
1433 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]); in tdefl_find_match()
1438 static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max… in tdefl_find_match() argument
1441 mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; in tdefl_find_match()
1442 const mz_uint8 *s = d->m_dict + pos, *p, *q; in tdefl_find_match()
1443 mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1]; in tdefl_find_match()
1454 next_probe_pos = d->m_next[probe_pos]; \ in tdefl_find_match()
1458 if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ in tdefl_find_match()
1467 q = d->m_dict + probe_pos; in tdefl_find_match()
1476 c0 = d->m_dict[pos + match_len]; in tdefl_find_match()
1477 c1 = d->m_dict[pos + match_len - 1]; in tdefl_find_match()
1494 static mz_bool tdefl_compress_fast(tdefl_compressor *d) in tdefl_compress_fast() argument
1497 …os = d->m_lookahead_pos, lookahead_size = d->m_lookahead_size, dict_size = d->m_dict_size, total_l… in tdefl_compress_fast()
1498 mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags; in tdefl_compress_fast()
1501 while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size))) in tdefl_compress_fast()
1505 …mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE -… in tdefl_compress_fast()
1506 d->m_src_buf_left -= num_bytes_to_process; in tdefl_compress_fast()
1512 memcpy(d->m_dict + dst_pos, d->m_pSrc, n); in tdefl_compress_fast()
1514 …memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - … in tdefl_compress_fast()
1515 d->m_pSrc += n; in tdefl_compress_fast()
1521 if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE)) in tdefl_compress_fast()
1527 mz_uint8 *pCur_dict = d->m_dict + cur_pos; in tdefl_compress_fast()
1530 mz_uint probe_pos = d->m_hash[hash]; in tdefl_compress_fast()
1531 d->m_hash[hash] = (mz_uint16)lookahead_pos; in tdefl_compress_fast()
1533 …(lookahead_pos - probe_pos)) <= dict_size) && ((TDEFL_READ_UNALIGNED_WORD32(d->m_dict + (probe_pos… in tdefl_compress_fast()
1536 const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos); in tdefl_compress_fast()
1551 d->m_huff_count[0][(mz_uint8)first_trigram]++; in tdefl_compress_fast()
1573 d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++; in tdefl_compress_fast()
1575 d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - TDEFL_MIN_MATCH_LEN]]++; in tdefl_compress_fast()
1582 d->m_huff_count[0][(mz_uint8)first_trigram]++; in tdefl_compress_fast()
1598 if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) in tdefl_compress_fast()
1601 d->m_lookahead_pos = lookahead_pos; in tdefl_compress_fast()
1602 d->m_lookahead_size = lookahead_size; in tdefl_compress_fast()
1603 d->m_dict_size = dict_size; in tdefl_compress_fast()
1604 d->m_total_lz_bytes = total_lz_bytes; in tdefl_compress_fast()
1605 d->m_pLZ_code_buf = pLZ_code_buf; in tdefl_compress_fast()
1606 d->m_pLZ_flags = pLZ_flags; in tdefl_compress_fast()
1607 d->m_num_flags_left = num_flags_left; in tdefl_compress_fast()
1608 if ((n = tdefl_flush_block(d, 0)) != 0) in tdefl_compress_fast()
1610 total_lz_bytes = d->m_total_lz_bytes; in tdefl_compress_fast()
1611 pLZ_code_buf = d->m_pLZ_code_buf; in tdefl_compress_fast()
1612 pLZ_flags = d->m_pLZ_flags; in tdefl_compress_fast()
1613 num_flags_left = d->m_num_flags_left; in tdefl_compress_fast()
1619 mz_uint8 lit = d->m_dict[cur_pos]; in tdefl_compress_fast()
1630 d->m_huff_count[0][lit]++; in tdefl_compress_fast()
1637 if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) in tdefl_compress_fast()
1640 d->m_lookahead_pos = lookahead_pos; in tdefl_compress_fast()
1641 d->m_lookahead_size = lookahead_size; in tdefl_compress_fast()
1642 d->m_dict_size = dict_size; in tdefl_compress_fast()
1643 d->m_total_lz_bytes = total_lz_bytes; in tdefl_compress_fast()
1644 d->m_pLZ_code_buf = pLZ_code_buf; in tdefl_compress_fast()
1645 d->m_pLZ_flags = pLZ_flags; in tdefl_compress_fast()
1646 d->m_num_flags_left = num_flags_left; in tdefl_compress_fast()
1647 if ((n = tdefl_flush_block(d, 0)) != 0) in tdefl_compress_fast()
1649 total_lz_bytes = d->m_total_lz_bytes; in tdefl_compress_fast()
1650 pLZ_code_buf = d->m_pLZ_code_buf; in tdefl_compress_fast()
1651 pLZ_flags = d->m_pLZ_flags; in tdefl_compress_fast()
1652 num_flags_left = d->m_num_flags_left; in tdefl_compress_fast()
1657 d->m_lookahead_pos = lookahead_pos; in tdefl_compress_fast()
1658 d->m_lookahead_size = lookahead_size; in tdefl_compress_fast()
1659 d->m_dict_size = dict_size; in tdefl_compress_fast()
1660 d->m_total_lz_bytes = total_lz_bytes; in tdefl_compress_fast()
1661 d->m_pLZ_code_buf = pLZ_code_buf; in tdefl_compress_fast()
1662 d->m_pLZ_flags = pLZ_flags; in tdefl_compress_fast()
1663 d->m_num_flags_left = num_flags_left; in tdefl_compress_fast()
1668 static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit) in tdefl_record_literal() argument
1670 d->m_total_lz_bytes++; in tdefl_record_literal()
1671 *d->m_pLZ_code_buf++ = lit; in tdefl_record_literal()
1672 *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); in tdefl_record_literal()
1673 if (--d->m_num_flags_left == 0) in tdefl_record_literal()
1675 d->m_num_flags_left = 8; in tdefl_record_literal()
1676 d->m_pLZ_flags = d->m_pLZ_code_buf++; in tdefl_record_literal()
1678 d->m_huff_count[0][lit]++; in tdefl_record_literal()
1681 static MZ_FORCEINLINE void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match… in tdefl_record_match() argument
1687 d->m_total_lz_bytes += match_len; in tdefl_record_match()
1689 d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN); in tdefl_record_match()
1692 d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF); in tdefl_record_match()
1693 d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); in tdefl_record_match()
1694 d->m_pLZ_code_buf += 3; in tdefl_record_match()
1696 *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); in tdefl_record_match()
1697 if (--d->m_num_flags_left == 0) in tdefl_record_match()
1699 d->m_num_flags_left = 8; in tdefl_record_match()
1700 d->m_pLZ_flags = d->m_pLZ_code_buf++; in tdefl_record_match()
1705 d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; in tdefl_record_match()
1708 d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++; in tdefl_record_match()
1711 static mz_bool tdefl_compress_normal(tdefl_compressor *d) in tdefl_compress_normal() argument
1713 const mz_uint8 *pSrc = d->m_pSrc; in tdefl_compress_normal()
1714 size_t src_buf_left = d->m_src_buf_left; in tdefl_compress_normal()
1715 tdefl_flush flush = d->m_flush; in tdefl_compress_normal()
1717 while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) in tdefl_compress_normal()
1721 if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) in tdefl_compress_normal()
1723 …mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = … in tdefl_compress_normal()
1724 …mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(… in tdefl_compress_normal()
1725 …mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_… in tdefl_compress_normal()
1728 d->m_lookahead_size += num_bytes_to_process; in tdefl_compress_normal()
1732 d->m_dict[dst_pos] = c; in tdefl_compress_normal()
1734 d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; in tdefl_compress_normal()
1736 d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; in tdefl_compress_normal()
1737 d->m_hash[hash] = (mz_uint16)(ins_pos); in tdefl_compress_normal()
1744 while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) in tdefl_compress_normal()
1747 … mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK; in tdefl_compress_normal()
1749 d->m_dict[dst_pos] = c; in tdefl_compress_normal()
1751 d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; in tdefl_compress_normal()
1752 if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) in tdefl_compress_normal()
1754 mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2; in tdefl_compress_normal()
1755 …mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->… in tdefl_compress_normal()
1756 d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; in tdefl_compress_normal()
1757 d->m_hash[hash] = (mz_uint16)(ins_pos); in tdefl_compress_normal()
1761 d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size); in tdefl_compress_normal()
1762 if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) in tdefl_compress_normal()
1768 cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); in tdefl_compress_normal()
1769 cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; in tdefl_compress_normal()
1770 if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) in tdefl_compress_normal()
1772 if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) in tdefl_compress_normal()
1774 mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK]; in tdefl_compress_normal()
1776 while (cur_match_len < d->m_lookahead_size) in tdefl_compress_normal()
1778 if (d->m_dict[cur_pos + cur_match_len] != c) in tdefl_compress_normal()
1790 …tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur… in tdefl_compress_normal()
1792 …LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FIL… in tdefl_compress_normal()
1796 if (d->m_saved_match_len) in tdefl_compress_normal()
1798 if (cur_match_len > d->m_saved_match_len) in tdefl_compress_normal()
1800 tdefl_record_literal(d, (mz_uint8)d->m_saved_lit); in tdefl_compress_normal()
1803 tdefl_record_match(d, cur_match_len, cur_match_dist); in tdefl_compress_normal()
1804 d->m_saved_match_len = 0; in tdefl_compress_normal()
1809 d->m_saved_lit = d->m_dict[cur_pos]; in tdefl_compress_normal()
1810 d->m_saved_match_dist = cur_match_dist; in tdefl_compress_normal()
1811 d->m_saved_match_len = cur_match_len; in tdefl_compress_normal()
1816 tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); in tdefl_compress_normal()
1817 len_to_move = d->m_saved_match_len - 1; in tdefl_compress_normal()
1818 d->m_saved_match_len = 0; in tdefl_compress_normal()
1822 tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); in tdefl_compress_normal()
1823 … else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) in tdefl_compress_normal()
1825 tdefl_record_match(d, cur_match_len, cur_match_dist); in tdefl_compress_normal()
1830 d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; in tdefl_compress_normal()
1831 d->m_saved_match_dist = cur_match_dist; in tdefl_compress_normal()
1832 d->m_saved_match_len = cur_match_len; in tdefl_compress_normal()
1835 d->m_lookahead_pos += len_to_move; in tdefl_compress_normal()
1836 MZ_ASSERT(d->m_lookahead_size >= len_to_move); in tdefl_compress_normal()
1837 d->m_lookahead_size -= len_to_move; in tdefl_compress_normal()
1838 d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE); in tdefl_compress_normal()
1840 if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || in tdefl_compress_normal()
1841 …((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >… in tdefl_compress_normal()
1844 d->m_pSrc = pSrc; in tdefl_compress_normal()
1845 d->m_src_buf_left = src_buf_left; in tdefl_compress_normal()
1846 if ((n = tdefl_flush_block(d, 0)) != 0) in tdefl_compress_normal()
1851 d->m_pSrc = pSrc; in tdefl_compress_normal()
1852 d->m_src_buf_left = src_buf_left; in tdefl_compress_normal()
1856 static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d) in tdefl_flush_output_buffer() argument
1858 if (d->m_pIn_buf_size) in tdefl_flush_output_buffer()
1860 *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; in tdefl_flush_output_buffer()
1863 if (d->m_pOut_buf_size) in tdefl_flush_output_buffer()
1865 size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining); in tdefl_flush_output_buffer()
1866 … memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n); in tdefl_flush_output_buffer()
1867 d->m_output_flush_ofs += (mz_uint)n; in tdefl_flush_output_buffer()
1868 d->m_output_flush_remaining -= (mz_uint)n; in tdefl_flush_output_buffer()
1869 d->m_out_buf_ofs += n; in tdefl_flush_output_buffer()
1871 *d->m_pOut_buf_size = d->m_out_buf_ofs; in tdefl_flush_output_buffer()
1874 return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY; in tdefl_flush_output_buffer()
1877 tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *p… in tdefl_compress() argument
1879 if (!d) in tdefl_compress()
1888 d->m_pIn_buf = pIn_buf; in tdefl_compress()
1889 d->m_pIn_buf_size = pIn_buf_size; in tdefl_compress()
1890 d->m_pOut_buf = pOut_buf; in tdefl_compress()
1891 d->m_pOut_buf_size = pOut_buf_size; in tdefl_compress()
1892 d->m_pSrc = (const mz_uint8 *)(pIn_buf); in tdefl_compress()
1893 d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; in tdefl_compress()
1894 d->m_out_buf_ofs = 0; in tdefl_compress()
1895 d->m_flush = flush; in tdefl_compress()
1897 …if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_pre… in tdefl_compress()
1898 …(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) |… in tdefl_compress()
1904 return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM); in tdefl_compress()
1906 d->m_wants_to_finish |= (flush == TDEFL_FINISH); in tdefl_compress()
1908 if ((d->m_output_flush_remaining) || (d->m_finished)) in tdefl_compress()
1909 return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); in tdefl_compress()
1912 if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) && in tdefl_compress()
1913 ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) && in tdefl_compress()
1914 … ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0)) in tdefl_compress()
1916 if (!tdefl_compress_fast(d)) in tdefl_compress()
1917 return d->m_prev_return_status; in tdefl_compress()
1922 if (!tdefl_compress_normal(d)) in tdefl_compress()
1923 return d->m_prev_return_status; in tdefl_compress()
1926 if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf)) in tdefl_compress()
1927 …d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const m… in tdefl_compress()
1929 if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) in tdefl_compress()
1931 if (tdefl_flush_block(d, flush) < 0) in tdefl_compress()
1932 return d->m_prev_return_status; in tdefl_compress()
1933 d->m_finished = (flush == TDEFL_FINISH); in tdefl_compress()
1936 MZ_CLEAR_OBJ(d->m_hash); in tdefl_compress()
1937 MZ_CLEAR_OBJ(d->m_next); in tdefl_compress()
1938 d->m_dict_size = 0; in tdefl_compress()
1942 return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); in tdefl_compress()
1945 tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, td… in tdefl_compress_buffer() argument
1947 MZ_ASSERT(d->m_pPut_buf_func); in tdefl_compress_buffer()
1948 return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush); in tdefl_compress_buffer()
1951 tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_u… in tdefl_init() argument
1953 d->m_pPut_buf_func = pPut_buf_func; in tdefl_init()
1954 d->m_pPut_buf_user = pPut_buf_user; in tdefl_init()
1955 d->m_flags = (mz_uint)(flags); in tdefl_init()
1956 d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; in tdefl_init()
1957 d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0; in tdefl_init()
1958 d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3; in tdefl_init()
1960 MZ_CLEAR_OBJ(d->m_hash); in tdefl_init()
1961 …d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf… in tdefl_init()
1962 …d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_… in tdefl_init()
1963 d->m_pLZ_code_buf = d->m_lz_code_buf + 1; in tdefl_init()
1964 d->m_pLZ_flags = d->m_lz_code_buf; in tdefl_init()
1965 d->m_num_flags_left = 8; in tdefl_init()
1966 d->m_pOutput_buf = d->m_output_buf; in tdefl_init()
1967 d->m_pOutput_buf_end = d->m_output_buf; in tdefl_init()
1968 d->m_prev_return_status = TDEFL_STATUS_OKAY; in tdefl_init()
1969 d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; in tdefl_init()
1970 d->m_adler32 = 1; in tdefl_init()
1971 d->m_pIn_buf = NULL; in tdefl_init()
1972 d->m_pOut_buf = NULL; in tdefl_init()
1973 d->m_pIn_buf_size = NULL; in tdefl_init()
1974 d->m_pOut_buf_size = NULL; in tdefl_init()
1975 d->m_flush = TDEFL_NO_FLUSH; in tdefl_init()
1976 d->m_pSrc = NULL; in tdefl_init()
1977 d->m_src_buf_left = 0; in tdefl_init()
1978 d->m_out_buf_ofs = 0; in tdefl_init()
1980 MZ_CLEAR_OBJ(d->m_dict); in tdefl_init()
1981 memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); in tdefl_init()
1982 memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); in tdefl_init()
1986 tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d) in tdefl_get_prev_return_status() argument
1988 return d->m_prev_return_status; in tdefl_get_prev_return_status()
1991 mz_uint32 tdefl_get_adler32(tdefl_compressor *d) in tdefl_get_adler32() argument
1993 return d->m_adler32; in tdefl_get_adler32()
2242 #define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) argument