42 size_t block_len = buf_len % 5552;
47 for(i = 0; i + 7 < block_len; i += 8, ptr += 8)
58 for(; i < block_len; ++i)
60 s1 %= 65521U,
s2 %= 65521U;
64 return (
s2 << 16) +
s1;
71 static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
72 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
80 crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)];
81 crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)];
92 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
93 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
94 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,
95 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
96 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
97 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
98 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,
99 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
100 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
101 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
102 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,
103 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
104 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,
105 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,
106 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
107 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
108 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,
109 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
110 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
111 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
112 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,
113 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,
114 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
115 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
116 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
117 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
118 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
119 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
120 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,
121 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
122 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,
123 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
124 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,
125 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
126 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
127 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
128 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
160 #ifndef MINIZ_NO_ZLIB_APIS 164 (void)opaque, (
void)items, (void)size;
169 (void)opaque, (
void)address;
174 (void)opaque, (
void)address, (void)items, (
void)size;
213 pStream->
state = (
struct mz_internal_state *)pComp;
226 if((!pStream) || (!pStream->
state) || (!pStream->
zalloc) || (!pStream->
zfree))
235 size_t in_bytes, out_bytes;
236 mz_ulong orig_total_in, orig_total_out;
237 int mz_status =
MZ_OK;
282 if((flush) || (pStream->
total_in != orig_total_in) || (pStream->
total_out != orig_total_out))
298 pStream->
state = NULL;
307 return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);
314 memset(&stream, 0,
sizeof(stream));
317 if((source_len | *pDest_len) > 0xFFFFFFFFU)
382 pStream->
state = (
struct mz_internal_state *)pDecomp;
404 size_t in_bytes, out_bytes, orig_avail_in;
407 if((!pStream) || (!pStream->
state))
519 pStream->
state = NULL;
528 memset(&stream, 0,
sizeof(stream));
531 if((source_len | *pDest_len) > 0xFFFFFFFFU)
562 {
MZ_OK,
"" }, {
MZ_STREAM_END,
"stream end" }, {
MZ_NEED_DICT,
"need dictionary" }, {
MZ_ERRNO,
"file error" }, {
MZ_STREAM_ERROR,
"stream error" },
566 for(i = 0; i <
sizeof(s_error_descs) /
sizeof(s_error_descs[0]); ++i)
567 if(s_error_descs[i].m_err == err)
568 return s_error_descs[i].m_pDesc;
642 257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, 268, 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 272,
643 273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, 276, 276, 276,
644 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
645 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,
646 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
647 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
648 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
649 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 285
654 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
655 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
656 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
657 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0
662 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,
663 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13,
664 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
665 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
666 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
667 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
668 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
669 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
670 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
671 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
672 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
673 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17
678 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
679 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
680 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
681 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
682 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
683 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
684 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
685 7, 7, 7, 7, 7, 7, 7, 7
690 0, 0, 18, 19, 20, 20, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
691 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
692 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
697 0, 0, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
698 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
699 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13
709 mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2];
712 for(i = 0; i < num_syms; i++)
716 hist[256 + ((freq >> 8) & 0xFF)]++;
718 while((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256]))
720 for(pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
722 const mz_uint32 *pHist = &hist[pass << 8];
723 mz_uint offsets[256], cur_ofs = 0;
724 for(i = 0; i < 256; i++)
726 offsets[i] = cur_ofs;
729 for(i = 0; i < num_syms; i++)
730 pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
733 pCur_syms = pNew_syms;
743 int root, leaf, next, avbl, used, dpth;
754 for(next = 1; next < n - 1; next++)
756 if(leaf >= n || A[root].m_key < A[leaf].m_key)
763 if(leaf >= n || (root < next && A[root].m_key < A[leaf].m_key))
772 for(next = n - 3; next >= 0; next--)
773 A[next].m_key = A[A[next].m_key].m_key + 1;
780 while(root >= 0 && (
int)A[root].
m_key == dpth)
805 if(code_list_len <= 1)
808 pNum_codes[max_code_size] += pNum_codes[i];
809 for(i = max_code_size; i > 0; i--)
810 total += (((
mz_uint32)pNum_codes[i]) << (max_code_size - i));
811 while(total != (1UL << max_code_size))
813 pNum_codes[max_code_size]--;
814 for(i = max_code_size - 1; i > 0; i--)
818 pNum_codes[i + 1] += 2;
832 for(i = 0; i < table_len; i++)
838 int num_used_syms = 0;
840 for(i = 0; i < table_len; i++)
850 for(i = 0; i < num_used_syms; i++)
851 num_codes[pSyms[i].m_key]++;
857 for(i = 1, j = num_used_syms; i <= code_size_limit; i++)
858 for(l = num_codes[i]; l > 0; l--)
863 for(j = 0, i = 2; i <= code_size_limit; i++)
864 next_code[i] = j = ((j + num_codes[i - 1]) << 1);
866 for(i = 0; i < table_len; i++)
868 mz_uint rev_code = 0, code, code_size;
871 code = next_code[code_size]++;
872 for(l = code_size; l > 0; l--, code >>= 1)
873 rev_code = (rev_code << 1) | (code & 1);
878 #define TDEFL_PUT_BITS(b, l) \ 883 MZ_ASSERT(bits <= ((1U << len) - 1U)); \ 884 d->m_bit_buffer |= (bits << d->m_bits_in); \ 885 d->m_bits_in += len; \ 886 while(d->m_bits_in >= 8) \ 888 if(d->m_pOutput_buf < d->m_pOutput_buf_end) \ 889 *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ 890 d->m_bit_buffer >>= 8; \ 896 #define TDEFL_RLE_PREV_CODE_SIZE() \ 898 if(rle_repeat_count) \ 900 if(rle_repeat_count < 3) \ 902 d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ 903 while(rle_repeat_count--) \ 904 packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ 908 d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ 909 packed_code_sizes[num_packed_code_sizes++] = 16; \ 910 packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ 912 rle_repeat_count = 0; \ 916 #define TDEFL_RLE_ZERO_CODE_SIZE() \ 920 if(rle_z_count < 3) \ 922 d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ 923 while(rle_z_count--) \ 924 packed_code_sizes[num_packed_code_sizes++] = 0; \ 926 else if(rle_z_count <= 10) \ 928 d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ 929 packed_code_sizes[num_packed_code_sizes++] = 17; \ 930 packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ 934 d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ 935 packed_code_sizes[num_packed_code_sizes++] = 18; \ 936 packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ 942 static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
946 int num_lit_codes, num_dist_codes, num_bit_lengths;
947 mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;
955 for(num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--)
958 for(num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--)
963 memcpy(code_sizes_to_pack + num_lit_codes, &d->
m_huff_code_sizes[1][0], num_dist_codes);
964 total_code_sizes_to_pack = num_lit_codes + num_dist_codes;
965 num_packed_code_sizes = 0;
967 rle_repeat_count = 0;
970 for(i = 0; i < total_code_sizes_to_pack; i++)
972 mz_uint8 code_size = code_sizes_to_pack[i];
976 if(++rle_z_count == 138)
984 if(code_size != prev_code_size)
988 packed_code_sizes[num_packed_code_sizes++] = code_size;
990 else if(++rle_repeat_count == 6)
995 prev_code_size = code_size;
1013 for(num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--)
1016 num_bit_lengths =
MZ_MAX(4, (num_bit_lengths + 1));
1018 for(i = 0; (int)i < num_bit_lengths; i++)
1021 for(packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;)
1023 mz_uint code = packed_code_sizes[packed_code_sizes_index++];
1027 TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++],
"\02\03\07"[code - 16]);
1036 for(i = 0; i <= 143; ++i)
1038 for(; i <= 255; ++i)
1040 for(; i <= 279; ++i)
1042 for(; i <= 287; ++i)
1053 static const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
1055 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES &&MINIZ_LITTLE_ENDIAN &&MINIZ_HAS_64BIT_REGISTERS 1065 #define TDEFL_PUT_BITS_FAST(b, l) \ 1067 bit_buffer |= (((mz_uint64)(b)) << bits_in); \ 1072 for(pLZ_codes = d->
m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1)
1075 flags = *pLZ_codes++ | 0x100;
1079 mz_uint s0,
s1, n0, n1, sym, num_extra_bits;
1080 mz_uint match_len = pLZ_codes[0], match_dist = *(
const mz_uint16 *)(pLZ_codes + 1);
1092 sym = (match_dist < 512) ? s0 :
s1;
1093 num_extra_bits = (match_dist < 512) ? n0 : n1;
1097 TDEFL_PUT_BITS_FAST(match_dist &
mz_bitmasks[num_extra_bits], num_extra_bits);
1105 if(((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
1112 if(((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
1126 pOutput_buf += (bits_in >> 3);
1127 bit_buffer >>= (bits_in & ~7);
1131 #undef TDEFL_PUT_BITS_FAST 1156 for(pLZ_codes = d->
m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1)
1159 flags = *pLZ_codes++ | 0x100;
1163 mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8));
1170 if(match_dist < 512)
1209 mz_uint saved_bit_buf, saved_bits_in;
1262 else if(!comp_block_succeeded)
1280 for(i = 0; i < 4; i++)
1295 for(i = 2; i; --i, z ^= 0xFFFF)
1327 if((n -= bytes_to_copy) != 0)
1342 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1343 #define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p) 1349 mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->
m_dict[
pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD(s);
1351 if(max_match_len <= match_len)
1357 if(--num_probes_left == 0)
1359 #define TDEFL_PROBE \ 1360 next_probe_pos = d->m_next[probe_pos]; \ 1361 if((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ 1363 probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ 1364 if(TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01) \ 1373 if(TDEFL_READ_UNALIGNED_WORD(q) != s01)
1379 }
while((TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) &&
1380 (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (--probe_len > 0));
1383 *pMatch_dist = dist;
1389 *pMatch_dist = dist;
1390 if((*pMatch_len = match_len =
MZ_MIN(max_match_len, probe_len)) == max_match_len)
1392 c01 = TDEFL_READ_UNALIGNED_WORD(&d->
m_dict[
pos + match_len - 1]);
1404 if(max_match_len <= match_len)
1410 if(--num_probes_left == 0)
1412 #define TDEFL_PROBE \ 1413 next_probe_pos = d->m_next[probe_pos]; \ 1414 if((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ 1416 probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ 1417 if((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ 1426 q = d->
m_dict + probe_pos;
1427 for(probe_len = 0; probe_len < max_match_len; probe_len++)
1430 if(probe_len > match_len)
1432 *pMatch_dist = dist;
1433 if((*pMatch_len = match_len = probe_len) == max_match_len)
1442 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES &&MINIZ_LITTLE_ENDIAN 1452 const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096;
1456 lookahead_size += num_bytes_to_process;
1458 while(num_bytes_to_process)
1466 num_bytes_to_process -= n;
1470 if((!d->
m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE))
1473 while(lookahead_size >= 4)
1475 mz_uint cur_match_dist, cur_match_len = 1;
1489 }
while((TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) &&
1490 (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (TDEFL_READ_UNALIGNED_WORD(++p) == TDEFL_READ_UNALIGNED_WORD(++q)) && (--probe_len > 0));
1498 *pLZ_code_buf++ = (
mz_uint8)first_trigram;
1499 *pLZ_flags = (
mz_uint8)(*pLZ_flags >> 1);
1505 cur_match_len =
MZ_MIN(cur_match_len, lookahead_size);
1514 *pLZ_flags = (
mz_uint8)((*pLZ_flags >> 1) | 0x80);
1525 *pLZ_code_buf++ = (
mz_uint8)first_trigram;
1526 *pLZ_flags = (
mz_uint8)(*pLZ_flags >> 1);
1530 if(--num_flags_left == 0)
1533 pLZ_flags = pLZ_code_buf++;
1536 total_lz_bytes += cur_match_len;
1537 lookahead_pos += cur_match_len;
1540 MZ_ASSERT(lookahead_size >= cur_match_len);
1541 lookahead_size -= cur_match_len;
1562 while(lookahead_size)
1567 *pLZ_code_buf++ = lit;
1568 *pLZ_flags = (
mz_uint8)(*pLZ_flags >> 1);
1569 if(--num_flags_left == 0)
1572 pLZ_flags = pLZ_code_buf++;
1664 mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos;
1671 const mz_uint8 *pSrc_end = pSrc + num_bytes_to_process;
1672 src_buf_left -= num_bytes_to_process;
1674 while(pSrc != pSrc_end)
1721 while(cur_match_len < d->m_lookahead_size)
1723 if(d->
m_dict[cur_pos + cur_match_len] != c)
1739 cur_match_dist = cur_match_len = 0;
1746 if(cur_match_len >= 128)
1750 len_to_move = cur_match_len;
1766 else if(!cur_match_dist)
1771 len_to_move = cur_match_len;
1843 (d->
m_wants_to_finish && (flush !=
TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf))
1856 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES &&MINIZ_LITTLE_ENDIAN 1861 if(!tdefl_compress_fast(d))
1893 return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
1903 d->
m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
1943 if(((buf_len) && (!pBuf)) || (!pPut_buf_func))
1964 size_t new_size = p->
m_size + len;
1973 new_capacity =
MZ_MAX(128U, new_capacity << 1U);
1974 }
while(new_size > new_capacity);
1997 *pOut_len = out_buf.
m_size;
2014 #ifndef MINIZ_NO_ZLIB_APIS 2015 static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
2032 else if(strategy ==
MZ_RLE)
2040 #pragma warning(push) 2041 #pragma warning(disable : 4204) 2050 static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
2053 int i, bpl = w * num_chans, y, z;
2071 for(y = 0; y < h; ++y)
2083 *pLen_out = out_buf.
m_size - 41;
2085 static const mz_uint8 chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 };
2086 mz_uint8 pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
2087 0, 0, (
mz_uint8)(w >> 8), (
mz_uint8)w, 0, 0, (
mz_uint8)(h >> 8), (
mz_uint8)h, 8, chans[num_chans], 0, 0, 0, 0, 0, 0, 0,
2090 for(i = 0; i < 4; ++i, c <<= 8)
2092 memcpy(out_buf.
m_pBuf, pnghdr, 41);
2103 for(i = 0; i < 4; ++i, c <<= 8)
2130 #pragma warning(pop) 2170 #define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) 2171 #define TINFL_MEMSET(p, c, l) memset(p, c, l) 2173 #define TINFL_CR_BEGIN \ 2174 switch(r->m_state) \ 2177 #define TINFL_CR_RETURN(state_index, result) \ 2181 r->m_state = state_index; \ 2187 #define TINFL_CR_RETURN_FOREVER(state_index, result) \ 2192 TINFL_CR_RETURN(state_index, result); \ 2196 #define TINFL_CR_FINISH } 2198 #define TINFL_GET_BYTE(state_index, c) \ 2201 while(pIn_buf_cur >= pIn_buf_end) \ 2203 TINFL_CR_RETURN(state_index, (decomp_flags &TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ 2205 c = *pIn_buf_cur++; \ 2209 #define TINFL_NEED_BITS(state_index, n) \ 2213 TINFL_GET_BYTE(state_index, c); \ 2214 bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ 2216 } while(num_bits < (mz_uint)(n)) 2217 #define TINFL_SKIP_BITS(state_index, n) \ 2220 if(num_bits < (mz_uint)(n)) \ 2222 TINFL_NEED_BITS(state_index, n); \ 2228 #define TINFL_GET_BITS(state_index, b, n) \ 2231 if(num_bits < (mz_uint)(n)) \ 2233 TINFL_NEED_BITS(state_index, n); \ 2235 b = bit_buf & ((1 << (n)) - 1); \ 2245 #define TINFL_HUFF_BITBUF_FILL(state_index, pHuff) \ 2248 temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ 2251 code_len = temp >> 9; \ 2252 if((code_len) && (num_bits >= code_len)) \ 2255 else if(num_bits > TINFL_FAST_LOOKUP_BITS) \ 2257 code_len = TINFL_FAST_LOOKUP_BITS; \ 2260 temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \ 2261 } while((temp < 0) && (num_bits >= (code_len + 1))); \ 2265 TINFL_GET_BYTE(state_index, c); \ 2266 bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ 2268 } while(num_bits < 15); 2276 #define TINFL_HUFF_DECODE(state_index, sym, pHuff) \ 2280 mz_uint code_len, c; \ 2283 if((pIn_buf_end - pIn_buf_cur) < 2) \ 2285 TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \ 2289 bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ 2294 if((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ 2295 code_len = temp >> 9, temp &= 511; \ 2298 code_len = TINFL_FAST_LOOKUP_BITS; \ 2301 temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \ 2302 } while(temp < 0); \ 2305 bit_buf >>= code_len; \ 2306 num_bits -= code_len; \ 2312 static const int 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 };
2313 static const int 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 };
2314 static const int 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 };
2315 static const int 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 };
2316 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 };
2317 static const int s_min_table_sizes[3] = { 257, 1, 4 };
2320 mz_uint32 num_bits, dist, counter, num_extra;
2322 const mz_uint8 *pIn_buf_cur = pIn_buf_next, *
const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
2323 mz_uint8 *pOut_buf_cur = pOut_buf_next, *
const pOut_buf_end = pOut_buf_next + *pOut_buf_size;
2327 if(((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start))
2329 *pIn_buf_size = *pOut_buf_size = 0;
2333 num_bits =
r->m_num_bits;
2334 bit_buf =
r->m_bit_buf;
2336 counter =
r->m_counter;
2337 num_extra =
r->m_num_extra;
2338 dist_from_out_buf_start =
r->m_dist_from_out_buf_start;
2341 bit_buf = num_bits = dist = counter = num_extra =
r->m_zhdr0 =
r->m_zhdr1 = 0;
2342 r->m_z_adler32 =
r->m_check_adler32 = 1;
2347 counter = (((
r->m_zhdr0 * 256 +
r->m_zhdr1) % 31 != 0) || (
r->m_zhdr1 & 32) || ((
r->m_zhdr0 & 15) != 8));
2349 counter |= (((1U << (8U + (
r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (
r->m_zhdr0 >> 4)))));
2359 r->m_type =
r->m_final >> 1;
2363 for(counter = 0; counter < 4; ++counter)
2370 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))))
2374 while((counter) && (num_bits))
2377 while(pOut_buf_cur >= pOut_buf_end)
2387 while(pOut_buf_cur >= pOut_buf_end)
2391 while(pIn_buf_cur >= pIn_buf_end)
2395 n =
MZ_MIN(
MZ_MIN((
size_t)(pOut_buf_end - pOut_buf_cur), (
size_t)(pIn_buf_end - pIn_buf_cur)), counter);
2402 else if(
r->m_type == 3)
2410 mz_uint8 *p =
r->m_tables[0].m_code_size;
2412 r->m_table_sizes[0] = 288;
2413 r->m_table_sizes[1] = 32;
2415 for(i = 0; i <= 143; ++i)
2417 for(; i <= 255; ++i)
2419 for(; i <= 279; ++i)
2421 for(; i <= 287; ++i)
2426 for(counter = 0; counter < 3; counter++)
2429 r->m_table_sizes[counter] += s_min_table_sizes[counter];
2432 for(counter = 0; counter <
r->m_table_sizes[2]; counter++)
2436 r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (
mz_uint8)s;
2438 r->m_table_sizes[2] = 19;
2440 for(; (int)
r->m_type >= 0;
r->m_type--)
2442 int tree_next, tree_cur;
2444 mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16];
2445 pTable = &
r->m_tables[
r->m_type];
2449 for(i = 0; i <
r->m_table_sizes[
r->m_type]; ++i)
2451 used_syms = 0, total = 0;
2452 next_code[0] = next_code[1] = 0;
2453 for(i = 1; i <= 15; ++i)
2455 used_syms += total_syms[i];
2456 next_code[i + 1] = (total = ((total + total_syms[i]) << 1));
2458 if((65536 != total) && (used_syms > 1))
2462 for(tree_next = -1, sym_index = 0; sym_index <
r->m_table_sizes[
r->m_type]; ++sym_index)
2467 cur_code = next_code[code_size]++;
2468 for(l = code_size; l > 0; l--, cur_code >>= 1)
2469 rev_code = (rev_code << 1) | (cur_code & 1);
2476 rev_code += (1 << code_size);
2483 tree_cur = tree_next;
2489 tree_cur -= ((rev_code >>= 1) & 1);
2490 if(!pTable->
m_tree[-tree_cur - 1])
2493 tree_cur = tree_next;
2497 tree_cur = pTable->
m_tree[-tree_cur - 1];
2499 tree_cur -= ((rev_code >>= 1) & 1);
2504 for(counter = 0; counter < (
r->m_table_sizes[0] +
r->m_table_sizes[1]);)
2510 r->m_len_codes[counter++] = (
mz_uint8)dist;
2513 if((dist == 16) && (!counter))
2517 num_extra =
"\02\03\07"[dist - 16];
2519 s +=
"\03\03\013"[dist - 16];
2520 TINFL_MEMSET(
r->m_len_codes + counter, (dist == 16) ?
r->m_len_codes[counter - 1] : 0, s);
2523 if((
r->m_table_sizes[0] +
r->m_table_sizes[1]) != counter)
2527 TINFL_MEMCPY(
r->m_tables[0].m_code_size,
r->m_len_codes,
r->m_table_sizes[0]);
2528 TINFL_MEMCPY(
r->m_tables[1].m_code_size,
r->m_len_codes +
r->m_table_sizes[0],
r->m_table_sizes[1]);
2536 if(((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
2541 while(pOut_buf_cur >= pOut_buf_end)
2545 *pOut_buf_cur++ = (
mz_uint8)counter;
2551 #if TINFL_USE_64BIT_BITBUF 2567 code_len = sym2 >> 9;
2573 sym2 =
r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
2577 bit_buf >>= code_len;
2578 num_bits -= code_len;
2582 #if !TINFL_USE_64BIT_BITBUF 2591 code_len = sym2 >> 9;
2597 sym2 =
r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
2600 bit_buf >>= code_len;
2601 num_bits -= code_len;
2603 pOut_buf_cur[0] = (
mz_uint8)counter;
2614 if((counter &= 511) == 256)
2617 num_extra = s_length_extra[counter - 257];
2618 counter = s_length_base[counter - 257];
2623 counter += extra_bits;
2627 num_extra = s_dist_extra[dist];
2628 dist = s_dist_base[dist];
2636 dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
2642 pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
2644 if((
MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
2648 while(pOut_buf_cur >= pOut_buf_end)
2652 *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
2656 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES 2657 else if((counter >= 9) && (counter <= dist))
2659 const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
2665 }
while((pSrc += 8) < pSrc_end);
2666 if((counter &= 7) < 3)
2670 pOut_buf_cur[0] = pSrc[0];
2672 pOut_buf_cur[1] = pSrc[1];
2673 pOut_buf_cur += counter;
2681 pOut_buf_cur[0] = pSrc[0];
2682 pOut_buf_cur[1] = pSrc[1];
2683 pOut_buf_cur[2] = pSrc[2];
2686 }
while((
int)(counter -= 3) > 2);
2687 if((
int)counter > 0)
2689 pOut_buf_cur[0] = pSrc[0];
2690 if((
int)counter > 1)
2691 pOut_buf_cur[1] = pSrc[1];
2692 pOut_buf_cur += counter;
2696 }
while(!(
r->m_final & 1));
2701 while((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
2711 for(counter = 0; counter < 4; ++counter)
2718 r->m_z_adler32 = (
r->m_z_adler32 << 8) | s;
2731 while((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
2737 r->m_num_bits = num_bits;
2740 r->m_counter = counter;
2741 r->m_num_extra = num_extra;
2742 r->m_dist_from_out_buf_start = dist_from_out_buf_start;
2743 *pIn_buf_size = pIn_buf_cur - pIn_buf_next;
2744 *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
2747 const mz_uint8 *ptr = pOut_buf_next;
2748 size_t buf_len = *pOut_buf_size;
2749 mz_uint32 i,
s1 =
r->m_check_adler32 & 0xffff,
s2 =
r->m_check_adler32 >> 16;
2750 size_t block_len = buf_len % 5552;
2753 for(i = 0; i + 7 < block_len; i += 8, ptr += 8)
2764 for(; i < block_len; ++i)
2766 s1 %= 65521U,
s2 %= 65521U;
2767 buf_len -= block_len;
2770 r->m_check_adler32 = (
s2 << 16) +
s1;
2781 void *pBuf = NULL, *pNew_buf;
2782 size_t src_buf_ofs = 0, out_buf_capacity = 0;
2787 size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
2796 src_buf_ofs += src_buf_size;
2797 *pOut_len += dst_buf_size;
2800 new_out_buf_capacity = out_buf_capacity * 2;
2801 if(new_out_buf_capacity < 128)
2802 new_out_buf_capacity = 128;
2803 pNew_buf =
MZ_REALLOC(pBuf, new_out_buf_capacity);
2811 out_buf_capacity = new_out_buf_capacity;
2830 size_t in_buf_ofs = 0, dict_ofs = 0;
2836 size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size =
TINFL_LZ_DICT_SIZE - dict_ofs;
2839 in_buf_ofs += in_buf_size;
2840 if((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (
int)dst_buf_size, pPut_buf_user)))
2850 *pIn_buf_size = in_buf_ofs;
2904 #ifdef MINIZ_NO_STDIO 2905 #define MZ_FILE void * 2907 #include <sys/stat.h> 2909 #if defined(_MSC_VER) || defined(__MINGW64__) 2910 static FILE *mz_fopen(
const char *pFilename,
const char *pMode)
2913 fopen_s(&pFile, pFilename, pMode);
2916 static FILE *mz_freopen(
const char *pPath,
const char *pMode, FILE *pStream)
2919 if(freopen_s(&pFile, pPath, pMode, pStream))
2923 #ifndef MINIZ_NO_TIME 2924 #include <sys/utime.h> 2926 #define MZ_FOPEN mz_fopen 2927 #define MZ_FCLOSE fclose 2928 #define MZ_FREAD fread 2929 #define MZ_FWRITE fwrite 2930 #define MZ_FTELL64 _ftelli64 2931 #define MZ_FSEEK64 _fseeki64 2932 #define MZ_FILE_STAT_STRUCT _stat 2933 #define MZ_FILE_STAT _stat 2934 #define MZ_FFLUSH fflush 2935 #define MZ_FREOPEN mz_freopen 2936 #define MZ_DELETE_FILE remove 2937 #elif defined(__MINGW32__) 2938 #ifndef MINIZ_NO_TIME 2939 #include <sys/utime.h> 2941 #define MZ_FOPEN(f, m) fopen(f, m) 2942 #define MZ_FCLOSE fclose 2943 #define MZ_FREAD fread 2944 #define MZ_FWRITE fwrite 2945 #define MZ_FTELL64 ftello64 2946 #define MZ_FSEEK64 fseeko64 2947 #define MZ_FILE_STAT_STRUCT _stat 2948 #define MZ_FILE_STAT _stat 2949 #define MZ_FFLUSH fflush 2950 #define MZ_FREOPEN(f, m, s) freopen(f, m, s) 2951 #define MZ_DELETE_FILE remove 2952 #elif defined(__TINYC__) 2953 #ifndef MINIZ_NO_TIME 2954 #include <sys/utime.h> 2956 #define MZ_FOPEN(f, m) fopen(f, m) 2957 #define MZ_FCLOSE fclose 2958 #define MZ_FREAD fread 2959 #define MZ_FWRITE fwrite 2960 #define MZ_FTELL64 ftell 2961 #define MZ_FSEEK64 fseek 2962 #define MZ_FILE_STAT_STRUCT stat 2963 #define MZ_FILE_STAT stat 2964 #define MZ_FFLUSH fflush 2965 #define MZ_FREOPEN(f, m, s) freopen(f, m, s) 2966 #define MZ_DELETE_FILE remove 2967 #elif defined(__GNUC__) && _LARGEFILE64_SOURCE 2968 #ifndef MINIZ_NO_TIME 2971 #define MZ_FOPEN(f, m) fopen64(f, m) 2972 #define MZ_FCLOSE fclose 2973 #define MZ_FREAD fread 2974 #define MZ_FWRITE fwrite 2975 #define MZ_FTELL64 ftello64 2976 #define MZ_FSEEK64 fseeko64 2977 #define MZ_FILE_STAT_STRUCT stat64 2978 #define MZ_FILE_STAT stat64 2979 #define MZ_FFLUSH fflush 2980 #define MZ_FREOPEN(p, m, s) freopen64(p, m, s) 2981 #define MZ_DELETE_FILE remove 2982 #elif defined(__APPLE__) && _LARGEFILE64_SOURCE 2983 #ifndef MINIZ_NO_TIME 2986 #define MZ_FOPEN(f, m) fopen(f, m) 2987 #define MZ_FCLOSE fclose 2988 #define MZ_FREAD fread 2989 #define MZ_FWRITE fwrite 2990 #define MZ_FTELL64 ftello 2991 #define MZ_FSEEK64 fseeko 2992 #define MZ_FILE_STAT_STRUCT stat 2993 #define MZ_FILE_STAT stat 2994 #define MZ_FFLUSH fflush 2995 #define MZ_FREOPEN(p, m, s) freopen(p, m, s) 2996 #define MZ_DELETE_FILE remove 2999 #pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.") 3000 #ifndef MINIZ_NO_TIME 3003 #define MZ_FOPEN(f, m) fopen(f, m) 3004 #define MZ_FCLOSE fclose 3005 #define MZ_FREAD fread 3006 #define MZ_FWRITE fwrite 3007 #define MZ_FTELL64 ftello 3008 #define MZ_FSEEK64 fseeko 3009 #define MZ_FILE_STAT_STRUCT stat 3010 #define MZ_FILE_STAT stat 3011 #define MZ_FFLUSH fflush 3012 #define MZ_FREOPEN(f, m, s) freopen(f, m, s) 3013 #define MZ_DELETE_FILE remove 3017 #define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c)) 3140 #define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) (array_ptr)->m_element_size = element_size 3142 #if defined(DEBUG) || defined(_DEBUG) || defined(NDEBUG) 3148 #define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[mz_zip_array_range_check(array_ptr, index)] 3150 #define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[index] 3168 size_t new_capacity = min_new_capacity;
3175 while(new_capacity < min_new_capacity)
3180 pArray->
m_p = pNew_p;
3202 pArray->
m_size = new_size;
3213 size_t orig_size = pArray->
m_size;
3220 #ifndef MINIZ_NO_TIME 3224 memset(&tm, 0,
sizeof(tm));
3226 tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;
3227 tm.tm_mon = ((dos_date >> 5) & 15) - 1;
3228 tm.tm_mday = dos_date & 31;
3229 tm.tm_hour = (dos_time >> 11) & 31;
3230 tm.tm_min = (dos_time >> 5) & 63;
3231 tm.tm_sec = (dos_time << 1) & 62;
3238 struct tm tm_struct;
3239 struct tm *tm = &tm_struct;
3240 errno_t err = localtime_s(tm, &time);
3248 struct tm *tm = localtime(&time);
3251 *pDOS_time = (
mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1));
3252 *pDOS_date = (
mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday);
3255 #ifndef MINIZ_NO_STDIO 3264 *pTime = file_stat.st_mtime;
3273 memset(&t, 0,
sizeof(t));
3274 t.actime = access_time;
3275 t.modtime = modified_time;
3277 return !utime(pFilename, &t);
3331 pE = pL +
MZ_MIN(l_len, r_len);
3339 return (pL == pE) ? (l_len < r_len) : (l <
r);
3342 #define MZ_SWAP_UINT32(a, b) \ 3366 start = (size - 2U) >> 1U;
3372 if((child = (root << 1U) + 1U) >= size)
3374 child += (((child + 1U) < size) && (
mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])));
3392 if((child = (root << 1U) + 1U) >= end)
3394 child += (((child + 1U) < end) &&
mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]));
3423 for(i = n - 4; i >= 0; --i)
3443 cur_file_ofs =
MZ_MAX(cur_file_ofs - (
sizeof(buf_u32) - 3), 0);
3446 *pOfs = cur_file_ofs;
3452 mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, cdir_disk_index = 0;
3461 mz_uint8 *pZip64_locator = (
mz_uint8 *)zip64_end_of_central_dir_locator_u32;
3464 mz_uint8 *pZip64_end_of_central_dir = (
mz_uint8 *)zip64_end_of_central_dir_header_u32;
3466 mz_uint64 zip64_end_of_central_dir_ofs = 0;
3521 if(zip64_total_num_of_disks != 1U)
3533 cdir_entries_on_this_disk = (
mz_uint32)zip64_cdir_total_entries_on_this_disk;
3539 cdir_size = (
mz_uint32)zip64_size_of_central_directory;
3551 if(((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1)))
3570 if(sort_central_dir)
3581 for(n = cdir_size, i = 0; i < pZip->m_total_files; ++i)
3583 mz_uint total_header_size, disk_index, bit_flags, filename_size, ext_data_size;
3584 mz_uint64 comp_size, decomp_size, local_header_ofs;
3591 if(sort_central_dir)
3605 mz_uint32 extra_size_remaining = ext_data_size;
3607 if(extra_size_remaining)
3613 if(extra_size_remaining < (
sizeof(
mz_uint16) * 2))
3619 if((field_data_size +
sizeof(
mz_uint16) * 2) > extra_size_remaining)
3630 pExtra_data +=
sizeof(
mz_uint16) * 2 + field_data_size;
3631 extra_size_remaining = extra_size_remaining -
sizeof(
mz_uint16) * 2 - field_data_size;
3632 }
while(extra_size_remaining);
3644 if((disk_index ==
MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1)))
3660 n -= total_header_size;
3661 p += total_header_size;
3665 if(sort_central_dir)
3701 #ifndef MINIZ_NO_STDIO 3730 if((!pZip) || (!pZip->
m_pRead))
3789 #ifndef MINIZ_NO_STDIO 3818 file_size = archive_size;
3861 if((!pZip) || (!pFile))
3871 archive_size =
MZ_FTELL64(pFile) - cur_file_ofs;
3958 mz_uint filename_len, attribute_mapping_id, external_attr;
3977 (void)attribute_mapping_id;
3991 const mz_uint8 *p = pCentral_dir_header;
3993 if(pFound_zip64_extra_data)
3994 *pFound_zip64_extra_data =
MZ_FALSE;
3996 if((!p) || (!pStat))
4006 #ifndef MINIZ_NO_TIME 4040 if(extra_size_remaining)
4046 if(extra_size_remaining < (
sizeof(
mz_uint16) * 2))
4052 if((field_data_size +
sizeof(
mz_uint16) * 2) > extra_size_remaining)
4058 mz_uint32 field_data_remaining = field_data_size;
4060 if(pFound_zip64_extra_data)
4061 *pFound_zip64_extra_data =
MZ_TRUE;
4065 if(field_data_remaining <
sizeof(
mz_uint64))
4070 field_data_remaining -=
sizeof(
mz_uint64);
4075 if(field_data_remaining <
sizeof(
mz_uint64))
4080 field_data_remaining -=
sizeof(
mz_uint64);
4085 if(field_data_remaining <
sizeof(
mz_uint64))
4090 field_data_remaining -=
sizeof(
mz_uint64);
4096 pExtra_data +=
sizeof(
mz_uint16) * 2 + field_data_size;
4097 extra_size_remaining = extra_size_remaining -
sizeof(
mz_uint16) * 2 - field_data_size;
4098 }
while(extra_size_remaining);
4109 return 0 == memcmp(pA, pB, len);
4110 for(i = 0; i < len; ++i)
4122 pE = pL +
MZ_MIN(l_len, r_len);
4130 return (pL == pE) ? (int)(l_len - r_len) : (l -
r);
4154 uint32_t file_index = pIndices[(uint32_t)m];
4160 *pIndex = file_index;
4185 size_t name_len, comment_len;
4190 if((!pZip) || (!pZip->
m_pState) || (!pName))
4202 name_len = strlen(pName);
4206 comment_len = pComment ? strlen(pComment) : 0;
4210 for(file_index = 0; file_index < pZip->
m_total_files; file_index++)
4215 if(filename_len < name_len)
4220 const char *pFile_comment = pFilename + filename_len + file_extra_len;
4221 if((file_comment_len != comment_len) || (!
mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags)))
4226 int ofs = filename_len - 1;
4229 if((pFilename[ofs] ==
'/') || (pFilename[ofs] ==
'\\') || (pFilename[ofs] ==
':'))
4231 }
while(--ofs >= 0);
4234 filename_len -= ofs;
4236 if((filename_len == name_len) && (
mz_zip_string_equal(pName, pFilename, filename_len, flags)))
4239 *pIndex = file_index;
4250 mz_uint64 needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;
4257 if((!pZip) || (!pZip->
m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->
m_pRead))
4277 if(buf_size < needed_size)
4295 if(pZip->
m_pRead(pZip->
m_pIO_opaque, cur_file_ofs, pBuf, (
size_t)needed_size) != needed_size)
4298 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 4316 read_buf_size = read_buf_avail = file_stat.
m_comp_size;
4319 else if(pUser_read_buf)
4322 if(!user_read_buf_size)
4324 pRead_buf = (
mz_uint8 *)pUser_read_buf;
4325 read_buf_size = user_read_buf_size;
4333 if(((
sizeof(
size_t) ==
sizeof(
mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
4346 size_t in_buf_size, out_buf_size = (size_t)(file_stat.
m_uncomp_size - out_buf_ofs);
4349 read_buf_avail =
MZ_MIN(read_buf_size, comp_remaining);
4350 if(pZip->
m_pRead(pZip->
m_pIO_opaque, cur_file_ofs, pRead_buf, (
size_t)read_buf_avail) != read_buf_avail)
4356 cur_file_ofs += read_buf_avail;
4357 comp_remaining -= read_buf_avail;
4360 in_buf_size = (size_t)read_buf_avail;
4362 read_buf_avail -= in_buf_size;
4363 read_buf_ofs += in_buf_size;
4364 out_buf_ofs += out_buf_size;
4375 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 4410 mz_uint64 comp_size, uncomp_size, alloc_size;
4427 if(((
sizeof(
size_t) ==
sizeof(
mz_uint32))) && (alloc_size > 0x7FFFFFFF))
4446 *pSize = (size_t)alloc_size;
4466 mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;
4468 void *pRead_buf = NULL;
4469 void *pWrite_buf = NULL;
4507 read_buf_size = read_buf_avail = file_stat.
m_comp_size;
4535 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 4546 while(comp_remaining)
4548 read_buf_avail =
MZ_MIN(read_buf_size, comp_remaining);
4549 if(pZip->
m_pRead(pZip->
m_pIO_opaque, cur_file_ofs, pRead_buf, (
size_t)read_buf_avail) != read_buf_avail)
4556 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 4563 if(pCallback(pOpaque, out_buf_ofs, pRead_buf, (
size_t)read_buf_avail) != read_buf_avail)
4570 cur_file_ofs += read_buf_avail;
4571 out_buf_ofs += read_buf_avail;
4572 comp_remaining -= read_buf_avail;
4594 read_buf_avail =
MZ_MIN(read_buf_size, comp_remaining);
4595 if(pZip->
m_pRead(pZip->
m_pIO_opaque, cur_file_ofs, pRead_buf, (
size_t)read_buf_avail) != read_buf_avail)
4601 cur_file_ofs += read_buf_avail;
4602 comp_remaining -= read_buf_avail;
4606 in_buf_size = (size_t)read_buf_avail;
4608 read_buf_avail -= in_buf_size;
4609 read_buf_ofs += in_buf_size;
4613 if(pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)
4620 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 4642 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS 4643 else if(file_crc32 != file_stat.
m_crc32)
4669 #ifndef MINIZ_NO_STDIO 4689 pFile =
MZ_FOPEN(pDst_filename,
"wb");
4703 #if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO) 4755 const mz_uint8 *pCentral_dir_header;
4761 mz_uint32 local_header_filename_len, local_header_extra_len, local_header_crc32;
4762 mz_uint64 local_header_comp_size, local_header_uncomp_size;
4812 has_data_descriptor = (local_header_bit_flags & 8) != 0;
4814 if(local_header_filename_len != strlen(file_stat.
m_filename))
4823 if(local_header_filename_len)
4828 goto handle_failure;
4832 if(memcmp(file_stat.
m_filename, file_data_array.
m_p, local_header_filename_len) != 0)
4835 goto handle_failure;
4844 goto handle_failure;
4847 mz_uint32 extra_size_remaining = local_header_extra_len;
4852 mz_uint32 field_id, field_data_size, field_total_size;
4854 if(extra_size_remaining < (
sizeof(
mz_uint16) * 2))
4859 field_total_size = field_data_size +
sizeof(
mz_uint16) * 2;
4861 if(field_total_size > extra_size_remaining)
4868 if(field_data_size <
sizeof(
mz_uint64) * 2)
4871 goto handle_failure;
4874 local_header_uncomp_size =
MZ_READ_LE64(pSrc_field_data);
4877 found_zip64_ext_data_in_ldir =
MZ_TRUE;
4881 pExtra_data += field_total_size;
4882 extra_size_remaining -= field_total_size;
4883 }
while(extra_size_remaining);
4888 if((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32))
4892 mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4;
4894 if(pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs +
MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size, descriptor_buf,
sizeof(
mz_uint32) * num_descriptor_uint32s) != (
sizeof(
mz_uint32) * num_descriptor_uint32s))
4897 goto handle_failure;
4901 const mz_uint8 *pSrc = has_id ? (descriptor_buf +
sizeof(
mz_uint32)) : descriptor_buf;
4904 mz_uint64 comp_size = 0, uncomp_size = 0;
4906 if((pState->m_zip64) || (found_zip64_ext_data_in_ldir))
4917 if((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size))
4920 goto handle_failure;
4925 if((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size))
4928 goto handle_failure;
4940 if(uncomp_crc32 != file_stat.m_crc32)
4996 if(found_index != i)
5013 if((!pMem) || (!size))
5048 #ifndef MINIZ_NO_STDIO 5093 #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS 5113 #define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) 5114 #define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) 5115 #define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) 5127 if((
sizeof(
size_t) ==
sizeof(
mz_uint32)) && (new_size > 0x7FFFFFFF))
5138 while(new_capacity < new_size)
5147 pState->
m_pMem = pNew_block;
5173 #ifndef MINIZ_NO_STDIO 5269 if(0 != (initial_allocation_size =
MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
5287 #ifndef MINIZ_NO_STDIO 5332 if(size_to_reserve_at_beginning)
5341 size_t n = (size_t)
MZ_MIN(
sizeof(buf), size_to_reserve_at_beginning);
5348 size_to_reserve_at_beginning -= n;
5349 }
while(size_to_reserve_at_beginning);
5408 #ifdef MINIZ_NO_STDIO 5489 #define MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2) 5490 #define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3) 5515 if(pLocal_header_ofs)
5527 static mz_bool mz_zip_writer_create_local_dir_header(
mz_zip_archive *pZip,
mz_uint8 *pDst,
mz_uint16 filename_size,
mz_uint16 extra_size,
mz_uint64 uncomp_size,
mz_uint64 comp_size,
mz_uint32 uncomp_crc32,
mz_uint16 method,
mz_uint16 bit_flags,
mz_uint16 dos_time,
mz_uint16 dos_date)
5571 const void *pExtra,
mz_uint16 extra_size,
const void *pComment,
mz_uint16 comment_size,
5575 const char *user_extra_data,
mz_uint user_extra_data_len)
5584 if(local_header_ofs > 0xFFFFFFFF)
5592 if(!
mz_zip_writer_create_central_dir_header(pZip, central_dir_header, filename_size, extra_size + user_extra_data_len, comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_header_ofs, ext_attributes))
5613 if(*pArchive_name ==
'/')
5616 while(*pArchive_name)
5618 if((*pArchive_name ==
'\\') || (*pArchive_name ==
':'))
5639 memset(buf, 0,
MZ_MIN(
sizeof(buf), n));
5655 return mz_zip_writer_add_mem_ex_v2(pZip, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, uncomp_size, uncomp_crc32, NULL, NULL, 0, NULL, 0);
5660 const char *user_extra_data,
mz_uint user_extra_data_len,
const char *user_extra_data_central,
mz_uint user_extra_data_central_len)
5662 mz_uint16 method = 0, dos_time = 0, dos_date = 0;
5663 mz_uint level, ext_attributes = 0, num_alignment_padding_bytes;
5665 size_t archive_name_size;
5668 mz_bool store_data_uncompressed;
5681 if((
int)level_and_flags < 0)
5683 level = level_and_flags & 0xF;
5703 if((buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))
5716 if(last_modified != NULL)
5722 #ifndef MINIZ_NO_TIME 5731 archive_name_size = strlen(pArchive_name);
5751 if((archive_name_size) && (pArchive_name[archive_name_size - 1] ==
'/'))
5757 if((buf_size) || (uncomp_size))
5765 if((!store_data_uncompressed) && (buf_size))
5777 local_dir_header_ofs += num_alignment_padding_bytes;
5782 cur_archive_file_ofs += num_alignment_padding_bytes;
5795 pExtra_data = extra_data;
5800 if(!
mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (
mz_uint16)archive_name_size, extra_size + user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
5803 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, local_dir_header_ofs, local_dir_header,
sizeof(local_dir_header)) !=
sizeof(local_dir_header))
5806 cur_archive_file_ofs +=
sizeof(local_dir_header);
5808 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
5813 cur_archive_file_ofs += archive_name_size;
5815 if(pExtra_data != NULL)
5817 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
5820 cur_archive_file_ofs += extra_size;
5827 if(!
mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (
mz_uint16)archive_name_size, user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
5830 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, local_dir_header_ofs, local_dir_header,
sizeof(local_dir_header)) !=
sizeof(local_dir_header))
5833 cur_archive_file_ofs +=
sizeof(local_dir_header);
5835 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
5840 cur_archive_file_ofs += archive_name_size;
5843 if(user_extra_data_len > 0)
5845 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
5848 cur_archive_file_ofs += user_extra_data_len;
5854 uncomp_size = buf_size;
5855 if(uncomp_size <= 3)
5858 store_data_uncompressed =
MZ_TRUE;
5862 if(store_data_uncompressed)
5870 cur_archive_file_ofs += buf_size;
5871 comp_size = buf_size;
5904 if(pExtra_data == NULL)
5919 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
5922 cur_archive_file_ofs += local_dir_footer_size;
5925 if(pExtra_data != NULL)
5932 comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
5933 user_extra_data_central, user_extra_data_central_len))
5942 #ifndef MINIZ_NO_STDIO 5944 const char *user_extra_data,
mz_uint user_extra_data_len,
const char *user_extra_data_central,
mz_uint user_extra_data_central_len)
5948 mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;
5949 mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->
m_archive_size, uncomp_size = size_to_add, comp_size = 0;
5950 size_t archive_name_size;
5960 if((
int)level_and_flags < 0)
5962 level = level_and_flags & 0xF;
5998 archive_name_size = strlen(pArchive_name);
6018 #ifndef MINIZ_NO_TIME 6025 if(uncomp_size <= 3)
6033 cur_archive_file_ofs += num_alignment_padding_bytes;
6034 local_dir_header_ofs = cur_archive_file_ofs;
6041 if(uncomp_size && level)
6051 pExtra_data = extra_data;
6056 if(!
mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (
mz_uint16)archive_name_size, extra_size + user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
6059 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, local_dir_header,
sizeof(local_dir_header)) !=
sizeof(local_dir_header))
6062 cur_archive_file_ofs +=
sizeof(local_dir_header);
6064 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
6069 cur_archive_file_ofs += archive_name_size;
6071 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
6074 cur_archive_file_ofs += extra_size;
6080 if(!
mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (
mz_uint16)archive_name_size, user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
6083 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, local_dir_header,
sizeof(local_dir_header)) !=
sizeof(local_dir_header))
6086 cur_archive_file_ofs +=
sizeof(local_dir_header);
6088 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
6093 cur_archive_file_ofs += archive_name_size;
6096 if(user_extra_data_len > 0)
6098 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
6101 cur_archive_file_ofs += user_extra_data_len;
6106 mz_uint64 uncomp_remaining = uncomp_size;
6115 while(uncomp_remaining)
6124 uncomp_remaining -= n;
6125 cur_archive_file_ofs += n;
6127 comp_size = uncomp_size;
6156 if(
MZ_FREAD(pRead_buf, 1, in_buf_size, pSrc_file) != in_buf_size)
6163 uncomp_remaining -= in_buf_size;
6198 if(pExtra_data == NULL)
6213 if(pZip->
m_pWrite(pZip->
m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
6216 cur_archive_file_ofs += local_dir_footer_size;
6218 if(pExtra_data != NULL)
6225 uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
6226 user_extra_data_central, user_extra_data_central_len))
6242 memset(&file_modified_time, 0,
sizeof(file_modified_time));
6244 #if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO) 6245 pFile_time = &file_modified_time;
6250 pSrc_file =
MZ_FOPEN(pSrc_filename,
"rb");
6258 mz_bool status =
mz_zip_writer_add_cfile(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags, NULL, 0, NULL, 0);
6274 if((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start))
6294 if(pLocal_header_ofs)
6312 if((pExt) && (ext_len))
6314 mz_uint32 extra_size_remaining = ext_len;
6315 const mz_uint8 *pExtra_data = pExt;
6319 mz_uint32 field_id, field_data_size, field_total_size;
6321 if(extra_size_remaining < (
sizeof(
mz_uint16) * 2))
6326 field_total_size = field_data_size +
sizeof(
mz_uint16) * 2;
6328 if(field_total_size > extra_size_remaining)
6337 pExtra_data += field_total_size;
6338 extra_size_remaining -= field_total_size;
6339 }
while(extra_size_remaining);
6348 mz_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;
6349 mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs;
6350 mz_uint64 cur_src_file_ofs, cur_dst_file_ofs;
6354 size_t orig_central_dir_size;
6357 const mz_uint8 *pSrc_central_header;
6359 mz_uint32 src_filename_len, src_comment_len, src_ext_len;
6360 mz_uint32 local_header_filename_size, local_header_extra_len;
6361 mz_uint64 local_header_comp_size, local_header_uncomp_size;
6375 if(NULL == (pSrc_central_header =
mz_zip_get_cdh(pSource_zip, src_file_index)))
6384 src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len;
6424 src_archive_bytes_remaining = local_header_filename_size + local_header_extra_len + src_file_stat.
m_comp_size;
6442 mz_uint32 extra_size_remaining = local_header_extra_len;
6447 mz_uint32 field_id, field_data_size, field_total_size;
6449 if(extra_size_remaining < (
sizeof(
mz_uint16) * 2))
6457 field_total_size = field_data_size +
sizeof(
mz_uint16) * 2;
6459 if(field_total_size > extra_size_remaining)
6469 if(field_data_size <
sizeof(
mz_uint64) * 2)
6475 local_header_uncomp_size =
MZ_READ_LE64(pSrc_field_data);
6478 found_zip64_ext_data_in_ldir =
MZ_TRUE;
6482 pExtra_data += field_total_size;
6483 extra_size_remaining -= field_total_size;
6484 }
while(extra_size_remaining);
6489 if(!pState->m_zip64)
6504 cur_dst_file_ofs += num_alignment_padding_bytes;
6506 local_dir_header_ofs = cur_dst_file_ofs;
6507 if(pZip->m_file_offset_alignment)
6509 MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
6522 while(src_archive_bytes_remaining)
6525 if(pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n)
6527 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
6530 cur_src_file_ofs += n;
6532 if(pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
6534 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
6537 cur_dst_file_ofs += n;
6539 src_archive_bytes_remaining -= n;
6547 if((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir))
6556 if(pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (
sizeof(
mz_uint32) * 6)) != (
sizeof(
mz_uint32) * 6))
6558 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
6569 if(pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf,
sizeof(
mz_uint32) * 4) !=
sizeof(
mz_uint32) * 4)
6571 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
6577 if(pZip->m_pState->m_zip64)
6581 const mz_uint32 src_crc32 = pSrc_descriptor[0];
6582 const mz_uint64 src_comp_size = pSrc_descriptor[1];
6583 const mz_uint64 src_uncomp_size = pSrc_descriptor[2];
6595 n =
sizeof(
mz_uint32) * (has_id ? 4 : 3);
6599 if(pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
6601 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
6605 cur_src_file_ofs += n;
6606 cur_dst_file_ofs += n;
6608 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
6611 orig_central_dir_size = pState->m_central_dir.m_size;
6700 pZip->m_total_files++;
6701 pZip->m_archive_size = cur_dst_file_ofs;
6709 mz_uint64 central_dir_ofs, central_dir_size;
6728 central_dir_ofs = 0;
6729 central_dir_size = 0;
6783 #ifndef MINIZ_NO_STDIO 6796 if((!ppBuf) || (!pSize))
6824 #ifndef MINIZ_NO_STDIO 6838 if((
int)level_and_flags < 0)
6841 if((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) >
MZ_UBER_COMPRESSION))
6867 created_new_archive =
MZ_TRUE;
6890 status =
mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);
6910 if((!status) && (created_new_archive))
6914 (void)ignoredStatus;
6932 if((!pZip_filename) || (!pArchive_name))
7029 return "undefined error";
7031 return "too many files";
7033 return "file too large";
7035 return "unsupported method";
7037 return "unsupported encryption";
7039 return "unsupported feature";
7041 return "failed finding central directory";
7043 return "not a ZIP archive";
7045 return "invalid header or archive is corrupted";
7047 return "unsupported multidisk archive";
7049 return "decompression failed or archive is corrupted";
7051 return "compression failed";
7053 return "unexpected decompressed size";
7055 return "CRC-32 check failed";
7057 return "unsupported central directory size";
7059 return "allocation failed";
7061 return "file open failed";
7063 return "file create failed";
7065 return "file write failed";
7067 return "file read failed";
7069 return "file close failed";
7071 return "file seek failed";
7073 return "file stat failed";
7075 return "invalid parameter";
7077 return "invalid filename";
7079 return "buffer too small";
7081 return "internal error";
7083 return "file not found";
7085 return "archive is too large";
7087 return "validation failed";
7089 return "write calledback failed";
7094 return "unknown error";
7154 if(filename_buf_size)
7155 pFilename[0] =
'\0';
7160 if(filename_buf_size)
7162 n =
MZ_MIN(n, filename_buf_size - 1);
7164 pFilename[n] =
'\0';
void * tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip)
#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED
#define MZ_WRITE_LE32(p, v)
#define MZ_WRITE_LE16(p, v)
char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE]
static mz_bool mz_zip_writer_create_central_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)
mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE]
mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, FILE *pFile, mz_uint64 archive_size, mz_uint flags)
tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d)
mz_uint8 m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]
mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr)
mz_uint m_lz_code_buf_dict_pos
tdefl_compressor * tdefl_compressor_alloc()
mz_zip_array m_central_dir
static const mz_uint8 s_tdefl_small_dist_extra[512]
mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, FILE *pFile, mz_uint flags)
int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
static mz_bool mz_zip_writer_update_zip64_extension_block(mz_zip_array *pNew_ext, mz_zip_archive *pZip, const mz_uint8 *pExt, uint32_t ext_len, mz_uint64 *pComp_size, mz_uint64 *pUncomp_size, mz_uint64 *pLocal_header_ofs, mz_uint32 *pDisk_start)
#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size)
tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
mz_uint m_saved_match_dist
static void tdefl_start_static_block(tdefl_compressor *d)
static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename, mz_uint32 *pIndex)
#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index)
mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index)
static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[]
int mz_deflateReset(mz_streamp pStream)
void * tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out)
int mz_inflate(mz_streamp pStream, int flush)
mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
static tdefl_sym_freq * tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq *pSyms0, tdefl_sym_freq *pSyms1)
static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
const char * mz_version(void)
static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index)
void * mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr)
static const mz_uint8 * mz_zip_get_cdh(mz_zip_archive *pZip, mz_uint file_index)
unsigned char mz_validate_uint64[sizeof(mz_uint64)==8 ? 1 :-1]
int mz_deflateInit(mz_streamp pStream, int level)
static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n)
#define TINFL_HUFF_DECODE(state_index, sym, pHuff)
int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip)
mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip)
size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip)
mz_bool mz_zip_end(mz_zip_archive *pZip)
unsigned char mz_validate_uint32[sizeof(mz_uint32)==4 ? 1 :-1]
mz_uint m_wants_to_finish
mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, FILE *pSrc_file, mz_uint64 size_to_add, const time_t *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
#define TINFL_CR_RETURN(state_index, result)
mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags)
int mz_inflateEnd(mz_streamp pStream)
static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)
mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)
mz_uint m_output_flush_ofs
mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip)
mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize)
static mz_bool tdefl_compress_normal(tdefl_compressor *d)
static const mz_uint16 s_tdefl_len_sym[256]
mz_uint32 m_external_attr
static int tdefl_flush_block(tdefl_compressor *d, int flush)
static mz_bool mz_zip_file_stat_internal(mz_zip_archive *pZip, mz_uint file_index, const mz_uint8 *pCentral_dir_header, mz_zip_archive_file_stat *pStat, mz_bool *pFound_zip64_extra_data)
static time_t mz_zip_dos_to_time_t(int dos_time, int dos_date)
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)
mz_uint m_output_flush_remaining
mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
void miniz_def_free_func(void *opaque, void *address)
mz_ulong mz_compressBound(mz_ulong source_len)
static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
mz_uint16 m_version_made_by
int mz_inflateInit(mz_streamp pStream)
static int mz_zip_filename_compare(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, const char *pR, mz_uint r_len)
mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)
struct mz_internal_state * state
void mz_zip_zero_struct(mz_zip_archive *pZip)
mz_zip_internal_state * m_pState
mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip)
static mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)
mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len)
#define TINFL_MEMCPY(d, s, l)
static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0]
#define TDEFL_RLE_PREV_CODE_SIZE()
mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags)
mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, FILE *pFile, mz_uint flags)
mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32)
mz_uint8 * m_pOutput_buf_end
mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, time_t *last_modified, const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
mz_uint32 tinfl_bit_buf_t
size_t(* mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]
static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)
tdefl_put_buf_func_ptr m_pPut_buf_func
void * tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
#define TDEFL_RLE_ZERO_CODE_SIZE()
static void mz_write_le16(mz_uint8 *p, mz_uint16 v)
static mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)
mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename)
mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags)
static mz_bool mz_zip_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags)
mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index)
static void tdefl_start_dynamic_block(tdefl_compressor *d)
mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, FILE *pFile, mz_uint flags)
mz_uint m_saved_match_len
mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex)
static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
static mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)
int mz_inflateInit2(mz_streamp pStream, int window_bits)
static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)
void * mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)
mz_realloc_func m_pRealloc
#define tinfl_get_adler32(r)
const unsigned char * next_in
mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE+TDEFL_MAX_MATCH_LEN - 1]
static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)
int(* tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser)
size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n)
int mz_deflate(mz_streamp pStream, int flush)
mz_uint64 m_central_directory_file_ofs
tinfl_decompressor m_decomp
#define MZ_FILE_STAT_STRUCT
mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
void * miniz_def_alloc_func(void *opaque, size_t items, size_t size)
static void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)
int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE]
static const mz_uint8 s_tdefl_len_extra[256]
static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, mz_uint32 record_sig, mz_uint32 record_size, mz_int64 *pOfs)
mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index)
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE]
static void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)
mz_uint64 m_file_archive_start_ofs
static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)
static void mz_write_le64(mz_uint8 *p, mz_uint64 v)
mz_int16 m_tree[TINFL_MAX_HUFF_SYMBOLS_0 *2]
mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags)
#define TINFL_GET_BITS(state_index, b, n)
mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
#define TINFL_GET_BYTE(state_index, c)
void * tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
static const mz_uint8 s_tdefl_small_dist_sym[512]
mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags)
tdefl_status m_prev_return_status
mz_bool mz_zip_reader_end(mz_zip_archive *pZip)
#define MZ_SWAP_UINT32(a, b)
mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags)
mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr)
mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
static void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser)
static mz_uint32 mz_zip_writer_create_zip64_extra_data(mz_uint8 *pBuf, mz_uint64 *pUncomp_size, mz_uint64 *pComp_size, mz_uint64 *pLocal_header_ofs)
mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)
mz_file_read_func m_pRead
void * mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
#define TINFL_CR_RETURN_FOREVER(state_index, result)
mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip)
mz_bool mz_zip_is_zip64(mz_zip_archive *pZip)
static mz_bool mz_zip_set_file_times(const char *pFilename, time_t access_time, time_t modified_time)
#define MZ_CLEAR_OBJ(obj)
int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)
#define TINFL_LZ_DICT_SIZE
mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr)
static mz_bool mz_zip_get_file_modified_time(const char *pFilename, time_t *pTime)
unsigned char mz_validate_uint16[sizeof(mz_uint16)==2 ? 1 :-1]
size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE]
const char * mz_error(int err)
static mz_bool mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)
static void mz_write_le32(mz_uint8 *p, mz_uint32 v)
mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning)
void tinfl_decompressor_free(tinfl_decompressor *pDecomp)
mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip)
void tdefl_compressor_free(tdefl_compressor *pComp)
static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags)
mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
#define MZ_FREOPEN(f, m, s)
static const mz_uint mz_bitmasks[17]
mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size)
mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)
mz_uint16 m_next[TDEFL_LZ_DICT_SIZE]
static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
tinfl_decompressor * tinfl_decompressor_alloc()
mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
static const mz_uint s_tdefl_num_probes[11]
static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
static mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num)
mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip)
mz_bool mz_zip_writer_end(mz_zip_archive *pZip)
mz_file_write_func m_pWrite
void * miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size)
int mz_deflateEnd(mz_streamp pStream)
#define MZ_WRITE_LE64(p, v)
tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags)
#define MZ_DEFAULT_WINDOW_BITS
mz_uint16 m_internal_attr
mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags)
#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE
mz_uint64 m_central_dir_ofs
static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
static void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
mz_uint64 m_cur_archive_file_ofs
static mz_bool mz_zip_writer_add_to_central_dir(mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size, const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes, const char *user_extra_data, mz_uint user_extra_data_len)
mz_zip_error m_last_error
mz_zip_array m_central_dir_offsets
#define TINFL_SKIP_BITS(state_index, n)
static void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size)
FILE * mz_zip_get_cfile(mz_zip_archive *pZip)
mz_uint64 m_file_offset_alignment
static void mz_zip_time_t_to_dos_time(time_t time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
mz_uint16 m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]
mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags)
mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags)
mz_uint32 tdefl_get_adler32(tdefl_compressor *d)
mz_uint64 m_local_header_ofs
static mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)
mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip)
mz_bool m_zip64_has_extended_info_fields
mz_zip_array m_sorted_central_dir_offsets
static mz_bool mz_zip_writer_create_local_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)
void * mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags)
mz_uint8 * m_pLZ_code_buf
mz_bool(* tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser)
char m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE]
#define TINFL_MEMSET(p, c, l)
static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
mz_uint16 m_version_needed
static const mz_uint8 s_tdefl_large_dist_sym[128]
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
tinfl_status m_last_status
static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)
mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
mz_zip_type mz_zip_get_type(mz_zip_archive *pZip)
const char * mz_zip_get_error_string(mz_zip_error mz_err)
#define TDEFL_PUT_BITS(b, l)
static const mz_uint8 s_tdefl_large_dist_extra[128]
mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip)