fte/quakespasm
2
0
Fork 0
mirror of https://github.com/Shpoike/Quakespasm.git synced 2025-02-02 22:11:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

miniz: updates from mainstream PR/159

Browse source 
--
This commit is contained in:
Ozkan Sezer 2022-01-27 08:10:04 +03:00
parent f260464d96
commit 743c983060
2 changed files with 31 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
Quake/miniz.c
View file

@ -259,11 +259,10 @@ extern "C" {
/* It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a */ /* It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a */
/* Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the */ /* Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the */
/* bit buffer contains >=15 bits (deflate's max. Huffman code size). */ /* bit buffer contains >=15 bits (deflate's max. Huffman code size). */
#define TINFL_HUFF_BITBUF_FILL(state_index, pHuff) \ #define TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree) \
do \ do \
{ \ { \
mz_int16 *pTreeFill; \ temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
if (temp >= 0) \ if (temp >= 0) \
{ \ { \
code_len = temp >> 9; \ code_len = temp >> 9; \
@ -272,11 +271,10 @@ extern "C" {
} \ } \
else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ else if (num_bits > TINFL_FAST_LOOKUP_BITS) \
{ \ { \
pTreeFill = (pHuff)->m_pTree; \
code_len = TINFL_FAST_LOOKUP_BITS; \ code_len = TINFL_FAST_LOOKUP_BITS; \
do \ do \
{ \ { \
temp = pTreeFill[~temp + ((bit_buf >> code_len++) & 1)]; \ temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \
} while ((temp < 0) && (num_bits >= (code_len + 1))); \ } while ((temp < 0) && (num_bits >= (code_len + 1))); \
if (temp >= 0) \ if (temp >= 0) \
break; \ break; \
@ -292,17 +290,16 @@ extern "C" {
/* The slow path is only executed at the very end of the input buffer. */ /* The slow path is only executed at the very end of the input buffer. */
/* v1.16: The original macro handled the case at the very end of the passed-in input buffer, but we also need to handle the case where the user passes in 1+zillion bytes */ /* v1.16: The original macro handled the case at the very end of the passed-in input buffer, but we also need to handle the case where the user passes in 1+zillion bytes */
/* following the deflate data and our non-conservative read-ahead path won't kick in here on this code. This is much trickier. */ /* following the deflate data and our non-conservative read-ahead path won't kick in here on this code. This is much trickier. */
#define TINFL_HUFF_DECODE(state_index, sym, pHuff) \ #define TINFL_HUFF_DECODE(state_index, sym, pLookUp, pTree) \
do \ do \
{ \ { \
int temp; \ int temp; \
mz_uint code_len, c; \ mz_uint code_len, c; \
mz_int16 *pTreeDec; \
if (num_bits < 15) \ if (num_bits < 15) \
{ \ { \
if ((pIn_buf_end - pIn_buf_cur) < 2) \ if ((pIn_buf_end - pIn_buf_cur) < 2) \
{ \ { \
TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \ TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \
} \ } \
else \ else \
{ \ { \
@ -311,15 +308,14 @@ extern "C" {
num_bits += 16; \ num_bits += 16; \
} \ } \
} \ } \
if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \
code_len = temp >> 9, temp &= 511; \ code_len = temp >> 9, temp &= 511; \
else \ else \
{ \ { \
pTreeDec = (pHuff)->m_pTree; \
code_len = TINFL_FAST_LOOKUP_BITS; \ code_len = TINFL_FAST_LOOKUP_BITS; \
do \ do \
{ \ { \
temp = pTreeDec[~temp + ((bit_buf >> code_len++) & 1)]; \ temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \
} while (temp < 0); \ } while (temp < 0); \
} \ } \
sym = temp; \ sym = temp; \
@ -337,6 +333,9 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
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 }; 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 };
static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 }; static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 };
mz_int16 *pTrees[3];
mz_uint8 *pCode_sizes[3];
tinfl_status status = TINFL_STATUS_FAILED; tinfl_status status = TINFL_STATUS_FAILED;
mz_uint32 num_bits, dist, counter, num_extra; mz_uint32 num_bits, dist, counter, num_extra;
tinfl_bit_buf_t bit_buf; tinfl_bit_buf_t bit_buf;
@ -351,6 +350,13 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
return TINFL_STATUS_BAD_PARAM; return TINFL_STATUS_BAD_PARAM;
} }
pTrees[0] = r->m_tree_0;
pTrees[1] = r->m_tree_1;
pTrees[2] = r->m_tree_2;
pCode_sizes[0] = r->m_code_size_0;
pCode_sizes[1] = r->m_code_size_1;
pCode_sizes[2] = r->m_code_size_2;
num_bits = r->m_num_bits; num_bits = r->m_num_bits;
bit_buf = r->m_bit_buf; bit_buf = r->m_bit_buf;
dist = r->m_dist; dist = r->m_dist;
@ -461,15 +467,15 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
for (; (int)r->m_type >= 0; r->m_type--) for (; (int)r->m_type >= 0; r->m_type--)
{ {
int tree_next, tree_cur; int tree_next, tree_cur;
tinfl_huff_table *pTable; mz_int16 *pLookUp;
mz_int16 *pTree; mz_int16 *pTree;
mz_uint8 *pCode_size; mz_uint8 *pCode_size;
mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16];
pTable = &r->m_tables[r->m_type]; pLookUp = r->m_look_up[r->m_type];
pTree = pTable->m_pTree; pTree = pTrees[r->m_type];
pCode_size = pTable->m_pCode_size; pCode_size = pCode_sizes[r->m_type];
MZ_CLEAR_ARR(total_syms); MZ_CLEAR_ARR(total_syms);
MZ_CLEAR_ARR(pTable->m_look_up); TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0]));
TINFL_MEMSET(pTree, 0, r->m_table_sizes[r->m_type] * sizeof(pTree[0]) * 2); TINFL_MEMSET(pTree, 0, r->m_table_sizes[r->m_type] * sizeof(pTree[0]) * 2);
for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) for (i = 0; i < r->m_table_sizes[r->m_type]; ++i)
total_syms[pCode_size[i]]++; total_syms[pCode_size[i]]++;
@ -497,14 +503,14 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
mz_int16 k = (mz_int16)((code_size << 9) | sym_index); mz_int16 k = (mz_int16)((code_size << 9) | sym_index);
while (rev_code < TINFL_FAST_LOOKUP_SIZE) while (rev_code < TINFL_FAST_LOOKUP_SIZE)
{ {
pTable->m_look_up[rev_code] = k; pLookUp[rev_code] = k;
rev_code += (1 << code_size); rev_code += (1 << code_size);
} }
continue; continue;
} }
if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)]))
{ {
pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next;
tree_cur = tree_next; tree_cur = tree_next;
tree_next -= 2; tree_next -= 2;
} }
@ -529,7 +535,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);)
{ {
mz_uint s; mz_uint s;
TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]); TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2);
if (dist < 16) if (dist < 16)
{ {
r->m_len_codes[counter++] = (mz_uint8)dist; r->m_len_codes[counter++] = (mz_uint8)dist;
@ -560,7 +566,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
{ {
if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
{ {
TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]); TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0);
if (counter >= 256) if (counter >= 256)
break; break;
while (pOut_buf_cur >= pOut_buf_end) while (pOut_buf_cur >= pOut_buf_end)
@ -588,7 +594,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
num_bits += 16; num_bits += 16;
} }
#endif #endif
if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
code_len = sym2 >> 9; code_len = sym2 >> 9;
else else
{ {
@ -612,7 +618,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
num_bits += 16; num_bits += 16;
} }
#endif #endif
if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
code_len = sym2 >> 9; code_len = sym2 >> 9;
else else
{ {
@ -648,7 +654,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
counter += extra_bits; counter += extra_bits;
} }
TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]); TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1);
num_extra = s_dist_extra[dist]; num_extra = s_dist_extra[dist];
dist = s_dist_base[dist]; dist = s_dist_base[dist];
if (num_extra) if (num_extra)

15
Quake/miniz.h
View file

@ -420,12 +420,6 @@ typedef enum {
do \ do \
{ \ { \
(r)->m_state = 0; \ (r)->m_state = 0; \
(r)->m_tables[0].m_pCode_size = (r)->m_code_size_0; \
(r)->m_tables[0].m_pTree = (r)->m_tree_0; \
(r)->m_tables[1].m_pCode_size = (r)->m_code_size_1; \
(r)->m_tables[1].m_pTree = (r)->m_tree_1; \
(r)->m_tables[2].m_pCode_size = (r)->m_code_size_2; \
(r)->m_tables[2].m_pTree = (r)->m_tree_2; \
} \ } \
MZ_MACRO_END MZ_MACRO_END
#define tinfl_get_adler32(r) (r)->m_check_adler32 #define tinfl_get_adler32(r) (r)->m_check_adler32
@ -445,13 +439,6 @@ enum
TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
}; };
typedef struct
{
mz_uint8 *m_pCode_size;
mz_int16 *m_pTree;
mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE];
} tinfl_huff_table;
#if MINIZ_HAS_64BIT_REGISTERS #if MINIZ_HAS_64BIT_REGISTERS
#define TINFL_USE_64BIT_BITBUF 1 #define TINFL_USE_64BIT_BITBUF 1
#else #else
@ -471,7 +458,7 @@ struct tinfl_decompressor_tag
mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES]; mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
tinfl_bit_buf_t m_bit_buf; tinfl_bit_buf_t m_bit_buf;
size_t m_dist_from_out_buf_start; size_t m_dist_from_out_buf_start;
tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES]; mz_int16 m_look_up[TINFL_MAX_HUFF_TABLES][TINFL_FAST_LOOKUP_SIZE];
mz_int16 m_tree_0[TINFL_MAX_HUFF_SYMBOLS_0 * 2]; mz_int16 m_tree_0[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
mz_int16 m_tree_1[TINFL_MAX_HUFF_SYMBOLS_1 * 2]; mz_int16 m_tree_1[TINFL_MAX_HUFF_SYMBOLS_1 * 2];
mz_int16 m_tree_2[TINFL_MAX_HUFF_SYMBOLS_2 * 2]; mz_int16 m_tree_2[TINFL_MAX_HUFF_SYMBOLS_2 * 2];