utd_util/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>

Include dependency graph for miniz.c:

This graph shows which files directly or indirectly include this file:

Classes
struct	mz_stream_s
struct	mz_zip_archive_file_stat
struct	mz_zip_archive_tag
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
Defines
#define	MINIZ_LITTLE_ENDIAN 1
#define	MZ_ADLER32_INIT (1)
#define	MZ_CRC32_INIT (0)
#define	MZ_DEFLATED 8
#define	MZ_VERSION "9.1.15"
#define	MZ_VERNUM 0x91F0
#define	MZ_VER_MAJOR 9
#define	MZ_VER_MINOR 1
#define	MZ_VER_REVISION 15
#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(f, m) fopen(f, m)
#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(f, m, s) freopen(f, m, s)
#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 struct mz_zip_archive_tag	mz_zip_archive
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
void	mz_free (void *p)
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)
void *	tdefl_write_image_to_png_file_in_memory_ex (const void pImage, int w, int h, int num_chans, size_t pLen_out, mz_uint level, mz_bool flip)
void *	tdefl_write_image_to_png_file_in_memory (const void pImage, int w, int h, int num_chans, size_t pLen_out)
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)

Define Documentation

#define adler32 mz_adler32

#define alloc_func mz_alloc_func

#define compress mz_compress

#define compress2 mz_compress2

#define compressBound mz_compressBound

#define crc32 mz_crc32

#define deflate mz_deflate

#define deflateBound mz_deflateBound

#define deflateEnd mz_deflateEnd

#define deflateInit mz_deflateInit

#define deflateInit2 mz_deflateInit2

#define deflateReset mz_deflateReset

#define free_func mz_free_func

#define inflate mz_inflate

#define inflateEnd mz_inflateEnd

#define inflateInit mz_inflateInit

#define inflateInit2 mz_inflateInit2

#define internal_state mz_internal_state

#define MAX_MEM_LEVEL 9

#define MAX_WBITS 15

#define MINIZ_LITTLE_ENDIAN 1

#define MZ_ADLER32_INIT (1)

#define MZ_ASSERT ( x ) assert(x)

#define MZ_CLEAR_OBJ ( obj ) memset(&(obj), 0, sizeof(obj))

#define MZ_CRC32_INIT (0)

#define MZ_DEFAULT_WINDOW_BITS 15

#define MZ_DEFLATED 8

#define MZ_DELETE_FILE remove

#define MZ_FALSE (0)

#define MZ_FCLOSE fclose

#define MZ_FFLUSH fflush

#define MZ_FILE FILE

#define MZ_FILE_STAT stat

#define MZ_FILE_STAT_STRUCT stat

#define MZ_FOPEN	(	f,
		m		)	fopen(f, m)

#define MZ_FORCEINLINE inline

#define MZ_FREAD fread

#define MZ_FREE ( x ) free(x)

#define MZ_FREOPEN	(	f,
		m,
		s	)	freopen(f, m, s)

#define MZ_FSEEK64 fseeko

#define MZ_FTELL64 ftello

#define MZ_FWRITE fwrite

#define MZ_MACRO_END while (0)

#define MZ_MALLOC ( x ) malloc(x)

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

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

#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_REALLOC	(	p,
		x		)	realloc(p, x)

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

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

#define MZ_TRUE (1)

#define MZ_VER_MAJOR 9

#define MZ_VER_MINOR 1

#define MZ_VER_REVISION 15

#define MZ_VER_SUBREVISION 0

#define MZ_VERNUM 0x91F0

#define MZ_VERSION "9.1.15"

#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))

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

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

#define TDEFL_LESS_MEMORY 0

#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;

#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); \
      d->m_bit_buffer >>= 8; \
      d->m_bits_in -= 8; \
  } \
} MZ_MACRO_END

#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; } }

#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; } }

#define TINFL_BITBUF_SIZE (32)

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

#define TINFL_CR_FINISH }

#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_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))

#define tinfl_get_adler32 ( r ) (r)->m_check_adler32

#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_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

#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);

#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

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

#define TINFL_LZ_DICT_SIZE 32768

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

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

#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 uncompress mz_uncompress

#define Z_BEST_COMPRESSION MZ_BEST_COMPRESSION

#define Z_BEST_SPEED MZ_BEST_SPEED

#define Z_BLOCK MZ_BLOCK

#define Z_BUF_ERROR MZ_BUF_ERROR

#define Z_DATA_ERROR MZ_DATA_ERROR

#define Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION

#define Z_DEFAULT_STRATEGY MZ_DEFAULT_STRATEGY

#define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS

#define Z_DEFLATED MZ_DEFLATED

#define Z_ERRNO MZ_ERRNO

#define Z_FILTERED MZ_FILTERED

#define Z_FINISH MZ_FINISH

#define Z_FIXED MZ_FIXED

#define Z_FULL_FLUSH MZ_FULL_FLUSH

#define Z_HUFFMAN_ONLY MZ_HUFFMAN_ONLY

#define Z_MEM_ERROR MZ_MEM_ERROR

#define Z_NEED_DICT MZ_NEED_DICT

#define Z_NO_COMPRESSION MZ_NO_COMPRESSION

#define Z_NO_FLUSH MZ_NO_FLUSH

#define Z_NULL 0

#define Z_OK MZ_OK

#define Z_PARAM_ERROR MZ_PARAM_ERROR

#define Z_PARTIAL_FLUSH MZ_PARTIAL_FLUSH

#define Z_RLE MZ_RLE

#define z_stream mz_stream

#define Z_STREAM_END MZ_STREAM_END

#define Z_STREAM_ERROR MZ_STREAM_ERROR

#define Z_SYNC_FLUSH MZ_SYNC_FLUSH

#define Z_VERSION_ERROR MZ_VERSION_ERROR

#define zError mz_error

#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 ZLIB_VERNUM MZ_VERNUM

#define zlib_version mz_version()

#define ZLIB_VERSION MZ_VERSION

#define zlibVersion mz_version

Typedef Documentation

typedef unsigned char Byte

typedef Byte Bytef

typedef char charf

typedef int intf

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

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 void(* mz_free_func)(void *opaque, void *address)

typedef signed short mz_int16

typedef long long mz_int64

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 int mz_uint

typedef unsigned short mz_uint16

typedef unsigned int mz_uint32

typedef unsigned long long mz_uint64

typedef unsigned char mz_uint8

typedef unsigned long mz_ulong

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]

typedef struct mz_zip_archive_tag mz_zip_archive

typedef struct mz_zip_internal_state_tag mz_zip_internal_state

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

typedef mz_uint32 tinfl_bit_buf_t

typedef struct tinfl_decompressor_tag tinfl_decompressor

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

typedef unsigned int uInt

typedef uInt uIntf

typedef mz_ulong uLong

typedef uLong uLongf

typedef void* voidp

typedef void* const voidpc

typedef void* voidpf

Enumeration Type Documentation

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

Enumerator:

TDEFL_MAX_SUPPORTED_HUFF_CODESIZE

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

Enumerator:

MZ_DEFAULT_STRATEGY
MZ_FILTERED
MZ_HUFFMAN_ONLY
MZ_RLE
MZ_FIXED

anonymous enum

Enumerator:

MZ_NO_FLUSH
MZ_PARTIAL_FLUSH
MZ_SYNC_FLUSH
MZ_FULL_FLUSH
MZ_FINISH
MZ_BLOCK

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

Enumerator:

MZ_NO_COMPRESSION
MZ_BEST_SPEED
MZ_BEST_COMPRESSION
MZ_UBER_COMPRESSION
MZ_DEFAULT_LEVEL
MZ_DEFAULT_COMPRESSION

anonymous enum

Enumerator:

MZ_ZIP_MAX_IO_BUF_SIZE
MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE
MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE

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

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

Enumerator:

TDEFL_HUFFMAN_ONLY
TDEFL_DEFAULT_MAX_PROBES
TDEFL_MAX_PROBES_MASK

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

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

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

enum mz_zip_mode

Enumerator:

MZ_ZIP_MODE_INVALID
MZ_ZIP_MODE_READING
MZ_ZIP_MODE_WRITING
MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED

enum tdefl_flush

Enumerator:

TDEFL_NO_FLUSH
TDEFL_SYNC_FLUSH
TDEFL_FULL_FLUSH
TDEFL_FINISH

enum tdefl_status

Enumerator:

TDEFL_STATUS_BAD_PARAM
TDEFL_STATUS_PUT_BUF_FAILED
TDEFL_STATUS_OKAY
TDEFL_STATUS_DONE

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_ulong mz_adler32	(	mz_ulong	adler,
		const unsigned char *	ptr,
		size_t	buf_len
	)

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

mz_ulong mz_compressBound ( mz_ulong source_len )

Here is the call graph for this function:

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

Here is the caller graph for this function:

int mz_deflate	(	mz_streamp	pStream,
		int	flush
	)

Here is the call graph for this function:

Here is the caller graph for this function:

mz_ulong mz_deflateBound	(	mz_streamp	pStream,
		mz_ulong	source_len
	)

Here is the caller graph for this function:

int mz_deflateEnd ( mz_streamp pStream )

Here is the caller graph for this function:

int mz_deflateInit	(	mz_streamp	pStream,
		int	level
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

int mz_deflateReset ( mz_streamp pStream )

Here is the call graph for this function:

const char * mz_error ( int err )

void mz_free ( void * p )

int mz_inflate	(	mz_streamp	pStream,
		int	flush
	)

Here is the call graph for this function:

Here is the caller graph for this function:

int mz_inflateEnd ( mz_streamp pStream )

Here is the caller graph for this function:

int mz_inflateInit ( mz_streamp pStream )

Here is the call graph for this function:

Here is the caller graph for this function:

int mz_inflateInit2	(	mz_streamp	pStream,
		int	window_bits
	)

Here is the caller graph for this function:

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

Here is the call graph for this function:

const char * mz_version ( void )

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
	)

Here is the call graph for this function:

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

Here is the call graph for this function:

mz_bool mz_zip_reader_end ( mz_zip_archive * pZip )

Here is the caller graph for this function:

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
	)

Here is the call graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

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
	)

Here is the call graph for this function:

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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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

mz_uint mz_zip_reader_get_num_files ( mz_zip_archive * pZip )

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

mz_bool mz_zip_reader_is_file_a_directory	(	mz_zip_archive *	pZip,
		mz_uint	file_index
	)

Here is the caller graph for this function:

mz_bool mz_zip_reader_is_file_encrypted	(	mz_zip_archive *	pZip,
		mz_uint	file_index
	)

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

Here is the caller graph for this function:

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
	)

Here is the call graph for this function:

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_add_mem	(	mz_zip_archive *	pZip,
		const char *	pArchive_name,
		const void *	pBuf,
		size_t	buf_size,
		mz_uint	level_and_flags
	)

Here is the call graph for this function:

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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

mz_bool mz_zip_writer_end ( mz_zip_archive * pZip )

Here is the caller graph for this function:

mz_bool mz_zip_writer_finalize_archive ( mz_zip_archive * pZip )

Here is the caller graph for this function:

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

Here is the call graph for this function:

mz_bool mz_zip_writer_init	(	mz_zip_archive *	pZip,
		mz_uint64	existing_size
	)

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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
	)

Here is the call graph for this function:

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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

mz_uint32 tdefl_get_adler32 ( tdefl_compressor * d )

Here is the caller graph for this function:

tdefl_status tdefl_get_prev_return_status ( tdefl_compressor * d )

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

Here is the caller graph for this function:

void * tdefl_write_image_to_png_file_in_memory	(	const void *	pImage,
		int	w,
		int	h,
		int	num_chans,
		size_t *	pLen_out
	)

Here is the call graph for this function:

void * tdefl_write_image_to_png_file_in_memory_ex	(	const void *	pImage,
		int	w,
		int	h,
		int	num_chans,
		size_t *	pLen_out,
		mz_uint	level,
		mz_bool	flip
	)

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

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
	)

Here is the call graph for this function:

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

Here is the call graph for this function:

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
	)

Here is the call graph for this function:

utd_util/miniz.c File Reference

Classes

Defines

Typedefs

Enumerations

Functions

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation