// Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions).
61
#define MINIZ_HAS_64BIT_REGISTERS 1
62
#endif
63
64
#ifdef __cplusplus
65
extern "C" {
66
#endif
67
68
// ------------------- zlib-style API Definitions.
69
70
// For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits!
71
typedef unsigned long mz_ulong;
72
73
// mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap.
74
void mz_free(void *p);
75
76
#define MZ_ADLER32_INIT (1)
77
// mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL.
// Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL.
const unsigned char *next_in; // pointer to next byte to read
123
unsigned int avail_in; // number of bytes available at next_in
124
mz_ulong total_in; // total number of bytes consumed so far
125
126
unsigned char *next_out; // pointer to next byte to write
127
unsigned int avail_out; // number of bytes that can be written to next_out
128
mz_ulong total_out; // total number of bytes produced so far
129
130
char *msg; // error msg (unused)
131
struct mz_internal_state *state; // internal state, allocated by zalloc/zfree
132
133
mz_alloc_func zalloc; // optional heap allocation function (defaults to malloc)
134
mz_free_func zfree; // optional heap free function (defaults to free)
135
void *opaque; // heap alloc function user pointer
136
137
int data_type; // data_type (unused)
138
mz_ulong adler; // adler32 of the source or uncompressed data
139
mz_ulong reserved; // not used
140
} mz_stream;
141
142
typedef mz_stream *mz_streamp;
143
144
// Returns the version string of miniz.c.
145
const char *mz_version(void);
146
147
// mz_deflateInit() initializes a compressor with default options:
148
// Parameters:
149
// pStream must point to an initialized mz_stream struct.
150
// level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION].
151
// level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio.
152
// (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.)
153
// Return values:
154
// MZ_OK on success.
155
// MZ_STREAM_ERROR if the stream is bogus.
156
// MZ_PARAM_ERROR if the input parameters are bogus.
157
// MZ_MEM_ERROR on out of memory.
158
int mz_deflateInit(mz_streamp pStream, int level);
159
160
// mz_deflateInit2() is like mz_deflate(), except with more control:
161
// Additional parameters:
162
// method must be MZ_DEFLATED
163
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer)
164
// mem_level must be between [1, 9] (it's checked but ignored by miniz.c)
165
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
166
167
// Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2().
168
int mz_deflateReset(mz_streamp pStream);
169
170
// mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible.
171
// Parameters:
172
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
173
// flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH.
174
// Return values:
175
// MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full).
176
// MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore.
177
// MZ_STREAM_ERROR if the stream is bogus.
178
// MZ_PARAM_ERROR if one of the parameters is invalid.
179
// MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.)
180
int mz_deflate(mz_streamp pStream, int flush);
181
182
// mz_deflateEnd() deinitializes a compressor:
183
// Return values:
184
// MZ_OK on success.
185
// MZ_STREAM_ERROR if the stream is bogus.
186
int mz_deflateEnd(mz_streamp pStream);
187
188
// mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH.
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);
195
196
// mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress().
197
mz_ulong mz_compressBound(mz_ulong source_len);
198
199
// Initializes a decompressor.
200
int mz_inflateInit(mz_streamp pStream);
201
202
// mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer:
203
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate).
204
int mz_inflateInit2(mz_streamp pStream, int window_bits);
205
206
// Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible.
207
// Parameters:
208
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
209
// flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH.
210
// On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster).
211
// MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data.
212
// Return values:
213
// MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full.
214
// MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified.
215
// MZ_STREAM_ERROR if the stream is bogus.
216
// MZ_DATA_ERROR if the deflate stream is invalid.
217
// MZ_PARAM_ERROR if one of the parameters is invalid.
218
// MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again
219
// with more input data, or with more room in the output buffer (except when using single call decompression, described above).
220
int mz_inflate(mz_streamp pStream, int flush);
221
222
// Deinitializes a decompressor.
223
int mz_inflateEnd(mz_streamp pStream);
224
225
// Single-call decompression.
226
// Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure.
// Retrieves the filename of an archive file entry.
429
// Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename.
// Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive.
476
// For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called.
477
// For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it).
478
// Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL.
479
// Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before
480
// the archive is finalized the file's central directory will be hosed.
// Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive.
484
// To add a directory entry, call this method with an archive name ending in a forwardslash with empty buffer.
485
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive.
491
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used.
506
// Note for the archive to be valid, it must have been finalized before ending.
507
mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
508
509
// Misc. high-level helper functions:
510
511
// mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive.
512
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// ------------------- Low-level Decompression API Definitions
524
525
// Decompression flags used by tinfl_decompress().
526
// TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream.
527
// TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input.
528
// TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB).
529
// TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes.
530
enum
531
{
532
TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
533
TINFL_FLAG_HAS_MORE_INPUT = 2,
534
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
535
TINFL_FLAG_COMPUTE_ADLER32 = 8
536
};
537
538
// High level decompression functions:
539
// tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc().
540
// On entry:
541
// pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress.
542
// On return:
543
// Function returns a pointer to the decompressed data, or NULL on failure.
544
// *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data.
545
// The caller must call mz_free() on the returned block when it's no longer needed.
546
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
547
548
// tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory.
549
// Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success.
// tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer.
554
// Returns 1 on success or 0 on failure.
555
typedef int (*tinfl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
556
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);
// Initializes the decompressor to its initial state.
575
#define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END
576
#define tinfl_get_adler32(r) (r)->m_check_adler32
577
578
// Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability.
579
// This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output.
// TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data.
629
// TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers).
630
// TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing.
631
// TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory).
632
// TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1)
633
// TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled.
634
// TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables.
635
// TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks.
636
// The low 12 bits are reserved to control the max # of hash probes per dictionary lookup (see TDEFL_MAX_PROBES_MASK).
637
enum
638
{
639
TDEFL_WRITE_ZLIB_HEADER = 0x01000,
640
TDEFL_COMPUTE_ADLER32 = 0x02000,
641
TDEFL_GREEDY_PARSING_FLAG = 0x04000,
642
TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
643
TDEFL_RLE_MATCHES = 0x10000,
644
TDEFL_FILTER_MATCHES = 0x20000,
645
TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000,
646
TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000
647
};
648
649
// High level compression functions:
650
// tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc().
651
// On entry:
652
// pSrc_buf, src_buf_len: Pointer and size of source block to compress.
653
// flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression.
654
// On return:
655
// Function returns a pointer to the compressed data, or NULL on failure.
656
// *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data.
657
// The caller must free() the returned block when it's no longer needed.
658
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
659
660
// tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory.
// The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions.
693
typedef enum
694
{
695
TDEFL_STATUS_BAD_PARAM = -2,
696
TDEFL_STATUS_PUT_BUF_FAILED = -1,
697
TDEFL_STATUS_OKAY = 0,
698
TDEFL_STATUS_DONE = 1,
699
} tdefl_status;
700
701
// Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums
// There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory.
740
// pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression.
741
// If pBut_buf_func is NULL the user should always call the tdefl_compress() API.
742
// flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.)
743
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
744
745
// Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible.
// Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions).
830
#define MINIZ_HAS_64BIT_REGISTERS 1
831
#endif
832
833
#ifdef __cplusplus
834
extern "C" {
835
#endif
836
837
// ------------------- zlib-style API Definitions.
838
839
// For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits!
840
typedef unsigned long mz_ulong;
841
842
// mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap.
843
void mz_free(void *p);
844
845
#define MZ_ADLER32_INIT (1)
846
// mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL.
// Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL.
const unsigned char *next_in; // pointer to next byte to read
892
unsigned int avail_in; // number of bytes available at next_in
893
mz_ulong total_in; // total number of bytes consumed so far
894
895
unsigned char *next_out; // pointer to next byte to write
896
unsigned int avail_out; // number of bytes that can be written to next_out
897
mz_ulong total_out; // total number of bytes produced so far
898
899
char *msg; // error msg (unused)
900
struct mz_internal_state *state; // internal state, allocated by zalloc/zfree
901
902
mz_alloc_func zalloc; // optional heap allocation function (defaults to malloc)
903
mz_free_func zfree; // optional heap free function (defaults to free)
904
void *opaque; // heap alloc function user pointer
905
906
int data_type; // data_type (unused)
907
mz_ulong adler; // adler32 of the source or uncompressed data
908
mz_ulong reserved; // not used
909
} mz_stream;
910
911
typedef mz_stream *mz_streamp;
912
913
// Returns the version string of miniz.c.
914
const char *mz_version(void);
915
916
// mz_deflateInit() initializes a compressor with default options:
917
// Parameters:
918
// pStream must point to an initialized mz_stream struct.
919
// level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION].
920
// level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio.
921
// (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.)
922
// Return values:
923
// MZ_OK on success.
924
// MZ_STREAM_ERROR if the stream is bogus.
925
// MZ_PARAM_ERROR if the input parameters are bogus.
926
// MZ_MEM_ERROR on out of memory.
927
int mz_deflateInit(mz_streamp pStream, int level);
928
929
// mz_deflateInit2() is like mz_deflate(), except with more control:
930
// Additional parameters:
931
// method must be MZ_DEFLATED
932
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer)
933
// mem_level must be between [1, 9] (it's checked but ignored by miniz.c)
934
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
935
936
// Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2().
937
int mz_deflateReset(mz_streamp pStream);
938
939
// mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible.
940
// Parameters:
941
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
942
// flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH.
943
// Return values:
944
// MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full).
945
// MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore.
946
// MZ_STREAM_ERROR if the stream is bogus.
947
// MZ_PARAM_ERROR if one of the parameters is invalid.
948
// MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.)
949
int mz_deflate(mz_streamp pStream, int flush);
950
951
// mz_deflateEnd() deinitializes a compressor:
952
// Return values:
953
// MZ_OK on success.
954
// MZ_STREAM_ERROR if the stream is bogus.
955
int mz_deflateEnd(mz_streamp pStream);
956
957
// mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH.
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);
964
965
// mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress().
966
mz_ulong mz_compressBound(mz_ulong source_len);
967
968
// Initializes a decompressor.
969
int mz_inflateInit(mz_streamp pStream);
970
971
// mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer:
972
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate).
973
int mz_inflateInit2(mz_streamp pStream, int window_bits);
974
975
// Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible.
976
// Parameters:
977
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
978
// flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH.
979
// On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster).
980
// MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data.
981
// Return values:
982
// MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full.
983
// MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified.
984
// MZ_STREAM_ERROR if the stream is bogus.
985
// MZ_DATA_ERROR if the deflate stream is invalid.
986
// MZ_PARAM_ERROR if one of the parameters is invalid.
987
// MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again
988
// with more input data, or with more room in the output buffer (except when using single call decompression, described above).
989
int mz_inflate(mz_streamp pStream, int flush);
990
991
// Deinitializes a decompressor.
992
int mz_inflateEnd(mz_streamp pStream);
993
994
// Single-call decompression.
995
// Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure.
// Retrieves the filename of an archive file entry.
1198
// Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename.
// Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive.
1245
// For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called.
1246
// For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it).
1247
// Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL.
1248
// Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before
1249
// the archive is finalized the file's central directory will be hosed.
// Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive.
1253
// To add a directory entry, call this method with an archive name ending in a forwardslash with empty buffer.
1254
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive.
1260
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used.
1275
// Note for the archive to be valid, it must have been finalized before ending.
1276
mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
1277
1278
// Misc. high-level helper functions:
1279
1280
// mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive.
1281
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// ------------------- Low-level Decompression API Definitions
1293
1294
// Decompression flags used by tinfl_decompress().
1295
// TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream.
1296
// TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input.
1297
// TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB).
1298
// TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes.
1299
enum
1300
{
1301
TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
1302
TINFL_FLAG_HAS_MORE_INPUT = 2,
1303
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
1304
TINFL_FLAG_COMPUTE_ADLER32 = 8
1305
};
1306
1307
// High level decompression functions:
1308
// tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc().
1309
// On entry:
1310
// pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress.
1311
// On return:
1312
// Function returns a pointer to the decompressed data, or NULL on failure.
1313
// *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data.
1314
// The caller must call mz_free() on the returned block when it's no longer needed.
1315
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
1316
1317
// tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory.
1318
// Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success.
// tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer.
1323
// Returns 1 on success or 0 on failure.
1324
typedef int (*tinfl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
1325
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);
// Initializes the decompressor to its initial state.
1344
#define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END
1345
#define tinfl_get_adler32(r) (r)->m_check_adler32
1346
1347
// Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability.
1348
// This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output.
// TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data.
1398
// TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers).
1399
// TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing.
1400
// TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory).
1401
// TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1)
1402
// TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled.
1403
// TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables.
1404
// TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks.
1405
// The low 12 bits are reserved to control the max # of hash probes per dictionary lookup (see TDEFL_MAX_PROBES_MASK).
1406
enum
1407
{
1408
TDEFL_WRITE_ZLIB_HEADER = 0x01000,
1409
TDEFL_COMPUTE_ADLER32 = 0x02000,
1410
TDEFL_GREEDY_PARSING_FLAG = 0x04000,
1411
TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
1412
TDEFL_RLE_MATCHES = 0x10000,
1413
TDEFL_FILTER_MATCHES = 0x20000,
1414
TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000,
1415
TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000
1416
};
1417
1418
// High level compression functions:
1419
// tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc().
1420
// On entry:
1421
// pSrc_buf, src_buf_len: Pointer and size of source block to compress.
1422
// flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression.
1423
// On return:
1424
// Function returns a pointer to the compressed data, or NULL on failure.
1425
// *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data.
1426
// The caller must free() the returned block when it's no longer needed.
1427
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
1428
1429
// tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory.
// The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions.
1462
typedef enum
1463
{
1464
TDEFL_STATUS_BAD_PARAM = -2,
1465
TDEFL_STATUS_PUT_BUF_FAILED = -1,
1466
TDEFL_STATUS_OKAY = 0,
1467
TDEFL_STATUS_DONE = 1,
1468
} tdefl_status;
1469
1470
// Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums
// There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory.
1509
// pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression.
1510
// If pBut_buf_func is NULL the user should always call the tdefl_compress() API.
1511
// flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.)
1512
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
1513
1514
// Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible.
// Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions).
1599
#define MINIZ_HAS_64BIT_REGISTERS 1
1600
#endif
1601
1602
#ifdef __cplusplus
1603
extern "C" {
1604
#endif
1605
1606
// ------------------- zlib-style API Definitions.
1607
1608
// For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits!
1609
typedef unsigned long mz_ulong;
1610
1611
// mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap.
1612
void mz_free(void *p);
1613
1614
#define MZ_ADLER32_INIT (1)
1615
// mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL.
// Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL.
const unsigned char *next_in; // pointer to next byte to read
1661
unsigned int avail_in; // number of bytes available at next_in
1662
mz_ulong total_in; // total number of bytes consumed so far
1663
1664
unsigned char *next_out; // pointer to next byte to write
1665
unsigned int avail_out; // number of bytes that can be written to next_out
1666
mz_ulong total_out; // total number of bytes produced so far
1667
1668
char *msg; // error msg (unused)
1669
struct mz_internal_state *state; // internal state, allocated by zalloc/zfree
1670
1671
mz_alloc_func zalloc; // optional heap allocation function (defaults to malloc)
1672
mz_free_func zfree; // optional heap free function (defaults to free)
1673
void *opaque; // heap alloc function user pointer
1674
1675
int data_type; // data_type (unused)
1676
mz_ulong adler; // adler32 of the source or uncompressed data
1677
mz_ulong reserved; // not used
1678
} mz_stream;
1679
1680
typedef mz_stream *mz_streamp;
1681
1682
// Returns the version string of miniz.c.
1683
const char *mz_version(void);
1684
1685
// mz_deflateInit() initializes a compressor with default options:
1686
// Parameters:
1687
// pStream must point to an initialized mz_stream struct.
1688
// level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION].
1689
// level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio.
1690
// (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.)
1691
// Return values:
1692
// MZ_OK on success.
1693
// MZ_STREAM_ERROR if the stream is bogus.
1694
// MZ_PARAM_ERROR if the input parameters are bogus.
1695
// MZ_MEM_ERROR on out of memory.
1696
int mz_deflateInit(mz_streamp pStream, int level);
1697
1698
// mz_deflateInit2() is like mz_deflate(), except with more control:
1699
// Additional parameters:
1700
// method must be MZ_DEFLATED
1701
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer)
1702
// mem_level must be between [1, 9] (it's checked but ignored by miniz.c)
1703
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
1704
1705
// Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2().
1706
int mz_deflateReset(mz_streamp pStream);
1707
1708
// mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible.
1709
// Parameters:
1710
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
1711
// flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH.
1712
// Return values:
1713
// MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full).
1714
// MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore.
1715
// MZ_STREAM_ERROR if the stream is bogus.
1716
// MZ_PARAM_ERROR if one of the parameters is invalid.
1717
// MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.)
1718
int mz_deflate(mz_streamp pStream, int flush);
1719
1720
// mz_deflateEnd() deinitializes a compressor:
1721
// Return values:
1722
// MZ_OK on success.
1723
// MZ_STREAM_ERROR if the stream is bogus.
1724
int mz_deflateEnd(mz_streamp pStream);
1725
1726
// mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH.
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);
1733
1734
// mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress().
1735
mz_ulong mz_compressBound(mz_ulong source_len);
1736
1737
// Initializes a decompressor.
1738
int mz_inflateInit(mz_streamp pStream);
1739
1740
// mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer:
1741
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate).
1742
int mz_inflateInit2(mz_streamp pStream, int window_bits);
1743
1744
// Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible.
1745
// Parameters:
1746
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
1747
// flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH.
1748
// On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster).
1749
// MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data.
1750
// Return values:
1751
// MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full.
1752
// MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified.
1753
// MZ_STREAM_ERROR if the stream is bogus.
1754
// MZ_DATA_ERROR if the deflate stream is invalid.
1755
// MZ_PARAM_ERROR if one of the parameters is invalid.
1756
// MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again
1757
// with more input data, or with more room in the output buffer (except when using single call decompression, described above).
1758
int mz_inflate(mz_streamp pStream, int flush);
1759
1760
// Deinitializes a decompressor.
1761
int mz_inflateEnd(mz_streamp pStream);
1762
1763
// Single-call decompression.
1764
// Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure.
// Retrieves the filename of an archive file entry.
1967
// Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename.
// Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive.
2014
// For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called.
2015
// For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it).
2016
// Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL.
2017
// Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before
2018
// the archive is finalized the file's central directory will be hosed.
// Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive.
2022
// To add a directory entry, call this method with an archive name ending in a forwardslash with empty buffer.
2023
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive.
2029
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used.
2044
// Note for the archive to be valid, it must have been finalized before ending.
2045
mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
2046
2047
// Misc. high-level helper functions:
2048
2049
// mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive.
2050
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// ------------------- Low-level Decompression API Definitions
2062
2063
// Decompression flags used by tinfl_decompress().
2064
// TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream.
2065
// TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input.
2066
// TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB).
2067
// TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes.
2068
enum
2069
{
2070
TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
2071
TINFL_FLAG_HAS_MORE_INPUT = 2,
2072
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
2073
TINFL_FLAG_COMPUTE_ADLER32 = 8
2074
};
2075
2076
// High level decompression functions:
2077
// tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc().
2078
// On entry:
2079
// pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress.
2080
// On return:
2081
// Function returns a pointer to the decompressed data, or NULL on failure.
2082
// *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data.
2083
// The caller must call mz_free() on the returned block when it's no longer needed.
2084
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
2085
2086
// tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory.
2087
// Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success.
// tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer.
2092
// Returns 1 on success or 0 on failure.
2093
typedef int (*tinfl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
2094
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);
// Initializes the decompressor to its initial state.
2113
#define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END
2114
#define tinfl_get_adler32(r) (r)->m_check_adler32
2115
2116
// Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability.
2117
// This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output.
// TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data.
2167
// TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers).
2168
// TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing.
2169
// TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory).
2170
// TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1)
2171
// TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled.
2172
// TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables.
2173
// TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks.
2174
// The low 12 bits are reserved to control the max # of hash probes per dictionary lookup (see TDEFL_MAX_PROBES_MASK).
2175
enum
2176
{
2177
TDEFL_WRITE_ZLIB_HEADER = 0x01000,
2178
TDEFL_COMPUTE_ADLER32 = 0x02000,
2179
TDEFL_GREEDY_PARSING_FLAG = 0x04000,
2180
TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
2181
TDEFL_RLE_MATCHES = 0x10000,
2182
TDEFL_FILTER_MATCHES = 0x20000,
2183
TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000,
2184
TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000
2185
};
2186
2187
// High level compression functions:
2188
// tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc().
2189
// On entry:
2190
// pSrc_buf, src_buf_len: Pointer and size of source block to compress.
2191
// flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression.
2192
// On return:
2193
// Function returns a pointer to the compressed data, or NULL on failure.
2194
// *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data.
2195
// The caller must free() the returned block when it's no longer needed.
2196
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
2197
2198
// tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory.
// The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions.
2231
typedef enum
2232
{
2233
TDEFL_STATUS_BAD_PARAM = -2,
2234
TDEFL_STATUS_PUT_BUF_FAILED = -1,
2235
TDEFL_STATUS_OKAY = 0,
2236
TDEFL_STATUS_DONE = 1,
2237
} tdefl_status;
2238
2239
// Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums
// There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory.
2278
// pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression.
2279
// If pBut_buf_func is NULL the user should always call the tdefl_compress() API.
2280
// flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.)
2281
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
2282
2283
// Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible.
// Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are reasonably fast (and don't involve compiler generated calls to helper functions).
2368
#define MINIZ_HAS_64BIT_REGISTERS 1
2369
#endif
2370
2371
#ifdef __cplusplus
2372
extern "C" {
2373
#endif
2374
2375
// ------------------- zlib-style API Definitions.
2376
2377
// For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits!
2378
typedef unsigned long mz_ulong;
2379
2380
// mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap.
2381
void mz_free(void *p);
2382
2383
#define MZ_ADLER32_INIT (1)
2384
// mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL.
// Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL.
const unsigned char *next_in; // pointer to next byte to read
2430
unsigned int avail_in; // number of bytes available at next_in
2431
mz_ulong total_in; // total number of bytes consumed so far
2432
2433
unsigned char *next_out; // pointer to next byte to write
2434
unsigned int avail_out; // number of bytes that can be written to next_out
2435
mz_ulong total_out; // total number of bytes produced so far
2436
2437
char *msg; // error msg (unused)
2438
struct mz_internal_state *state; // internal state, allocated by zalloc/zfree
2439
2440
mz_alloc_func zalloc; // optional heap allocation function (defaults to malloc)
2441
mz_free_func zfree; // optional heap free function (defaults to free)
2442
void *opaque; // heap alloc function user pointer
2443
2444
int data_type; // data_type (unused)
2445
mz_ulong adler; // adler32 of the source or uncompressed data
2446
mz_ulong reserved; // not used
2447
} mz_stream;
2448
2449
typedef mz_stream *mz_streamp;
2450
2451
// Returns the version string of miniz.c.
2452
const char *mz_version(void);
2453
2454
// mz_deflateInit() initializes a compressor with default options:
2455
// Parameters:
2456
// pStream must point to an initialized mz_stream struct.
2457
// level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION].
2458
// level 1 enables a specially optimized compression function that's been optimized purely for performance, not ratio.
2459
// (This special func. is currently only enabled when MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.)
2460
// Return values:
2461
// MZ_OK on success.
2462
// MZ_STREAM_ERROR if the stream is bogus.
2463
// MZ_PARAM_ERROR if the input parameters are bogus.
2464
// MZ_MEM_ERROR on out of memory.
2465
int mz_deflateInit(mz_streamp pStream, int level);
2466
2467
// mz_deflateInit2() is like mz_deflate(), except with more control:
2468
// Additional parameters:
2469
// method must be MZ_DEFLATED
2470
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer)
2471
// mem_level must be between [1, 9] (it's checked but ignored by miniz.c)
2472
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
2473
2474
// Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2().
2475
int mz_deflateReset(mz_streamp pStream);
2476
2477
// mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible.
2478
// Parameters:
2479
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
2480
// flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or MZ_FINISH.
2481
// Return values:
2482
// MZ_OK on success (when flushing, or if more input is needed but not available, and/or there's more output to be written but the output buffer is full).
2483
// MZ_STREAM_END if all input has been consumed and all output bytes have been written. Don't call mz_deflate() on the stream anymore.
2484
// MZ_STREAM_ERROR if the stream is bogus.
2485
// MZ_PARAM_ERROR if one of the parameters is invalid.
2486
// MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.)
2487
int mz_deflate(mz_streamp pStream, int flush);
2488
2489
// mz_deflateEnd() deinitializes a compressor:
2490
// Return values:
2491
// MZ_OK on success.
2492
// MZ_STREAM_ERROR if the stream is bogus.
2493
int mz_deflateEnd(mz_streamp pStream);
2494
2495
// mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH.
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);
2502
2503
// mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress().
2504
mz_ulong mz_compressBound(mz_ulong source_len);
2505
2506
// Initializes a decompressor.
2507
int mz_inflateInit(mz_streamp pStream);
2508
2509
// mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer:
2510
// window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate).
2511
int mz_inflateInit2(mz_streamp pStream, int window_bits);
2512
2513
// Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible.
2514
// Parameters:
2515
// pStream is the stream to read from and write to. You must initialize/update the next_in, avail_in, next_out, and avail_out members.
2516
// flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH.
2517
// On the first call, if flush is MZ_FINISH it's assumed the input and output buffers are both sized large enough to decompress the entire stream in a single call (this is slightly faster).
2518
// MZ_FINISH implies that there are no more source bytes available beside what's already in the input buffer, and that the output buffer is large enough to hold the rest of the decompressed data.
2519
// Return values:
2520
// MZ_OK on success. Either more input is needed but not available, and/or there's more output to be written but the output buffer is full.
2521
// MZ_STREAM_END if all needed input has been consumed and all output bytes have been written. For zlib streams, the adler-32 of the decompressed data has also been verified.
2522
// MZ_STREAM_ERROR if the stream is bogus.
2523
// MZ_DATA_ERROR if the deflate stream is invalid.
2524
// MZ_PARAM_ERROR if one of the parameters is invalid.
2525
// MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again
2526
// with more input data, or with more room in the output buffer (except when using single call decompression, described above).
2527
int mz_inflate(mz_streamp pStream, int flush);
2528
2529
// Deinitializes a decompressor.
2530
int mz_inflateEnd(mz_streamp pStream);
2531
2532
// Single-call decompression.
2533
// Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure.
// Retrieves the filename of an archive file entry.
2736
// Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename.
// Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive.
2783
// For archives opened using mz_zip_reader_init_file, pFilename must be the archive's filename so it can be reopened for writing. If the file can't be reopened, mz_zip_reader_end() will be called.
2784
// For archives opened using mz_zip_reader_init_mem, the memory block must be growable using the realloc callback (which defaults to realloc unless you've overridden it).
2785
// Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL.
2786
// Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before
2787
// the archive is finalized the file's central directory will be hosed.
// Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive.
2791
// To add a directory entry, call this method with an archive name ending in a forwardslash with empty buffer.
2792
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive.
2798
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used.
2813
// Note for the archive to be valid, it must have been finalized before ending.
2814
mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
2815
2816
// Misc. high-level helper functions:
2817
2818
// mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) appends a memory blob to a ZIP archive.
2819
// level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION.
// ------------------- Low-level Decompression API Definitions
2831
2832
// Decompression flags used by tinfl_decompress().
2833
// TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the input is a raw deflate stream.
2834
// TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available beyond the end of the supplied input buffer. If clear, the input buffer contains all remaining input.
2835
// TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large enough to hold the entire decompressed stream. If clear, the output buffer is at least the size of the dictionary (typically 32KB).
2836
// TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the decompressed bytes.
2837
enum
2838
{
2839
TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
2840
TINFL_FLAG_HAS_MORE_INPUT = 2,
2841
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
2842
TINFL_FLAG_COMPUTE_ADLER32 = 8
2843
};
2844
2845
// High level decompression functions:
2846
// tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc().
2847
// On entry:
2848
// pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress.
2849
// On return:
2850
// Function returns a pointer to the decompressed data, or NULL on failure.
2851
// *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data.
2852
// The caller must call mz_free() on the returned block when it's no longer needed.
2853
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
2854
2855
// tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory.
2856
// Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success.
// tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer.
2861
// Returns 1 on success or 0 on failure.
2862
typedef int (*tinfl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
2863
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);
// Initializes the decompressor to its initial state.
2882
#define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END
2883
#define tinfl_get_adler32(r) (r)->m_check_adler32
2884
2885
// Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability.
2886
// This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output.
// TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before the deflate data, and the Adler-32 of the source data at the end. Otherwise, you'll get raw deflate data.
2936
// TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even when not writing zlib headers).
2937
// TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more efficient lazy parsing.
2938
// TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's initialization time to the minimum, but the output may vary from run to run given the same input (depending on the contents of memory).
2939
// TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1)
2940
// TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled.
2941
// TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables.
2942
// TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks.
2943
// The low 12 bits are reserved to control the max # of hash probes per dictionary lookup (see TDEFL_MAX_PROBES_MASK).
2944
enum
2945
{
2946
TDEFL_WRITE_ZLIB_HEADER = 0x01000,
2947
TDEFL_COMPUTE_ADLER32 = 0x02000,
2948
TDEFL_GREEDY_PARSING_FLAG = 0x04000,
2949
TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000,
2950
TDEFL_RLE_MATCHES = 0x10000,
2951
TDEFL_FILTER_MATCHES = 0x20000,
2952
TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000,
2953
TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000
2954
};
2955
2956
// High level compression functions:
2957
// tdefl_compress_mem_to_heap() compresses a block in memory to a heap block allocated via malloc().
2958
// On entry:
2959
// pSrc_buf, src_buf_len: Pointer and size of source block to compress.
2960
// flags: The max match finder probes (default is 128) logically OR'd against the above flags. Higher probes are slower but improve compression.
2961
// On return:
2962
// Function returns a pointer to the compressed data, or NULL on failure.
2963
// *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data.
2964
// The caller must free() the returned block when it's no longer needed.
2965
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
2966
2967
// tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory.
// The low-level tdefl functions below may be used directly if the above helper functions aren't flexible enough. The low-level functions don't make any heap allocations, unlike the above helper functions.
3000
typedef enum
3001
{
3002
TDEFL_STATUS_BAD_PARAM = -2,
3003
TDEFL_STATUS_PUT_BUF_FAILED = -1,
3004
TDEFL_STATUS_OKAY = 0,
3005
TDEFL_STATUS_DONE = 1,
3006
} tdefl_status;
3007
3008
// Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums
// There is no corresponding deinit() function because the tdefl API's do not dynamically allocate memory.
3047
// pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression.
3048
// If pBut_buf_func is NULL the user should always call the tdefl_compress() API.
3049
// flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.)
3050
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
3051
3052
// Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible.