#include "miniz.h"
#include <sys/stat.h>
#include <utime.h>

Include dependency graph for miniz.c:

Classes
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	TDEFL_PUT_BITS(b, l)
#define	TDEFL_RLE_PREV_CODE_SIZE()
#define	TDEFL_RLE_ZERO_CODE_SIZE()
#define	TDEFL_PROBE
#define	TINFL_MEMCPY(d, s, l)
#define	TINFL_MEMSET(p, c, l)
#define	TINFL_CR_BEGIN
#define	TINFL_CR_RETURN(state_index, result)
#define	TINFL_CR_RETURN_FOREVER(state_index, result)
#define	TINFL_CR_FINISH }
#define	TINFL_GET_BYTE(state_index, c)
#define	TINFL_NEED_BITS(state_index, n)
#define	TINFL_SKIP_BITS(state_index, n)
#define	TINFL_GET_BITS(state_index, b, n)
#define	TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree)
#define	TINFL_HUFF_DECODE(state_index, sym, pLookUp, pTree)
#define	MZ_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)
#define	MZ_DELETE_FILE remove
#define	MZ_TOLOWER(c)
#define	MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size)
#define	MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index)
#define	MZ_SWAP_UINT32(a, b)
#define	MZ_WRITE_LE16(p, v)
#define	MZ_WRITE_LE32(p, v)
#define	MZ_WRITE_LE64(p, v)
#define	MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2)
#define	MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3)

Typedefs
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	{ 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_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50 , MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50 , MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56 , MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20 , MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001 , MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50 , MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24 , MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16 , 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_LDH_BIT_FLAG_HAS_LOCATOR = 1 << 3 , 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 , MZ_ZIP64_ECDL_SIG_OFS = 0 , MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4 , MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8 , MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16 , MZ_ZIP64_ECDH_SIG_OFS = 0 , MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4 , MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12 , MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14 , MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16 , MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20 , MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24 , MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32 , MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40 , MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48 , MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0 , MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10 , MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1 , MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32 , MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64 , MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192 , MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11 }

Functions
mz_ulong	mz_adler32 (mz_ulong adler, const unsigned char *ptr, size_t buf_len)
mz_ulong	mz_crc32 (mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
void	mz_free (void *p)
MINIZ_EXPORT void *	miniz_def_alloc_func (void *opaque, size_t items, size_t size)
MINIZ_EXPORT void	miniz_def_free_func (void opaque, void address)
MINIZ_EXPORT void *	miniz_def_realloc_func (void opaque, void address, size_t items, size_t size)
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_compress2 (unsigned char pDest, mz_ulong pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
int	mz_compress (unsigned char pDest, mz_ulong pDest_len, const unsigned char *pSource, mz_ulong source_len)
mz_ulong	mz_compressBound (mz_ulong source_len)
int	mz_inflateInit2 (mz_streamp pStream, int window_bits)
int	mz_inflateInit (mz_streamp pStream)
int	mz_inflateReset (mz_streamp pStream)
int	mz_inflate (mz_streamp pStream, int flush)
int	mz_inflateEnd (mz_streamp pStream)
int	mz_uncompress2 (unsigned char pDest, mz_ulong pDest_len, const unsigned char pSource, mz_ulong pSource_len)
int	mz_uncompress (unsigned char pDest, mz_ulong pDest_len, const unsigned char *pSource, mz_ulong source_len)
const char *	mz_error (int err)
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_init (tdefl_compressor d, tdefl_put_buf_func_ptr pPut_buf_func, void pPut_buf_user, int flags)
tdefl_status	tdefl_get_prev_return_status (tdefl_compressor *d)
mz_uint32	tdefl_get_adler32 (tdefl_compressor *d)
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)
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_uint	tdefl_create_comp_flags_from_zip_params (int level, int window_bits, int strategy)
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)
tdefl_compressor *	tdefl_compressor_alloc (void)
void	tdefl_compressor_free (tdefl_compressor *pComp)
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 *	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_decompressor *	tinfl_decompressor_alloc (void)
void	tinfl_decompressor_free (tinfl_decompressor *pDecomp)
void	mz_zip_zero_struct (mz_zip_archive *pZip)
mz_bool	mz_zip_reader_end (mz_zip_archive *pZip)
mz_bool	mz_zip_reader_init (mz_zip_archive *pZip, mz_uint64 size, mz_uint flags)
mz_bool	mz_zip_reader_init_mem (mz_zip_archive pZip, const void pMem, size_t size, mz_uint flags)
mz_bool	mz_zip_reader_init_file (mz_zip_archive pZip, const char pFilename, mz_uint32 flags)
mz_bool	mz_zip_reader_init_file_v2 (mz_zip_archive pZip, const char pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)
mz_bool	mz_zip_reader_init_cfile (mz_zip_archive pZip, MZ_FILE pFile, mz_uint64 archive_size, mz_uint flags)
mz_bool	mz_zip_reader_is_file_encrypted (mz_zip_archive *pZip, mz_uint file_index)
mz_bool	mz_zip_reader_is_file_supported (mz_zip_archive *pZip, mz_uint file_index)
mz_bool	mz_zip_reader_is_file_a_directory (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)
mz_bool	mz_zip_reader_locate_file_v2 (mz_zip_archive pZip, const char pName, const char pComment, mz_uint flags, mz_uint32 pIndex)
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_zip_reader_extract_iter_state *	mz_zip_reader_extract_iter_new (mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
mz_zip_reader_extract_iter_state *	mz_zip_reader_extract_file_iter_new (mz_zip_archive pZip, const char pFilename, mz_uint flags)
size_t	mz_zip_reader_extract_iter_read (mz_zip_reader_extract_iter_state pState, void pvBuf, size_t buf_size)
mz_bool	mz_zip_reader_extract_iter_free (mz_zip_reader_extract_iter_state *pState)
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_extract_to_cfile (mz_zip_archive pZip, mz_uint file_index, MZ_FILE pFile, mz_uint flags)
mz_bool	mz_zip_reader_extract_file_to_cfile (mz_zip_archive pZip, const char pArchive_filename, MZ_FILE *pFile, mz_uint flags)
mz_bool	mz_zip_validate_file (mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
mz_bool	mz_zip_validate_archive (mz_zip_archive *pZip, mz_uint flags)
mz_bool	mz_zip_validate_mem_archive (const void pMem, size_t size, mz_uint flags, mz_zip_error pErr)
mz_bool	mz_zip_validate_file_archive (const char pFilename, mz_uint flags, mz_zip_error pErr)
mz_bool	mz_zip_writer_init_v2 (mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags)
mz_bool	mz_zip_writer_init (mz_zip_archive *pZip, mz_uint64 existing_size)
mz_bool	mz_zip_writer_init_heap_v2 (mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags)
mz_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_file_v2 (mz_zip_archive pZip, const char pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags)
mz_bool	mz_zip_writer_init_cfile (mz_zip_archive pZip, MZ_FILE pFile, mz_uint flags)
mz_bool	mz_zip_writer_init_from_reader_v2 (mz_zip_archive pZip, const char pFilename, mz_uint flags)
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_mem_ex_v2 (mz_zip_archive pZip, const char pArchive_name, const void pBuf, size_t buf_size, const void pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T last_modified, const char user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
mz_bool	mz_zip_writer_add_read_buf_callback (mz_zip_archive pZip, const char pArchive_name, mz_file_read_func read_callback, void callback_opaque, mz_uint64 max_size, const MZ_TIME_T pFile_time, const void pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
mz_bool	mz_zip_writer_add_cfile (mz_zip_archive pZip, const char pArchive_name, MZ_FILE pSrc_file, mz_uint64 max_size, const MZ_TIME_T pFile_time, const void pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
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 src_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 ppBuf, 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)
mz_bool	mz_zip_add_mem_to_archive_file_in_place_v2 (const char pZip_filename, const char pArchive_name, const void pBuf, size_t buf_size, const void pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr)
void *	mz_zip_extract_archive_file_to_heap_v2 (const char pZip_filename, const char pArchive_name, const char pComment, size_t pSize, mz_uint flags, mz_zip_error *pErr)
void *	mz_zip_extract_archive_file_to_heap (const char pZip_filename, const char pArchive_name, size_t *pSize, mz_uint flags)
mz_zip_mode	mz_zip_get_mode (mz_zip_archive *pZip)
mz_zip_type	mz_zip_get_type (mz_zip_archive *pZip)
mz_zip_error	mz_zip_set_last_error (mz_zip_archive *pZip, mz_zip_error err_num)
mz_zip_error	mz_zip_peek_last_error (mz_zip_archive *pZip)
mz_zip_error	mz_zip_clear_last_error (mz_zip_archive *pZip)
mz_zip_error	mz_zip_get_last_error (mz_zip_archive *pZip)
const char *	mz_zip_get_error_string (mz_zip_error mz_err)
mz_bool	mz_zip_is_zip64 (mz_zip_archive *pZip)
size_t	mz_zip_get_central_dir_size (mz_zip_archive *pZip)
mz_uint	mz_zip_reader_get_num_files (mz_zip_archive *pZip)
mz_uint64	mz_zip_get_archive_size (mz_zip_archive *pZip)
mz_uint64	mz_zip_get_archive_file_start_offset (mz_zip_archive *pZip)
MZ_FILE *	mz_zip_get_cfile (mz_zip_archive *pZip)
size_t	mz_zip_read_archive_data (mz_zip_archive pZip, mz_uint64 file_ofs, void pBuf, size_t n)
mz_uint	mz_zip_reader_get_filename (mz_zip_archive pZip, mz_uint file_index, char pFilename, mz_uint filename_buf_size)
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_end (mz_zip_archive *pZip)

Macro Definition Documentation

◆ MZ_DELETE_FILE

#define MZ_DELETE_FILE remove

◆ MZ_FCLOSE

#define MZ_FCLOSE fclose

◆ MZ_FFLUSH

#define MZ_FFLUSH fflush

◆ MZ_FILE_STAT

#define MZ_FILE_STAT stat

◆ MZ_FILE_STAT_STRUCT

#define MZ_FILE_STAT_STRUCT stat

◆ MZ_FOPEN

#define MZ_FOPEN	(		f,
			m )

Value:

fopen(f, m)

◆ MZ_FREAD

#define MZ_FREAD fread

◆ MZ_FREOPEN

#define MZ_FREOPEN	(	f,
		m,
		s )

Value:

freopen(f, m, s)

◆ MZ_FSEEK64

#define MZ_FSEEK64 fseeko

◆ MZ_FTELL64

#define MZ_FTELL64 ftello

◆ MZ_FWRITE

#define MZ_FWRITE fwrite

◆ MZ_SWAP_UINT32

#define MZ_SWAP_UINT32	(		a,
			b )

Value:

do                       \
{                        \
    mz_uint32 t = a;     \
    a = b;               \
    b = t;               \
}                        \
MZ_MACRO_END

◆ MZ_TOLOWER

#define MZ_TOLOWER ( c )

Value:

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

◆ MZ_WRITE_LE16

#define MZ_WRITE_LE16	(		p,
			v )

Value:

mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v))

◆ MZ_WRITE_LE32

#define MZ_WRITE_LE32	(		p,
			v )

Value:

mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))

◆ MZ_WRITE_LE64

#define MZ_WRITE_LE64	(		p,
			v )

Value:

mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v))

◆ MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE

#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3)

◆ MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE

#define MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2)

◆ MZ_ZIP_ARRAY_ELEMENT

#define MZ_ZIP_ARRAY_ELEMENT	(	array_ptr,
		element_type,
		index )

Value:

((element_type *)((array_ptr)->m_p))[index]

◆ MZ_ZIP_ARRAY_SET_ELEMENT_SIZE

#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE	(		array_ptr,
			element_size )

Value:

(array_ptr)->m_element_size = element_size

◆ 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); \
        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_CR_BEGIN

#define TINFL_CR_BEGIN

Value:

switch (r->m_state) \
{                   \
    case 0:

◆ TINFL_CR_FINISH

#define TINFL_CR_FINISH }

◆ TINFL_CR_RETURN

#define TINFL_CR_RETURN	(		state_index,
			result )

Value:

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 )

Value:

do                                               \
{                                                \
    for (;;)                                     \
    {                                            \
        TINFL_CR_RETURN(state_index, result);    \
    }                                            \
}                                                \
MZ_MACRO_END

◆ TINFL_GET_BITS

#define TINFL_GET_BITS	(	state_index,
		b,
		n )

Value:

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                                                                                                                                                           \
{                                                                                                                                                            \
    while (pIn_buf_cur >= pIn_buf_end)                                                                                                                       \
    {                                                                                                                                                        \
        TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \
    }                                                                                                                                                        \
    c = *pIn_buf_cur++;                                                                                                                                      \
}                                                                                                                                                            \
MZ_MACRO_END

◆ TINFL_HUFF_BITBUF_FILL

#define TINFL_HUFF_BITBUF_FILL	(	state_index,
		pLookUp,
		pTree )

Value:

do                                                               \
{                                                                \
    temp = pLookUp[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 = pTree[~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,
		pLookUp,
		pTree )

◆ TINFL_MEMCPY

#define TINFL_MEMCPY	(	d,
		s,
		l )

Value:

memcpy(d, s, l)

◆ TINFL_MEMSET

#define TINFL_MEMSET	(	p,
		c,
		l )

Value:

memset(p, c, l)

◆ TINFL_NEED_BITS

#define TINFL_NEED_BITS	(		state_index,
			n )

Value:

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 )

Value:

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

Typedef Documentation

◆ 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]

Enumeration Type Documentation

◆ 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_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG
MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG
MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE
MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE
MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID
MZ_ZIP_DATA_DESCRIPTOR_ID
MZ_ZIP_DATA_DESCRIPTER_SIZE64
MZ_ZIP_DATA_DESCRIPTER_SIZE32
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_LDH_BIT_FLAG_HAS_LOCATOR
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
MZ_ZIP64_ECDL_SIG_OFS
MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS
MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS
MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS
MZ_ZIP64_ECDH_SIG_OFS
MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS
MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS
MZ_ZIP64_ECDH_VERSION_NEEDED_OFS
MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS
MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS
MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS
MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS
MZ_ZIP64_ECDH_CDIR_SIZE_OFS
MZ_ZIP64_ECDH_CDIR_OFS_OFS
MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID
MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG
MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED
MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG
MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION
MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED
MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8

Function Documentation

◆ miniz_def_alloc_func()

MINIZ_EXPORT void * miniz_def_alloc_func	(	void *	opaque,
		size_t	items,
		size_t	size )

◆ miniz_def_free_func()

MINIZ_EXPORT void miniz_def_free_func	(	void *	opaque,
		void *	address )

◆ miniz_def_realloc_func()

MINIZ_EXPORT void * miniz_def_realloc_func	(	void *	opaque,
		void *	address,
		size_t	items,
		size_t	size )

◆ 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 mz_uint8 *	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_free()

void mz_free ( void * p )

◆ 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_inflateReset()

int mz_inflateReset ( mz_streamp pStream )

◆ mz_uncompress()

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

◆ mz_uncompress2()

int mz_uncompress2	(	unsigned char *	pDest,
		mz_ulong *	pDest_len,
		const unsigned char *	pSource,
		mz_ulong *	pSource_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_add_mem_to_archive_file_in_place_v2()

mz_bool mz_zip_add_mem_to_archive_file_in_place_v2	(	const char *	pZip_filename,
		const char *	pArchive_name,
		const void *	pBuf,
		size_t	buf_size,
		const void *	pComment,
		mz_uint16	comment_size,
		mz_uint	level_and_flags,
		mz_zip_error *	pErr )

◆ mz_zip_clear_last_error()

mz_zip_error mz_zip_clear_last_error ( mz_zip_archive * pZip )

◆ mz_zip_end()

mz_bool mz_zip_end ( mz_zip_archive * pZip )

◆ 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	flags )

◆ mz_zip_extract_archive_file_to_heap_v2()

void * mz_zip_extract_archive_file_to_heap_v2	(	const char *	pZip_filename,
		const char *	pArchive_name,
		const char *	pComment,
		size_t *	pSize,
		mz_uint	flags,
		mz_zip_error *	pErr )

◆ mz_zip_get_archive_file_start_offset()

mz_uint64 mz_zip_get_archive_file_start_offset ( mz_zip_archive * pZip )

◆ mz_zip_get_archive_size()

mz_uint64 mz_zip_get_archive_size ( mz_zip_archive * pZip )

◆ mz_zip_get_central_dir_size()

size_t mz_zip_get_central_dir_size ( mz_zip_archive * pZip )

◆ mz_zip_get_cfile()

MZ_FILE * mz_zip_get_cfile ( mz_zip_archive * pZip )

◆ mz_zip_get_error_string()

const char * mz_zip_get_error_string ( mz_zip_error mz_err )

◆ mz_zip_get_last_error()

mz_zip_error mz_zip_get_last_error ( mz_zip_archive * pZip )

◆ mz_zip_get_mode()

mz_zip_mode mz_zip_get_mode ( mz_zip_archive * pZip )

◆ mz_zip_get_type()

mz_zip_type mz_zip_get_type ( mz_zip_archive * pZip )

◆ mz_zip_is_zip64()

mz_bool mz_zip_is_zip64 ( mz_zip_archive * pZip )

◆ mz_zip_peek_last_error()

mz_zip_error mz_zip_peek_last_error ( mz_zip_archive * pZip )

◆ mz_zip_read_archive_data()

size_t mz_zip_read_archive_data	(	mz_zip_archive *	pZip,
		mz_uint64	file_ofs,
		void *	pBuf,
		size_t	n )

◆ mz_zip_reader_end()

mz_bool mz_zip_reader_end ( mz_zip_archive * pZip )

◆ mz_zip_reader_extract_file_iter_new()

mz_zip_reader_extract_iter_state * mz_zip_reader_extract_file_iter_new	(	mz_zip_archive *	pZip,
		const char *	pFilename,
		mz_uint	flags )

◆ 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_cfile()

mz_bool mz_zip_reader_extract_file_to_cfile	(	mz_zip_archive *	pZip,
		const char *	pArchive_filename,
		MZ_FILE *	pFile,
		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_iter_free()

mz_bool mz_zip_reader_extract_iter_free ( mz_zip_reader_extract_iter_state * pState )

◆ mz_zip_reader_extract_iter_new()

mz_zip_reader_extract_iter_state * mz_zip_reader_extract_iter_new	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		mz_uint	flags )

◆ mz_zip_reader_extract_iter_read()

size_t mz_zip_reader_extract_iter_read	(	mz_zip_reader_extract_iter_state *	pState,
		void *	pvBuf,
		size_t	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_cfile()

mz_bool mz_zip_reader_extract_to_cfile	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		MZ_FILE *	pFile,
		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_uint	flags )

◆ mz_zip_reader_init_cfile()

mz_bool mz_zip_reader_init_cfile	(	mz_zip_archive *	pZip,
		MZ_FILE *	pFile,
		mz_uint64	archive_size,
		mz_uint	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_file_v2()

mz_bool mz_zip_reader_init_file_v2	(	mz_zip_archive *	pZip,
		const char *	pFilename,
		mz_uint	flags,
		mz_uint64	file_start_ofs,
		mz_uint64	archive_size )

◆ mz_zip_reader_init_mem()

mz_bool mz_zip_reader_init_mem	(	mz_zip_archive *	pZip,
		const void *	pMem,
		size_t	size,
		mz_uint	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_is_file_supported()

mz_bool mz_zip_reader_is_file_supported	(	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_reader_locate_file_v2()

mz_bool mz_zip_reader_locate_file_v2	(	mz_zip_archive *	pZip,
		const char *	pName,
		const char *	pComment,
		mz_uint	flags,
		mz_uint32 *	pIndex )

◆ mz_zip_set_last_error()

mz_zip_error mz_zip_set_last_error	(	mz_zip_archive *	pZip,
		mz_zip_error	err_num )

◆ mz_zip_validate_archive()

mz_bool mz_zip_validate_archive	(	mz_zip_archive *	pZip,
		mz_uint	flags )

◆ mz_zip_validate_file()

mz_bool mz_zip_validate_file	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		mz_uint	flags )

◆ mz_zip_validate_file_archive()

mz_bool mz_zip_validate_file_archive	(	const char *	pFilename,
		mz_uint	flags,
		mz_zip_error *	pErr )

◆ mz_zip_validate_mem_archive()

mz_bool mz_zip_validate_mem_archive	(	const void *	pMem,
		size_t	size,
		mz_uint	flags,
		mz_zip_error *	pErr )

◆ mz_zip_writer_add_cfile()

mz_bool mz_zip_writer_add_cfile	(	mz_zip_archive *	pZip,
		const char *	pArchive_name,
		MZ_FILE *	pSrc_file,
		mz_uint64	max_size,
		const MZ_TIME_T *	pFile_time,
		const void *	pComment,
		mz_uint16	comment_size,
		mz_uint	level_and_flags,
		const char *	user_extra_data,
		mz_uint	user_extra_data_len,
		const char *	user_extra_data_central,
		mz_uint	user_extra_data_central_len )

◆ 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	src_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_add_mem_ex_v2()

mz_bool mz_zip_writer_add_mem_ex_v2	(	mz_zip_archive *	pZip,
		const char *	pArchive_name,
		const void *	pBuf,
		size_t	buf_size,
		const void *	pComment,
		mz_uint16	comment_size,
		mz_uint	level_and_flags,
		mz_uint64	uncomp_size,
		mz_uint32	uncomp_crc32,
		MZ_TIME_T *	last_modified,
		const char *	user_extra_data,
		mz_uint	user_extra_data_len,
		const char *	user_extra_data_central,
		mz_uint	user_extra_data_central_len )

◆ mz_zip_writer_add_read_buf_callback()

mz_bool mz_zip_writer_add_read_buf_callback	(	mz_zip_archive *	pZip,
		const char *	pArchive_name,
		mz_file_read_func	read_callback,
		void *	callback_opaque,
		mz_uint64	max_size,
		const MZ_TIME_T *	pFile_time,
		const void *	pComment,
		mz_uint16	comment_size,
		mz_uint	level_and_flags,
		const char *	user_extra_data,
		mz_uint	user_extra_data_len,
		const char *	user_extra_data_central,
		mz_uint	user_extra_data_central_len )

◆ 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 **	ppBuf,
		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_cfile()

mz_bool mz_zip_writer_init_cfile	(	mz_zip_archive *	pZip,
		MZ_FILE *	pFile,
		mz_uint	flags )

◆ 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_file_v2()

mz_bool mz_zip_writer_init_file_v2	(	mz_zip_archive *	pZip,
		const char *	pFilename,
		mz_uint64	size_to_reserve_at_beginning,
		mz_uint	flags )

◆ 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_from_reader_v2()

mz_bool mz_zip_writer_init_from_reader_v2	(	mz_zip_archive *	pZip,
		const char *	pFilename,
		mz_uint	flags )

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

◆ mz_zip_writer_init_heap_v2()

mz_bool mz_zip_writer_init_heap_v2	(	mz_zip_archive *	pZip,
		size_t	size_to_reserve_at_beginning,
		size_t	initial_allocation_size,
		mz_uint	flags )

◆ mz_zip_writer_init_v2()

mz_bool mz_zip_writer_init_v2	(	mz_zip_archive *	pZip,
		mz_uint64	existing_size,
		mz_uint	flags )

◆ mz_zip_zero_struct()

void mz_zip_zero_struct ( mz_zip_archive * pZip )

◆ 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_compressor_alloc()

tdefl_compressor * tdefl_compressor_alloc ( void )

◆ tdefl_compressor_free()

void tdefl_compressor_free ( tdefl_compressor * pComp )

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

◆ tdefl_write_image_to_png_file_in_memory()

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

◆ tdefl_write_image_to_png_file_in_memory_ex()

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 )

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

◆ tinfl_decompressor_alloc()

tinfl_decompressor * tinfl_decompressor_alloc ( void )

◆ tinfl_decompressor_free()

void tinfl_decompressor_free ( tinfl_decompressor * pDecomp )

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ MZ_DELETE_FILE

◆ MZ_FCLOSE

◆ MZ_FFLUSH

◆ MZ_FILE_STAT

◆ MZ_FILE_STAT_STRUCT

◆ MZ_FOPEN

◆ MZ_FREAD

◆ MZ_FREOPEN

◆ MZ_FSEEK64

◆ MZ_FTELL64

◆ MZ_FWRITE

◆ MZ_SWAP_UINT32

◆ MZ_TOLOWER

◆ MZ_WRITE_LE16

◆ MZ_WRITE_LE32

◆ MZ_WRITE_LE64

◆ MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE

◆ MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE

◆ MZ_ZIP_ARRAY_ELEMENT

◆ MZ_ZIP_ARRAY_SET_ELEMENT_SIZE

◆ TDEFL_PROBE

◆ TDEFL_PUT_BITS

◆ TDEFL_RLE_PREV_CODE_SIZE

◆ TDEFL_RLE_ZERO_CODE_SIZE

◆ TINFL_CR_BEGIN

◆ TINFL_CR_FINISH

◆ TINFL_CR_RETURN

◆ TINFL_CR_RETURN_FOREVER

◆ TINFL_GET_BITS

◆ TINFL_GET_BYTE

◆ TINFL_HUFF_BITBUF_FILL

◆ TINFL_HUFF_DECODE

◆ TINFL_MEMCPY

◆ TINFL_MEMSET

◆ TINFL_NEED_BITS

◆ TINFL_SKIP_BITS

Typedef Documentation

◆ mz_validate_uint16

◆ mz_validate_uint32

◆ mz_validate_uint64

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ miniz_def_alloc_func()

◆ miniz_def_free_func()

◆ miniz_def_realloc_func()

◆ mz_adler32()

◆ mz_compress()

◆ mz_compress2()

◆ mz_compressBound()

◆ mz_crc32()

◆ mz_deflate()

◆ mz_deflateBound()

◆ mz_deflateEnd()

◆ mz_deflateInit()

◆ mz_deflateInit2()

◆ mz_deflateReset()

◆ mz_error()

◆ mz_free()

◆ mz_inflate()

◆ mz_inflateEnd()

◆ mz_inflateInit()

◆ mz_inflateInit2()

◆ mz_inflateReset()

◆ mz_uncompress()

◆ mz_uncompress2()

◆ mz_version()

◆ mz_zip_add_mem_to_archive_file_in_place()

◆ mz_zip_add_mem_to_archive_file_in_place_v2()

◆ mz_zip_clear_last_error()

◆ mz_zip_end()

◆ mz_zip_extract_archive_file_to_heap()

◆ mz_zip_extract_archive_file_to_heap_v2()