miniz.c File Reference

#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <sys/stat.h>
#include <utime.h>

Go to the source code of this file.

Classes
struct	mz_stream_s
struct	mz_zip_archive_file_stat
struct	mz_zip_archive
struct	tinfl_huff_table
struct	tinfl_decompressor_tag
struct	tdefl_compressor
struct	inflate_state
struct	tdefl_sym_freq
struct	tdefl_output_buffer
struct	mz_zip_array
struct	mz_zip_internal_state_tag
struct	mz_zip_writer_add_state

Macros
#define	MINIZ_HEADER_INCLUDED
#define	MINIZ_LITTLE_ENDIAN   1
#define	MZ_ADLER32_INIT   (1)
#define	MZ_CRC32_INIT   (0)
#define	MZ_DEFLATED   8
#define	MZ_VERSION   "9.1.14"
#define	MZ_VERNUM   0x91E0
#define	MZ_VER_MAJOR   9
#define	MZ_VER_MINOR   1
#define	MZ_VER_REVISION   14
#define	MZ_VER_SUBREVISION   0
#define	MZ_DEFAULT_WINDOW_BITS   15
#define	Z_NULL   0
#define	Z_NO_FLUSH   MZ_NO_FLUSH
#define	Z_PARTIAL_FLUSH   MZ_PARTIAL_FLUSH
#define	Z_SYNC_FLUSH   MZ_SYNC_FLUSH
#define	Z_FULL_FLUSH   MZ_FULL_FLUSH
#define	Z_FINISH   MZ_FINISH
#define	Z_BLOCK   MZ_BLOCK
#define	Z_OK   MZ_OK
#define	Z_STREAM_END   MZ_STREAM_END
#define	Z_NEED_DICT   MZ_NEED_DICT
#define	Z_ERRNO   MZ_ERRNO
#define	Z_STREAM_ERROR   MZ_STREAM_ERROR
#define	Z_DATA_ERROR   MZ_DATA_ERROR
#define	Z_MEM_ERROR   MZ_MEM_ERROR
#define	Z_BUF_ERROR   MZ_BUF_ERROR
#define	Z_VERSION_ERROR   MZ_VERSION_ERROR
#define	Z_PARAM_ERROR   MZ_PARAM_ERROR
#define	Z_NO_COMPRESSION   MZ_NO_COMPRESSION
#define	Z_BEST_SPEED   MZ_BEST_SPEED
#define	Z_BEST_COMPRESSION   MZ_BEST_COMPRESSION
#define	Z_DEFAULT_COMPRESSION   MZ_DEFAULT_COMPRESSION
#define	Z_DEFAULT_STRATEGY   MZ_DEFAULT_STRATEGY
#define	Z_FILTERED   MZ_FILTERED
#define	Z_HUFFMAN_ONLY   MZ_HUFFMAN_ONLY
#define	Z_RLE   MZ_RLE
#define	Z_FIXED   MZ_FIXED
#define	Z_DEFLATED   MZ_DEFLATED
#define	Z_DEFAULT_WINDOW_BITS   MZ_DEFAULT_WINDOW_BITS
#define	alloc_func   mz_alloc_func
#define	free_func   mz_free_func
#define	internal_state   mz_internal_state
#define	z_stream   mz_stream
#define	deflateInit   mz_deflateInit
#define	deflateInit2   mz_deflateInit2
#define	deflateReset   mz_deflateReset
#define	deflate   mz_deflate
#define	deflateEnd   mz_deflateEnd
#define	deflateBound   mz_deflateBound
#define	compress   mz_compress
#define	compress2   mz_compress2
#define	compressBound   mz_compressBound
#define	inflateInit   mz_inflateInit
#define	inflateInit2   mz_inflateInit2
#define	inflate   mz_inflate
#define	inflateEnd   mz_inflateEnd
#define	uncompress   mz_uncompress
#define	crc32   mz_crc32
#define	adler32   mz_adler32
#define	MAX_WBITS   15
#define	MAX_MEM_LEVEL   9
#define	zError   mz_error
#define	ZLIB_VERSION   MZ_VERSION
#define	ZLIB_VERNUM   MZ_VERNUM
#define	ZLIB_VER_MAJOR   MZ_VER_MAJOR
#define	ZLIB_VER_MINOR   MZ_VER_MINOR
#define	ZLIB_VER_REVISION   MZ_VER_REVISION
#define	ZLIB_VER_SUBREVISION   MZ_VER_SUBREVISION
#define	zlibVersion   mz_version
#define	zlib_version   mz_version()
#define	MZ_FALSE   (0)
#define	MZ_TRUE   (1)
#define	MZ_MACRO_END   while (0)
#define	TINFL_DECOMPRESS_MEM_TO_MEM_FAILED   ((size_t)(-1))
#define	TINFL_LZ_DICT_SIZE   32768
#define	tinfl_init(r)   do { (r)->m_state = 0; } MZ_MACRO_END
#define	tinfl_get_adler32(r)   (r)->m_check_adler32
#define	TINFL_BITBUF_SIZE   (32)
#define	TDEFL_LESS_MEMORY   0
#define	MZ_ASSERT(x)   assert(x)
#define	MZ_MALLOC(x)   malloc(x)
#define	MZ_FREE(x)   free(x)
#define	MZ_REALLOC(p, x)   realloc(p, x)
#define	MZ_MAX(a, b)   (((a)>(b))?(a):(b))
#define	MZ_MIN(a, b)   (((a)<(b))?(a):(b))
#define	MZ_CLEAR_OBJ(obj)   memset(&(obj), 0, sizeof(obj))
#define	MZ_READ_LE16(p)   ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
#define	MZ_READ_LE32(p)   ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
#define	MZ_FORCEINLINE   inline
#define	TINFL_MEMCPY(d, s, l)   memcpy(d, s, l)
#define	TINFL_MEMSET(p, c, l)   memset(p, c, l)
#define	TINFL_CR_BEGIN   switch(r->m_state) { case 0:
#define	TINFL_CR_RETURN(state_index, result)   do { status = result; r->m_state = state_index; goto common_exit; case state_index:; } MZ_MACRO_END
#define	TINFL_CR_RETURN_FOREVER(state_index, result)   do { for ( ; ; ) { TINFL_CR_RETURN(state_index, result); } } MZ_MACRO_END
#define	TINFL_CR_FINISH   }
#define	TINFL_GET_BYTE(state_index, c)
#define	TINFL_NEED_BITS(state_index, n)   do { mz_uint c; TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; } while (num_bits < (mz_uint)(n))
#define	TINFL_SKIP_BITS(state_index, n)   do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
#define	TINFL_GET_BITS(state_index, b, n)   do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } b = bit_buf & ((1 << (n)) - 1); bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
#define	TINFL_HUFF_BITBUF_FILL(state_index, pHuff)
#define	TINFL_HUFF_DECODE(state_index, sym, pHuff)
#define	TDEFL_PUT_BITS(b, l)
#define	TDEFL_RLE_PREV_CODE_SIZE()
#define	TDEFL_RLE_ZERO_CODE_SIZE()
#define	TDEFL_PROBE
#define	MZ_FILE   FILE
#define	MZ_FOPEN   fopen
#define	MZ_FCLOSE   fclose
#define	MZ_FREAD   fread
#define	MZ_FWRITE   fwrite
#define	MZ_FTELL64   ftello
#define	MZ_FSEEK64   fseeko
#define	MZ_FILE_STAT_STRUCT   stat
#define	MZ_FILE_STAT   stat
#define	MZ_FFLUSH   fflush
#define	MZ_FREOPEN   freopen
#define	MZ_DELETE_FILE   remove
#define	MZ_TOLOWER(c)   ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
#define	MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size)   (array_ptr)->m_element_size = element_size
#define	MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index)   ((element_type *)((array_ptr)->m_p))[index]
#define	MZ_SWAP_UINT32(a, b)   do { mz_uint32 t = a; a = b; b = t; } MZ_MACRO_END
#define	MZ_WRITE_LE16(p, v)   mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v))
#define	MZ_WRITE_LE32(p, v)   mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))

Typedefs
typedef unsigned long	mz_ulong
typedef void *(*	mz_alloc_func) (void *opaque, size_t items, size_t size)
typedef void(*	mz_free_func) (void *opaque, void *address)
typedef void *(*	mz_realloc_func) (void *opaque, void *address, size_t items, size_t size)
typedef struct mz_stream_s	mz_stream
typedef mz_stream *	mz_streamp
typedef unsigned char	Byte
typedef unsigned int	uInt
typedef mz_ulong	uLong
typedef Byte	Bytef
typedef uInt	uIntf
typedef char	charf
typedef int	intf
typedef void *	voidpf
typedef uLong	uLongf
typedef void *	voidp
typedef void *const	voidpc
typedef unsigned char	mz_uint8
typedef signed short	mz_int16
typedef unsigned short	mz_uint16
typedef unsigned int	mz_uint32
typedef unsigned int	mz_uint
typedef long long	mz_int64
typedef unsigned long long	mz_uint64
typedef int	mz_bool
typedef size_t(*	mz_file_read_func) (void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
typedef size_t(*	mz_file_write_func) (void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
typedef struct mz_zip_internal_state_tag	mz_zip_internal_state
typedef int(*	tinfl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)
typedef struct tinfl_decompressor_tag	tinfl_decompressor
typedef mz_uint32	tinfl_bit_buf_t
typedef mz_bool(*	tdefl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)
typedef unsigned char	mz_validate_uint16[sizeof(mz_uint16)==2 ? 1 :-1]
typedef unsigned char	mz_validate_uint32[sizeof(mz_uint32)==4 ? 1 :-1]
typedef unsigned char	mz_validate_uint64[sizeof(mz_uint64)==8 ? 1 :-1]

Enumerations
enum	{   MZ_DEFAULT_STRATEGY = 0 , MZ_FILTERED = 1 , MZ_HUFFMAN_ONLY = 2 , MZ_RLE = 3 ,   MZ_FIXED = 4 }
enum	{   MZ_NO_FLUSH = 0 , MZ_PARTIAL_FLUSH = 1 , MZ_SYNC_FLUSH = 2 , MZ_FULL_FLUSH = 3 ,   MZ_FINISH = 4 , MZ_BLOCK = 5 }
enum	{   MZ_OK = 0 , MZ_STREAM_END = 1 , MZ_NEED_DICT = 2 , MZ_ERRNO = -1 ,   MZ_STREAM_ERROR = -2 , MZ_DATA_ERROR = -3 , MZ_MEM_ERROR = -4 , MZ_BUF_ERROR = -5 ,   MZ_VERSION_ERROR = -6 , MZ_PARAM_ERROR = -10000 }
enum	{   MZ_NO_COMPRESSION = 0 , MZ_BEST_SPEED = 1 , MZ_BEST_COMPRESSION = 9 , MZ_UBER_COMPRESSION = 10 ,   MZ_DEFAULT_LEVEL = 6 , MZ_DEFAULT_COMPRESSION = -1 }
enum	{ MZ_ZIP_MAX_IO_BUF_SIZE = 64*1024 , MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 260 , MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 256 }
enum	mz_zip_mode { MZ_ZIP_MODE_INVALID = 0 , MZ_ZIP_MODE_READING = 1 , MZ_ZIP_MODE_WRITING = 2 , MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3 }
enum	mz_zip_flags { MZ_ZIP_FLAG_CASE_SENSITIVE = 0x0100 , MZ_ZIP_FLAG_IGNORE_PATH = 0x0200 , MZ_ZIP_FLAG_COMPRESSED_DATA = 0x0400 , MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY = 0x0800 }
enum	{ TINFL_FLAG_PARSE_ZLIB_HEADER = 1 , TINFL_FLAG_HAS_MORE_INPUT = 2 , TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4 , TINFL_FLAG_COMPUTE_ADLER32 = 8 }
enum	tinfl_status {   TINFL_STATUS_BAD_PARAM = -3 , TINFL_STATUS_ADLER32_MISMATCH = -2 , TINFL_STATUS_FAILED = -1 , TINFL_STATUS_DONE = 0 ,   TINFL_STATUS_NEEDS_MORE_INPUT = 1 , TINFL_STATUS_HAS_MORE_OUTPUT = 2 }
enum	{   TINFL_MAX_HUFF_TABLES = 3 , TINFL_MAX_HUFF_SYMBOLS_0 = 288 , TINFL_MAX_HUFF_SYMBOLS_1 = 32 , TINFL_MAX_HUFF_SYMBOLS_2 = 19 ,   TINFL_FAST_LOOKUP_BITS = 10 , TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS }
enum	{ TDEFL_HUFFMAN_ONLY = 0 , TDEFL_DEFAULT_MAX_PROBES = 128 , TDEFL_MAX_PROBES_MASK = 0xFFF }
enum	{   TDEFL_WRITE_ZLIB_HEADER = 0x01000 , TDEFL_COMPUTE_ADLER32 = 0x02000 , TDEFL_GREEDY_PARSING_FLAG = 0x04000 , TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000 ,   TDEFL_RLE_MATCHES = 0x10000 , TDEFL_FILTER_MATCHES = 0x20000 , TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000 , TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000 }
enum	{   TDEFL_MAX_HUFF_TABLES = 3 , TDEFL_MAX_HUFF_SYMBOLS_0 = 288 , TDEFL_MAX_HUFF_SYMBOLS_1 = 32 , TDEFL_MAX_HUFF_SYMBOLS_2 = 19 ,   TDEFL_LZ_DICT_SIZE = 32768 , TDEFL_LZ_DICT_SIZE_MASK = TDEFL_LZ_DICT_SIZE - 1 , TDEFL_MIN_MATCH_LEN = 3 , TDEFL_MAX_MATCH_LEN = 258 }
enum	{   TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024 , TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13 ) / 10 , TDEFL_MAX_HUFF_SYMBOLS = 288 , TDEFL_LZ_HASH_BITS = 15 ,   TDEFL_LEVEL1_HASH_SIZE_MASK = 4095 , TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3 , TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS }
enum	tdefl_status { TDEFL_STATUS_BAD_PARAM = -2 , TDEFL_STATUS_PUT_BUF_FAILED = -1 , TDEFL_STATUS_OKAY = 0 , TDEFL_STATUS_DONE = 1 }
enum	tdefl_flush { TDEFL_NO_FLUSH = 0 , TDEFL_SYNC_FLUSH = 2 , TDEFL_FULL_FLUSH = 3 , TDEFL_FINISH = 4 }
enum	{ TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32 }
enum	{   MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50 , MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50 , MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50 , MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30 ,   MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46 , MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22 , MZ_ZIP_CDH_SIG_OFS = 0 , MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4 ,   MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6 , MZ_ZIP_CDH_BIT_FLAG_OFS = 8 , MZ_ZIP_CDH_METHOD_OFS = 10 , MZ_ZIP_CDH_FILE_TIME_OFS = 12 ,   MZ_ZIP_CDH_FILE_DATE_OFS = 14 , MZ_ZIP_CDH_CRC32_OFS = 16 , MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20 , MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24 ,   MZ_ZIP_CDH_FILENAME_LEN_OFS = 28 , MZ_ZIP_CDH_EXTRA_LEN_OFS = 30 , MZ_ZIP_CDH_COMMENT_LEN_OFS = 32 , MZ_ZIP_CDH_DISK_START_OFS = 34 ,   MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36 , MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38 , MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42 , MZ_ZIP_LDH_SIG_OFS = 0 ,   MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4 , MZ_ZIP_LDH_BIT_FLAG_OFS = 6 , MZ_ZIP_LDH_METHOD_OFS = 8 , MZ_ZIP_LDH_FILE_TIME_OFS = 10 ,   MZ_ZIP_LDH_FILE_DATE_OFS = 12 , MZ_ZIP_LDH_CRC32_OFS = 14 , MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18 , MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22 ,   MZ_ZIP_LDH_FILENAME_LEN_OFS = 26 , MZ_ZIP_LDH_EXTRA_LEN_OFS = 28 , MZ_ZIP_ECDH_SIG_OFS = 0 , MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4 ,   MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6 , MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8 , MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10 , MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12 ,   MZ_ZIP_ECDH_CDIR_OFS_OFS = 16 , MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20 }

Functions
mz_ulong	mz_adler32 (mz_ulong adler, const unsigned char *ptr, size_t buf_len)
mz_ulong	mz_crc32 (mz_ulong crc, const unsigned char *ptr, size_t buf_len)
const char *	mz_version (void)
int	mz_deflateInit (mz_streamp pStream, int level)
int	mz_deflateInit2 (mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
int	mz_deflateReset (mz_streamp pStream)
int	mz_deflate (mz_streamp pStream, int flush)
int	mz_deflateEnd (mz_streamp pStream)
mz_ulong	mz_deflateBound (mz_streamp pStream, mz_ulong source_len)
int	mz_compress (unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
int	mz_compress2 (unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
mz_ulong	mz_compressBound (mz_ulong source_len)
int	mz_inflateInit (mz_streamp pStream)
int	mz_inflateInit2 (mz_streamp pStream, int window_bits)
int	mz_inflate (mz_streamp pStream, int flush)
int	mz_inflateEnd (mz_streamp pStream)
int	mz_uncompress (unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
const char *	mz_error (int err)
mz_bool	mz_zip_reader_init (mz_zip_archive *pZip, mz_uint64 size, mz_uint32 flags)
mz_bool	mz_zip_reader_init_mem (mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint32 flags)
mz_bool	mz_zip_reader_init_file (mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)
mz_uint	mz_zip_reader_get_num_files (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_bool	mz_zip_reader_is_file_a_directory (mz_zip_archive *pZip, mz_uint file_index)
mz_bool	mz_zip_reader_is_file_encrypted (mz_zip_archive *pZip, mz_uint file_index)
mz_uint	mz_zip_reader_get_filename (mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
int	mz_zip_reader_locate_file (mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)
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)
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)
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)
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)
void *	mz_zip_reader_extract_to_heap (mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
void *	mz_zip_reader_extract_file_to_heap (mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)
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)
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)
mz_bool	mz_zip_reader_extract_to_file (mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
mz_bool	mz_zip_reader_extract_file_to_file (mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags)
mz_bool	mz_zip_reader_end (mz_zip_archive *pZip)
mz_bool	mz_zip_writer_init (mz_zip_archive *pZip, mz_uint64 existing_size)
mz_bool	mz_zip_writer_init_heap (mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)
mz_bool	mz_zip_writer_init_file (mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning)
mz_bool	mz_zip_writer_init_from_reader (mz_zip_archive *pZip, const char *pFilename)
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_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_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)
mz_bool	mz_zip_writer_add_from_zip_reader (mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint file_index)
mz_bool	mz_zip_writer_finalize_archive (mz_zip_archive *pZip)
mz_bool	mz_zip_writer_finalize_heap_archive (mz_zip_archive *pZip, void **pBuf, size_t *pSize)
mz_bool	mz_zip_writer_end (mz_zip_archive *pZip)
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)
void *	mz_zip_extract_archive_file_to_heap (const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint zip_flags)
void *	tinfl_decompress_mem_to_heap (const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
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)
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)
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)
void *	tdefl_compress_mem_to_heap (const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
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)
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)
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)
tdefl_status	tdefl_compress_buffer (tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
tdefl_status	tdefl_get_prev_return_status (tdefl_compressor *d)
mz_uint32	tdefl_get_adler32 (tdefl_compressor *d)
mz_uint	tdefl_create_comp_flags_from_zip_params (int level, int window_bits, int strategy)

Macro Definition Documentation

adler32

#define adler32   mz_adler32

alloc_func

#define alloc_func   mz_alloc_func

compress

#define compress   mz_compress

compress2

#define compress2   mz_compress2

compressBound

#define compressBound   mz_compressBound

crc32

#define crc32   mz_crc32

deflate

#define deflate   mz_deflate

deflateBound

#define deflateBound   mz_deflateBound

deflateEnd

#define deflateEnd   mz_deflateEnd

deflateInit

#define deflateInit   mz_deflateInit

deflateInit2

#define deflateInit2   mz_deflateInit2

deflateReset

#define deflateReset   mz_deflateReset

free_func

#define free_func   mz_free_func

inflate

#define inflate   mz_inflate

inflateEnd

#define inflateEnd   mz_inflateEnd

inflateInit

#define inflateInit   mz_inflateInit

inflateInit2

#define inflateInit2   mz_inflateInit2

internal_state

#define internal_state   mz_internal_state

MAX_MEM_LEVEL

#define MAX_MEM_LEVEL   9

MAX_WBITS

#define MAX_WBITS   15

MINIZ_HEADER_INCLUDED

#define MINIZ_HEADER_INCLUDED

MINIZ_LITTLE_ENDIAN

#define MINIZ_LITTLE_ENDIAN   1

MZ_ADLER32_INIT

#define MZ_ADLER32_INIT   (1)

MZ_ASSERT

#define MZ_ASSERT

(

x

)

assert(x)

MZ_CLEAR_OBJ

#define MZ_CLEAR_OBJ

(

obj

)

memset(&(obj), 0, sizeof(obj))

MZ_CRC32_INIT

#define MZ_CRC32_INIT   (0)

MZ_DEFAULT_WINDOW_BITS

#define MZ_DEFAULT_WINDOW_BITS   15

MZ_DEFLATED

#define MZ_DEFLATED   8

MZ_DELETE_FILE

#define MZ_DELETE_FILE   remove

MZ_FALSE

#define MZ_FALSE   (0)

MZ_FCLOSE

#define MZ_FCLOSE   fclose

MZ_FFLUSH

#define MZ_FFLUSH   fflush

MZ_FILE

#define MZ_FILE   FILE

MZ_FILE_STAT

#define MZ_FILE_STAT   stat

MZ_FILE_STAT_STRUCT

#define MZ_FILE_STAT_STRUCT   stat

MZ_FOPEN

#define MZ_FOPEN   fopen

MZ_FORCEINLINE

#define MZ_FORCEINLINE   inline

MZ_FREAD

#define MZ_FREAD   fread

MZ_FREE

#define MZ_FREE

(

x

)

free(x)

MZ_FREOPEN

#define MZ_FREOPEN   freopen

MZ_FSEEK64

#define MZ_FSEEK64   fseeko

MZ_FTELL64

#define MZ_FTELL64   ftello

MZ_FWRITE

#define MZ_FWRITE   fwrite

MZ_MACRO_END

#define MZ_MACRO_END   while (0)

MZ_MALLOC

#define MZ_MALLOC

(

x

)

malloc(x)

MZ_MAX

#define MZ_MAX	(		a,
			b
	)		(((a)>(b))?(a):(b))

MZ_MIN

#define MZ_MIN	(		a,
			b
	)		(((a)<(b))?(a):(b))

MZ_READ_LE16

#define MZ_READ_LE16

(

p

)

((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))

MZ_READ_LE32

#define MZ_READ_LE32

(

p

)

((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))

MZ_REALLOC

#define MZ_REALLOC	(		p,
			x
	)		realloc(p, x)

MZ_SWAP_UINT32

#define MZ_SWAP_UINT32	(		a,
			b
	)		do { mz_uint32 t = a; a = b; b = t; } MZ_MACRO_END

MZ_TOLOWER

#define MZ_TOLOWER

(

c

)

((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))

MZ_TRUE

#define MZ_TRUE   (1)

MZ_VER_MAJOR

#define MZ_VER_MAJOR   9

MZ_VER_MINOR

#define MZ_VER_MINOR   1

MZ_VER_REVISION

#define MZ_VER_REVISION   14

MZ_VER_SUBREVISION

#define MZ_VER_SUBREVISION   0

MZ_VERNUM

#define MZ_VERNUM   0x91E0

MZ_VERSION

#define MZ_VERSION   "9.1.14"

MZ_WRITE_LE16

#define MZ_WRITE_LE16	(		p,
			v
	)		mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v))

MZ_WRITE_LE32

#define MZ_WRITE_LE32	(		p,
			v
	)		mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))

MZ_ZIP_ARRAY_ELEMENT

#define MZ_ZIP_ARRAY_ELEMENT	(		array_ptr,
			element_type,
			index
	)		((element_type *)((array_ptr)->m_p))[index]

MZ_ZIP_ARRAY_SET_ELEMENT_SIZE

#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE	(		array_ptr,
			element_size
	)		(array_ptr)->m_element_size = element_size

TDEFL_LESS_MEMORY

#define TDEFL_LESS_MEMORY   0

TDEFL_PROBE

#define TDEFL_PROBE

Value:

        next_probe_pos = d->m_next[probe_pos]; \
        if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) return; \
        probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
        if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) break;

TDEFL_PUT_BITS

#define TDEFL_PUT_BITS	(		b,
			l
	)

Value:

  do { \
  mz_uint bits = b; mz_uint len = l; MZ_ASSERT(bits <= ((1U << len) - 1U)); \
  d->m_bit_buffer |= (bits << d->m_bits_in); d->m_bits_in += len; \
  while (d->m_bits_in >= 8) { \
    if (d->m_pOutput_buf < d->m_pOutput_buf_end) \
      *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer&0xFF); \
      d->m_bit_buffer >>= 8; \
      d->m_bits_in -= 8; \
  } \
} MZ_MACRO_END

TDEFL_RLE_PREV_CODE_SIZE

#define TDEFL_RLE_PREV_CODE_SIZE

(

)

Value:

  { if (rle_repeat_count) { \
  if (rle_repeat_count < 3) { \
    d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \
    while (rle_repeat_count--) packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \
  } else { \
    d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); packed_code_sizes[num_packed_code_sizes++] = 16; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \
} rle_repeat_count = 0; } }

TDEFL_RLE_ZERO_CODE_SIZE

#define TDEFL_RLE_ZERO_CODE_SIZE

(

)

Value:

  { if (rle_z_count) { \
  if (rle_z_count < 3) { \
    d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); while (rle_z_count--) packed_code_sizes[num_packed_code_sizes++] = 0; \
  } else if (rle_z_count <= 10) { \
    d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); packed_code_sizes[num_packed_code_sizes++] = 17; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \
  } else { \
    d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); packed_code_sizes[num_packed_code_sizes++] = 18; packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \
} rle_z_count = 0; } }

TINFL_BITBUF_SIZE

#define TINFL_BITBUF_SIZE   (32)

TINFL_CR_BEGIN

#define TINFL_CR_BEGIN   switch(r->m_state) { case 0:

TINFL_CR_FINISH

#define TINFL_CR_FINISH   }

TINFL_CR_RETURN

#define TINFL_CR_RETURN	(		state_index,
			result
	)		do { status = result; r->m_state = state_index; goto common_exit; case state_index:; } MZ_MACRO_END

TINFL_CR_RETURN_FOREVER

#define TINFL_CR_RETURN_FOREVER	(		state_index,
			result
	)		do { for ( ; ; ) { TINFL_CR_RETURN(state_index, result); } } MZ_MACRO_END

TINFL_DECOMPRESS_MEM_TO_MEM_FAILED

#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED   ((size_t)(-1))

tinfl_get_adler32

#define tinfl_get_adler32

(

r

)

(r)->m_check_adler32

TINFL_GET_BITS

#define TINFL_GET_BITS	(		state_index,
			b,
			n
	)		do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } b = bit_buf & ((1 << (n)) - 1); bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END

TINFL_GET_BYTE

#define TINFL_GET_BYTE	(		state_index,
			c
	)

Value:

  do { \
  if (pIn_buf_cur >= pIn_buf_end) { \
    for ( ; ; ) { \
      if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) { \
        TINFL_CR_RETURN(state_index, TINFL_STATUS_NEEDS_MORE_INPUT); \
        if (pIn_buf_cur < pIn_buf_end) { \
          c = *pIn_buf_cur++; \
          break; \
        } \
      } else { \
        c = 0; \
        break; \
      } \
    } \
  } else c = *pIn_buf_cur++; } MZ_MACRO_END

TINFL_HUFF_BITBUF_FILL

#define TINFL_HUFF_BITBUF_FILL	(		state_index,
			pHuff
	)

Value:

  do { \
    temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
    if (temp >= 0) { \
      code_len = temp >> 9; \
      if ((code_len) && (num_bits >= code_len)) \
      break; \
    } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \
       code_len = TINFL_FAST_LOOKUP_BITS; \
       do { \
          temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \
       } while ((temp < 0) && (num_bits >= (code_len + 1))); if (temp >= 0) break; \
    } TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; \
  } while (num_bits < 15);

TINFL_HUFF_DECODE

#define TINFL_HUFF_DECODE	(		state_index,
			sym,
			pHuff
	)

Value:

  do { \
  int temp; mz_uint code_len, c; \
  if (num_bits < 15) { \
    if ((pIn_buf_end - pIn_buf_cur) < 2) { \
       TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \
    } else { \
       bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); pIn_buf_cur += 2; num_bits += 16; \
    } \
  } \
  if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \
    code_len = temp >> 9, temp &= 511; \
  else { \
    code_len = TINFL_FAST_LOOKUP_BITS; do { temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; } while (temp < 0); \
  } sym = temp; bit_buf >>= code_len; num_bits -= code_len; } MZ_MACRO_END

tinfl_init

#define tinfl_init

(

r

)

do { (r)->m_state = 0; } MZ_MACRO_END

TINFL_LZ_DICT_SIZE

#define TINFL_LZ_DICT_SIZE   32768

TINFL_MEMCPY

#define TINFL_MEMCPY	(		d,
			s,
			l
	)		memcpy(d, s, l)

TINFL_MEMSET

#define TINFL_MEMSET	(		p,
			c,
			l
	)		memset(p, c, l)

TINFL_NEED_BITS

#define TINFL_NEED_BITS	(		state_index,
			n
	)		do { mz_uint c; TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; } while (num_bits < (mz_uint)(n))

TINFL_SKIP_BITS

#define TINFL_SKIP_BITS	(		state_index,
			n
	)		do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END

uncompress

#define uncompress   mz_uncompress

Z_BEST_COMPRESSION

#define Z_BEST_COMPRESSION   MZ_BEST_COMPRESSION

Z_BEST_SPEED

#define Z_BEST_SPEED   MZ_BEST_SPEED

Z_BLOCK

#define Z_BLOCK   MZ_BLOCK

Z_BUF_ERROR

#define Z_BUF_ERROR   MZ_BUF_ERROR

Z_DATA_ERROR

#define Z_DATA_ERROR   MZ_DATA_ERROR

Z_DEFAULT_COMPRESSION

#define Z_DEFAULT_COMPRESSION   MZ_DEFAULT_COMPRESSION

Z_DEFAULT_STRATEGY

#define Z_DEFAULT_STRATEGY   MZ_DEFAULT_STRATEGY

Z_DEFAULT_WINDOW_BITS

#define Z_DEFAULT_WINDOW_BITS   MZ_DEFAULT_WINDOW_BITS

Z_DEFLATED

#define Z_DEFLATED   MZ_DEFLATED

Z_ERRNO

#define Z_ERRNO   MZ_ERRNO

Z_FILTERED

#define Z_FILTERED   MZ_FILTERED

Z_FINISH

#define Z_FINISH   MZ_FINISH

Z_FIXED

#define Z_FIXED   MZ_FIXED

Z_FULL_FLUSH

#define Z_FULL_FLUSH   MZ_FULL_FLUSH

Z_HUFFMAN_ONLY

#define Z_HUFFMAN_ONLY   MZ_HUFFMAN_ONLY

Z_MEM_ERROR

#define Z_MEM_ERROR   MZ_MEM_ERROR

Z_NEED_DICT

#define Z_NEED_DICT   MZ_NEED_DICT

Z_NO_COMPRESSION

#define Z_NO_COMPRESSION   MZ_NO_COMPRESSION

Z_NO_FLUSH

#define Z_NO_FLUSH   MZ_NO_FLUSH

Z_NULL

#define Z_NULL   0

Z_OK

#define Z_OK   MZ_OK

Z_PARAM_ERROR

#define Z_PARAM_ERROR   MZ_PARAM_ERROR

Z_PARTIAL_FLUSH

#define Z_PARTIAL_FLUSH   MZ_PARTIAL_FLUSH

Z_RLE

#define Z_RLE   MZ_RLE

z_stream

#define z_stream   mz_stream

Z_STREAM_END

#define Z_STREAM_END   MZ_STREAM_END

Z_STREAM_ERROR

#define Z_STREAM_ERROR   MZ_STREAM_ERROR

Z_SYNC_FLUSH

#define Z_SYNC_FLUSH   MZ_SYNC_FLUSH

Z_VERSION_ERROR

#define Z_VERSION_ERROR   MZ_VERSION_ERROR

zError

#define zError   mz_error

ZLIB_VER_MAJOR

#define ZLIB_VER_MAJOR   MZ_VER_MAJOR

ZLIB_VER_MINOR

#define ZLIB_VER_MINOR   MZ_VER_MINOR

ZLIB_VER_REVISION

#define ZLIB_VER_REVISION   MZ_VER_REVISION

ZLIB_VER_SUBREVISION

#define ZLIB_VER_SUBREVISION   MZ_VER_SUBREVISION

ZLIB_VERNUM

#define ZLIB_VERNUM   MZ_VERNUM

ZLIB_VERSION

#define ZLIB_VERSION   MZ_VERSION

zlib_version

#define zlib_version   mz_version()

zlibVersion

#define zlibVersion   mz_version

Typedef Documentation

Byte

typedef unsigned char Byte

Bytef

typedef Byte Bytef

charf

typedef char charf

intf

typedef int intf

mz_alloc_func

typedef void *(* mz_alloc_func) (void *opaque, size_t items, size_t size)

mz_bool

typedef int mz_bool

mz_file_read_func

typedef size_t(* mz_file_read_func) (void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

mz_file_write_func

typedef size_t(* mz_file_write_func) (void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)

mz_free_func

typedef void(* mz_free_func) (void *opaque, void *address)

mz_int16

typedef signed short mz_int16

mz_int64

typedef long long mz_int64

mz_realloc_func

typedef void *(* mz_realloc_func) (void *opaque, void *address, size_t items, size_t size)

mz_stream

typedef struct mz_stream_s mz_stream

mz_streamp

typedef mz_stream* mz_streamp

mz_uint

typedef unsigned int mz_uint

mz_uint16

typedef unsigned short mz_uint16

mz_uint32

typedef unsigned int mz_uint32

mz_uint64

typedef unsigned long long mz_uint64

mz_uint8

typedef unsigned char mz_uint8

mz_ulong

typedef unsigned long mz_ulong

mz_validate_uint16

typedef unsigned char mz_validate_uint16[sizeof(mz_uint16)==2 ? 1 :-1]

mz_validate_uint32

typedef unsigned char mz_validate_uint32[sizeof(mz_uint32)==4 ? 1 :-1]

mz_validate_uint64

typedef unsigned char mz_validate_uint64[sizeof(mz_uint64)==8 ? 1 :-1]

mz_zip_internal_state

typedef struct mz_zip_internal_state_tag mz_zip_internal_state

tdefl_put_buf_func_ptr

typedef mz_bool(* tdefl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)

tinfl_bit_buf_t

typedef mz_uint32 tinfl_bit_buf_t

tinfl_decompressor

typedef struct tinfl_decompressor_tag tinfl_decompressor

tinfl_put_buf_func_ptr

typedef int(* tinfl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)

uInt

typedef unsigned int uInt

uIntf

typedef uInt uIntf

uLong

typedef mz_ulong uLong

uLongf

typedef uLong uLongf

voidp

typedef void* voidp

voidpc

typedef void* const voidpc

voidpf

typedef void* voidpf

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
TINFL_FLAG_PARSE_ZLIB_HEADER
TINFL_FLAG_HAS_MORE_INPUT
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF
TINFL_FLAG_COMPUTE_ADLER32

anonymous enum

anonymous enum

Enumerator
TINFL_MAX_HUFF_TABLES
TINFL_MAX_HUFF_SYMBOLS_0
TINFL_MAX_HUFF_SYMBOLS_1
TINFL_MAX_HUFF_SYMBOLS_2
TINFL_FAST_LOOKUP_BITS
TINFL_FAST_LOOKUP_SIZE

anonymous enum

anonymous enum

Enumerator
TDEFL_HUFFMAN_ONLY
TDEFL_DEFAULT_MAX_PROBES
TDEFL_MAX_PROBES_MASK

anonymous enum

anonymous enum

Enumerator
TDEFL_WRITE_ZLIB_HEADER
TDEFL_COMPUTE_ADLER32
TDEFL_GREEDY_PARSING_FLAG
TDEFL_NONDETERMINISTIC_PARSING_FLAG
TDEFL_RLE_MATCHES
TDEFL_FILTER_MATCHES
TDEFL_FORCE_ALL_STATIC_BLOCKS
TDEFL_FORCE_ALL_RAW_BLOCKS

anonymous enum

anonymous enum

Enumerator
TDEFL_MAX_HUFF_TABLES
TDEFL_MAX_HUFF_SYMBOLS_0
TDEFL_MAX_HUFF_SYMBOLS_1
TDEFL_MAX_HUFF_SYMBOLS_2
TDEFL_LZ_DICT_SIZE
TDEFL_LZ_DICT_SIZE_MASK
TDEFL_MIN_MATCH_LEN
TDEFL_MAX_MATCH_LEN

anonymous enum

anonymous enum

Enumerator
TDEFL_LZ_CODE_BUF_SIZE
TDEFL_OUT_BUF_SIZE
TDEFL_MAX_HUFF_SYMBOLS
TDEFL_LZ_HASH_BITS
TDEFL_LEVEL1_HASH_SIZE_MASK
TDEFL_LZ_HASH_SHIFT
TDEFL_LZ_HASH_SIZE

anonymous enum

anonymous enum

Enumerator
TDEFL_MAX_SUPPORTED_HUFF_CODESIZE

anonymous enum

anonymous enum

Enumerator
MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG
MZ_ZIP_CENTRAL_DIR_HEADER_SIG
MZ_ZIP_LOCAL_DIR_HEADER_SIG
MZ_ZIP_LOCAL_DIR_HEADER_SIZE
MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE
MZ_ZIP_CDH_SIG_OFS
MZ_ZIP_CDH_VERSION_MADE_BY_OFS
MZ_ZIP_CDH_VERSION_NEEDED_OFS
MZ_ZIP_CDH_BIT_FLAG_OFS
MZ_ZIP_CDH_METHOD_OFS
MZ_ZIP_CDH_FILE_TIME_OFS
MZ_ZIP_CDH_FILE_DATE_OFS
MZ_ZIP_CDH_CRC32_OFS
MZ_ZIP_CDH_COMPRESSED_SIZE_OFS
MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS
MZ_ZIP_CDH_FILENAME_LEN_OFS
MZ_ZIP_CDH_EXTRA_LEN_OFS
MZ_ZIP_CDH_COMMENT_LEN_OFS
MZ_ZIP_CDH_DISK_START_OFS
MZ_ZIP_CDH_INTERNAL_ATTR_OFS
MZ_ZIP_CDH_EXTERNAL_ATTR_OFS
MZ_ZIP_CDH_LOCAL_HEADER_OFS
MZ_ZIP_LDH_SIG_OFS
MZ_ZIP_LDH_VERSION_NEEDED_OFS
MZ_ZIP_LDH_BIT_FLAG_OFS
MZ_ZIP_LDH_METHOD_OFS
MZ_ZIP_LDH_FILE_TIME_OFS
MZ_ZIP_LDH_FILE_DATE_OFS
MZ_ZIP_LDH_CRC32_OFS
MZ_ZIP_LDH_COMPRESSED_SIZE_OFS
MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS
MZ_ZIP_LDH_FILENAME_LEN_OFS
MZ_ZIP_LDH_EXTRA_LEN_OFS
MZ_ZIP_ECDH_SIG_OFS
MZ_ZIP_ECDH_NUM_THIS_DISK_OFS
MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS
MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS
MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS
MZ_ZIP_ECDH_CDIR_SIZE_OFS
MZ_ZIP_ECDH_CDIR_OFS_OFS
MZ_ZIP_ECDH_COMMENT_SIZE_OFS

anonymous enum

anonymous enum

Enumerator
MZ_DEFAULT_STRATEGY
MZ_FILTERED
MZ_HUFFMAN_ONLY
MZ_RLE
MZ_FIXED

anonymous enum

anonymous enum

Enumerator
MZ_NO_FLUSH
MZ_PARTIAL_FLUSH
MZ_SYNC_FLUSH
MZ_FULL_FLUSH
MZ_FINISH
MZ_BLOCK

anonymous enum

anonymous enum

Enumerator
MZ_OK
MZ_STREAM_END
MZ_NEED_DICT
MZ_ERRNO
MZ_STREAM_ERROR
MZ_DATA_ERROR
MZ_MEM_ERROR
MZ_BUF_ERROR
MZ_VERSION_ERROR
MZ_PARAM_ERROR

anonymous enum

anonymous enum

Enumerator
MZ_NO_COMPRESSION
MZ_BEST_SPEED
MZ_BEST_COMPRESSION
MZ_UBER_COMPRESSION
MZ_DEFAULT_LEVEL
MZ_DEFAULT_COMPRESSION

anonymous enum

anonymous enum

Enumerator
MZ_ZIP_MAX_IO_BUF_SIZE
MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE
MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE

mz_zip_flags

enum mz_zip_flags

Enumerator
MZ_ZIP_FLAG_CASE_SENSITIVE
MZ_ZIP_FLAG_IGNORE_PATH
MZ_ZIP_FLAG_COMPRESSED_DATA
MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY

mz_zip_mode

enum mz_zip_mode

Enumerator
MZ_ZIP_MODE_INVALID
MZ_ZIP_MODE_READING
MZ_ZIP_MODE_WRITING
MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED

tdefl_flush

enum tdefl_flush

Enumerator
TDEFL_NO_FLUSH
TDEFL_SYNC_FLUSH
TDEFL_FULL_FLUSH
TDEFL_FINISH

tdefl_status

enum tdefl_status

Enumerator
TDEFL_STATUS_BAD_PARAM
TDEFL_STATUS_PUT_BUF_FAILED
TDEFL_STATUS_OKAY
TDEFL_STATUS_DONE

tinfl_status

enum tinfl_status

Enumerator
TINFL_STATUS_BAD_PARAM
TINFL_STATUS_ADLER32_MISMATCH
TINFL_STATUS_FAILED
TINFL_STATUS_DONE
TINFL_STATUS_NEEDS_MORE_INPUT
TINFL_STATUS_HAS_MORE_OUTPUT

Function Documentation

mz_adler32()

mz_ulong mz_adler32	(	mz_ulong	adler,
		const unsigned char *	ptr,
		size_t	buf_len
	)

mz_compress()

int mz_compress	(	unsigned char *	pDest,
		mz_ulong *	pDest_len,
		const unsigned char *	pSource,
		mz_ulong	source_len
	)

mz_compress2()

int mz_compress2	(	unsigned char *	pDest,
		mz_ulong *	pDest_len,
		const unsigned char *	pSource,
		mz_ulong	source_len,
		int	level
	)

mz_compressBound()

mz_ulong mz_compressBound

(

mz_ulong

source_len

)

mz_crc32()

mz_ulong mz_crc32	(	mz_ulong	crc,
		const unsigned char *	ptr,
		size_t	buf_len
	)

mz_deflate()

int mz_deflate	(	mz_streamp	pStream,
		int	flush
	)

mz_deflateBound()

mz_ulong mz_deflateBound	(	mz_streamp	pStream,
		mz_ulong	source_len
	)

mz_deflateEnd()

int mz_deflateEnd

(

mz_streamp

pStream

)

mz_deflateInit()

int mz_deflateInit	(	mz_streamp	pStream,
		int	level
	)

mz_deflateInit2()

int mz_deflateInit2	(	mz_streamp	pStream,
		int	level,
		int	method,
		int	window_bits,
		int	mem_level,
		int	strategy
	)

mz_deflateReset()

int mz_deflateReset

(

mz_streamp

pStream

)

mz_error()

const char * mz_error

(

int

err

)

mz_inflate()

int mz_inflate	(	mz_streamp	pStream,
		int	flush
	)

mz_inflateEnd()

int mz_inflateEnd

(

mz_streamp

pStream

)

mz_inflateInit()

int mz_inflateInit

(

mz_streamp

pStream

)

mz_inflateInit2()

int mz_inflateInit2	(	mz_streamp	pStream,
		int	window_bits
	)

mz_uncompress()

int mz_uncompress	(	unsigned char *	pDest,
		mz_ulong *	pDest_len,
		const unsigned char *	pSource,
		mz_ulong	source_len
	)

mz_version()

const char * mz_version

(

void

)

mz_zip_add_mem_to_archive_file_in_place()

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_zip_extract_archive_file_to_heap()

void * mz_zip_extract_archive_file_to_heap	(	const char *	pZip_filename,
		const char *	pArchive_name,
		size_t *	pSize,
		mz_uint	zip_flags
	)

mz_zip_reader_end()

mz_bool mz_zip_reader_end

(

mz_zip_archive *

pZip

)

mz_zip_reader_extract_file_to_callback()

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
	)

mz_zip_reader_extract_file_to_file()

mz_bool mz_zip_reader_extract_file_to_file	(	mz_zip_archive *	pZip,
		const char *	pArchive_filename,
		const char *	pDst_filename,
		mz_uint	flags
	)

mz_zip_reader_extract_file_to_heap()

void * mz_zip_reader_extract_file_to_heap	(	mz_zip_archive *	pZip,
		const char *	pFilename,
		size_t *	pSize,
		mz_uint	flags
	)

mz_zip_reader_extract_file_to_mem()

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
	)

mz_zip_reader_extract_file_to_mem_no_alloc()

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
	)

mz_zip_reader_extract_to_callback()

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
	)

mz_zip_reader_extract_to_file()

mz_bool mz_zip_reader_extract_to_file	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		const char *	pDst_filename,
		mz_uint	flags
	)

mz_zip_reader_extract_to_heap()

void * mz_zip_reader_extract_to_heap	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		size_t *	pSize,
		mz_uint	flags
	)

mz_zip_reader_extract_to_mem()

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
	)

mz_zip_reader_extract_to_mem_no_alloc()

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
	)

mz_zip_reader_file_stat()

mz_bool mz_zip_reader_file_stat	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		mz_zip_archive_file_stat *	pStat
	)

mz_zip_reader_get_filename()

mz_uint mz_zip_reader_get_filename	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		char *	pFilename,
		mz_uint	filename_buf_size
	)

mz_zip_reader_get_num_files()

mz_uint mz_zip_reader_get_num_files

(

mz_zip_archive *

pZip

)

mz_zip_reader_init()

mz_bool mz_zip_reader_init	(	mz_zip_archive *	pZip,
		mz_uint64	size,
		mz_uint32	flags
	)

mz_zip_reader_init_file()

mz_bool mz_zip_reader_init_file	(	mz_zip_archive *	pZip,
		const char *	pFilename,
		mz_uint32	flags
	)

mz_zip_reader_init_mem()

mz_bool mz_zip_reader_init_mem	(	mz_zip_archive *	pZip,
		const void *	pMem,
		size_t	size,
		mz_uint32	flags
	)

mz_zip_reader_is_file_a_directory()

mz_bool mz_zip_reader_is_file_a_directory	(	mz_zip_archive *	pZip,
		mz_uint	file_index
	)

mz_zip_reader_is_file_encrypted()

mz_bool mz_zip_reader_is_file_encrypted	(	mz_zip_archive *	pZip,
		mz_uint	file_index
	)

mz_zip_reader_locate_file()

int mz_zip_reader_locate_file	(	mz_zip_archive *	pZip,
		const char *	pName,
		const char *	pComment,
		mz_uint	flags
	)

mz_zip_writer_add_file()

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
	)

mz_zip_writer_add_from_zip_reader()

mz_bool mz_zip_writer_add_from_zip_reader	(	mz_zip_archive *	pZip,
		mz_zip_archive *	pSource_zip,
		mz_uint	file_index
	)

mz_zip_writer_add_mem()

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_zip_writer_add_mem_ex()

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_zip_writer_end()

mz_bool mz_zip_writer_end

(

mz_zip_archive *

pZip

)

mz_zip_writer_finalize_archive()

mz_bool mz_zip_writer_finalize_archive

(

mz_zip_archive *

pZip

)

mz_zip_writer_finalize_heap_archive()

mz_bool mz_zip_writer_finalize_heap_archive	(	mz_zip_archive *	pZip,
		void **	pBuf,
		size_t *	pSize
	)

mz_zip_writer_init()

mz_bool mz_zip_writer_init	(	mz_zip_archive *	pZip,
		mz_uint64	existing_size
	)

mz_zip_writer_init_file()

mz_bool mz_zip_writer_init_file	(	mz_zip_archive *	pZip,
		const char *	pFilename,
		mz_uint64	size_to_reserve_at_beginning
	)

mz_zip_writer_init_from_reader()

mz_bool mz_zip_writer_init_from_reader	(	mz_zip_archive *	pZip,
		const char *	pFilename
	)

mz_zip_writer_init_heap()

mz_bool mz_zip_writer_init_heap	(	mz_zip_archive *	pZip,
		size_t	size_to_reserve_at_beginning,
		size_t	initial_allocation_size
	)

tdefl_compress()

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
	)

tdefl_compress_buffer()

tdefl_status tdefl_compress_buffer	(	tdefl_compressor *	d,
		const void *	pIn_buf,
		size_t	in_buf_size,
		tdefl_flush	flush
	)

tdefl_compress_mem_to_heap()

void * tdefl_compress_mem_to_heap	(	const void *	pSrc_buf,
		size_t	src_buf_len,
		size_t *	pOut_len,
		int	flags
	)

tdefl_compress_mem_to_mem()

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
	)

tdefl_compress_mem_to_output()

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
	)

tdefl_create_comp_flags_from_zip_params()

mz_uint tdefl_create_comp_flags_from_zip_params	(	int	level,
		int	window_bits,
		int	strategy
	)

tdefl_get_adler32()

mz_uint32 tdefl_get_adler32

(

tdefl_compressor *

d

)

tdefl_get_prev_return_status()

tdefl_status tdefl_get_prev_return_status

(

tdefl_compressor *

d

)

tdefl_init()

tdefl_status tdefl_init	(	tdefl_compressor *	d,
		tdefl_put_buf_func_ptr	pPut_buf_func,
		void *	pPut_buf_user,
		int	flags
	)

tinfl_decompress()

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
	)

tinfl_decompress_mem_to_callback()

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
	)

tinfl_decompress_mem_to_heap()

void * tinfl_decompress_mem_to_heap	(	const void *	pSrc_buf,
		size_t	src_buf_len,
		size_t *	pOut_len,
		int	flags
	)

tinfl_decompress_mem_to_mem()

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
	)