Assimp  v4.1. (December 2018)
miniz.h File Reference

Classes

struct  inflate_state
 
struct  mz_stream
 
struct  mz_zip_archive
 
struct  mz_zip_archive_file_stat
 
struct  mz_zip_array
 
struct  mz_zip_internal_state
 
struct  mz_zip_writer_add_state
 
struct  tdefl_compressor
 
struct  tdefl_output_buffer
 
struct  tdefl_sym_freq
 
struct  tinfl_decompressor
 
struct  tinfl_huff_table
 

Macros

#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
 
#define TDEFL_PUT_BITS(b, l)
 
#define TDEFL_RLE_PREV_CODE_SIZE()
 
#define TDEFL_RLE_ZERO_CODE_SIZE()
 
#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)
 
#define TINFL_HUFF_BITBUF_FILL(state_index, pHuff)
 
#define TINFL_HUFF_DECODE(state_index, sym, pHuff)
 
#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
 

Typedefs

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 mz_streammz_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 mz_bool(* tdefl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)
 
typedef mz_uint32 tinfl_bit_buf_t
 
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
 

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  { 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_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_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
}
 
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  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  tdefl_flush { TDEFL_NO_FLUSH = 0, TDEFL_SYNC_FLUSH = 2, TDEFL_FULL_FLUSH = 3, TDEFL_FINISH = 4 }
 
enum  tdefl_status { TDEFL_STATUS_BAD_PARAM = -2, TDEFL_STATUS_PUT_BUF_FAILED = -1, TDEFL_STATUS_OKAY = 0, TDEFL_STATUS_DONE = 1 }
 
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
}
 

Functions

static void * def_alloc_func (void *opaque, size_t items, size_t size)
 
static void def_free_func (void *opaque, void *address)
 
static void * def_realloc_func (void *opaque, void *address, size_t items, size_t size)
 
mz_ulong mz_adler32 (mz_ulong adler, const unsigned char *ptr, size_t buf_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)
 
mz_ulong mz_crc32 (mz_ulong crc, const unsigned char *ptr, size_t buf_len)
 
int mz_deflate (mz_streamp pStream, int flush)
 
mz_ulong mz_deflateBound (mz_streamp pStream, mz_ulong source_len)
 
int mz_deflateEnd (mz_streamp pStream)
 
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)
 
const char * mz_error (int err)
 
void mz_free (void *p)
 
int mz_inflate (mz_streamp pStream, int flush)
 
int mz_inflateEnd (mz_streamp pStream)
 
int mz_inflateInit (mz_streamp pStream)
 
int mz_inflateInit2 (mz_streamp pStream, int window_bits)
 
int mz_uncompress (unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
 
const char * mz_version (void)
 
static void mz_write_le16 (mz_uint8 *p, mz_uint16 v)
 
static void mz_write_le32 (mz_uint8 *p, mz_uint32 v)
 
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)
 
static MZ_FORCEINLINE void mz_zip_array_clear (mz_zip_archive *pZip, mz_zip_array *pArray)
 
static mz_bool mz_zip_array_ensure_capacity (mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
 
static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room (mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)
 
static MZ_FORCEINLINE mz_bool mz_zip_array_push_back (mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)
 
static MZ_FORCEINLINE mz_bool mz_zip_array_reserve (mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)
 
static MZ_FORCEINLINE mz_bool mz_zip_array_resize (mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)
 
static time_t mz_zip_dos_to_time_t (int dos_time, int dos_date)
 
void * mz_zip_extract_archive_file_to_heap (const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint zip_flags)
 
static size_t mz_zip_file_read_func (void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
 
static size_t mz_zip_file_write_callback (void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)
 
static size_t mz_zip_file_write_func (void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
 
static mz_bool mz_zip_get_file_modified_time (const char *pFilename, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
 
static size_t mz_zip_heap_write_func (void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
 
static size_t mz_zip_mem_read_func (void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
 
mz_bool mz_zip_reader_end (mz_zip_archive *pZip)
 
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_file_to_file (mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, 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_file_to_mem (mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags)
 
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_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_to_file (mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
 
void * mz_zip_reader_extract_to_heap (mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
 
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_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_file_stat (mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
 
static MZ_FORCEINLINE int mz_zip_reader_filename_compare (const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, const char *pR, mz_uint r_len)
 
static MZ_FORCEINLINE mz_bool mz_zip_reader_filename_less (const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)
 
static MZ_FORCEINLINE const mz_uint8mz_zip_reader_get_cdh (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)
 
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)
 
mz_bool mz_zip_reader_init_file (mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)
 
static mz_bool mz_zip_reader_init_internal (mz_zip_archive *pZip, 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_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)
 
int mz_zip_reader_locate_file (mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)
 
static int mz_zip_reader_locate_file_binary_search (mz_zip_archive *pZip, const char *pFilename)
 
static mz_bool mz_zip_reader_read_central_dir (mz_zip_archive *pZip, mz_uint32 flags)
 
static void mz_zip_reader_sort_central_dir_offsets_by_filename (mz_zip_archive *pZip)
 
static MZ_FORCEINLINE mz_bool mz_zip_reader_string_equal (const char *pA, const char *pB, mz_uint len, mz_uint flags)
 
static mz_bool mz_zip_set_file_times (const char *pFilename, time_t access_time, time_t modified_time)
 
static void mz_zip_time_to_dos_time (time_t time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
 
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_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)
 
static mz_bool mz_zip_writer_add_put_buf_callback (const void *pBuf, int len, void *pUser)
 
static mz_bool mz_zip_writer_add_to_central_dir (mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size, const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
 
static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment (mz_zip_archive *pZip)
 
static mz_bool mz_zip_writer_create_central_dir_header (mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
 
static mz_bool mz_zip_writer_create_local_dir_header (mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)
 
mz_bool mz_zip_writer_end (mz_zip_archive *pZip)
 
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_init (mz_zip_archive *pZip, mz_uint64 existing_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_init_heap (mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)
 
static mz_bool mz_zip_writer_validate_archive_name (const char *pArchive_name)
 
static mz_bool mz_zip_writer_write_zeros (mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
 
static void tdefl_calculate_minimum_redundancy (tdefl_sym_freq *A, int n)
 
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)
 
static mz_bool tdefl_compress_block (tdefl_compressor *d, mz_bool static_block)
 
tdefl_status tdefl_compress_buffer (tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
 
static mz_bool tdefl_compress_lz_codes (tdefl_compressor *d)
 
void * tdefl_compress_mem_to_heap (const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
 
size_t tdefl_compress_mem_to_mem (void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
 
mz_bool tdefl_compress_mem_to_output (const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
 
static mz_bool tdefl_compress_normal (tdefl_compressor *d)
 
mz_uint tdefl_create_comp_flags_from_zip_params (int level, int window_bits, int strategy)
 
static MZ_FORCEINLINE void tdefl_find_match (tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
 
static int tdefl_flush_block (tdefl_compressor *d, int flush)
 
static tdefl_status tdefl_flush_output_buffer (tdefl_compressor *d)
 
mz_uint32 tdefl_get_adler32 (tdefl_compressor *d)
 
tdefl_status tdefl_get_prev_return_status (tdefl_compressor *d)
 
static void tdefl_huffman_enforce_max_code_size (int *pNum_codes, int code_list_len, int max_code_size)
 
tdefl_status tdefl_init (tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
 
static void tdefl_optimize_huffman_table (tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)
 
static mz_bool tdefl_output_buffer_putter (const void *pBuf, int len, void *pUser)
 
static tdefl_sym_freqtdefl_radix_sort_syms (mz_uint num_syms, tdefl_sym_freq *pSyms0, tdefl_sym_freq *pSyms1)
 
static MZ_FORCEINLINE void tdefl_record_literal (tdefl_compressor *d, mz_uint8 lit)
 
static MZ_FORCEINLINE void tdefl_record_match (tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
 
static void tdefl_start_dynamic_block (tdefl_compressor *d)
 
static void tdefl_start_static_block (tdefl_compressor *d)
 
void * tdefl_write_image_to_png_file_in_memory (const void *pImage, int w, int h, int num_chans, size_t *pLen_out)
 
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_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)
 
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)
 
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)
 

Variables

static const mz_uint mz_bitmasks [17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF }
 
static const mz_uint8 s_tdefl_large_dist_extra [128]
 
static const mz_uint8 s_tdefl_large_dist_sym [128]
 
static const mz_uint8 s_tdefl_len_extra [256]
 
static const mz_uint16 s_tdefl_len_sym [256]
 
static const mz_uint s_tdefl_num_probes [11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 }
 
static mz_uint8 s_tdefl_packed_code_size_syms_swizzle [] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }
 
static const mz_uint8 s_tdefl_small_dist_extra [512]
 
static const mz_uint8 s_tdefl_small_dist_sym [512]
 

Macro Definition Documentation

◆ adler32

#define adler32   mz_adler32

◆ alloc_func

#define alloc_func   mz_alloc_func

◆ compress

#define compress   mz_compress

◆ compress2

#define compress2   mz_compress2

◆ compressBound

#define compressBound   mz_compressBound

◆ crc32

#define crc32   mz_crc32

◆ deflate

#define deflate   mz_deflate

◆ deflateBound

#define deflateBound   mz_deflateBound

◆ deflateEnd

#define deflateEnd   mz_deflateEnd

◆ deflateInit

#define deflateInit   mz_deflateInit

◆ deflateInit2

#define deflateInit2   mz_deflateInit2

◆ deflateReset

#define deflateReset   mz_deflateReset

◆ free_func

#define free_func   mz_free_func

◆ inflate

#define inflate   mz_inflate

◆ inflateEnd

#define inflateEnd   mz_inflateEnd

◆ inflateInit

#define inflateInit   mz_inflateInit

◆ inflateInit2

#define inflateInit2   mz_inflateInit2

◆ internal_state

#define internal_state   mz_internal_state

◆ MAX_MEM_LEVEL

#define MAX_MEM_LEVEL   9

◆ MAX_WBITS

#define MAX_WBITS   15

◆ MINIZ_LITTLE_ENDIAN

#define MINIZ_LITTLE_ENDIAN   1

◆ MZ_ADLER32_INIT

#define MZ_ADLER32_INIT   (1)

◆ MZ_ASSERT

#define MZ_ASSERT (   x)    assert(x)

◆ MZ_CLEAR_OBJ

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

◆ MZ_CRC32_INIT

#define MZ_CRC32_INIT   (0)

◆ MZ_DEFAULT_WINDOW_BITS

#define MZ_DEFAULT_WINDOW_BITS   15

◆ MZ_DEFLATED

#define MZ_DEFLATED   8

◆ MZ_DELETE_FILE

#define MZ_DELETE_FILE   remove

◆ MZ_FALSE

#define MZ_FALSE   (0)

◆ MZ_FCLOSE

#define MZ_FCLOSE   fclose

◆ MZ_FFLUSH

#define MZ_FFLUSH   fflush

◆ MZ_FILE

#define MZ_FILE   FILE

◆ MZ_FILE_STAT

#define MZ_FILE_STAT   stat

◆ MZ_FILE_STAT_STRUCT

#define MZ_FILE_STAT_STRUCT   stat

◆ MZ_FOPEN

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

◆ MZ_FORCEINLINE

#define MZ_FORCEINLINE   inline

◆ MZ_FREAD

#define MZ_FREAD   fread

◆ MZ_FREE

#define MZ_FREE (   x)    free(x)

◆ MZ_FREOPEN

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

◆ MZ_FSEEK64

#define MZ_FSEEK64   fseeko

◆ MZ_FTELL64

#define MZ_FTELL64   ftello

◆ MZ_FWRITE

#define MZ_FWRITE   fwrite

◆ MZ_MACRO_END

#define MZ_MACRO_END   while (0)

◆ MZ_MALLOC

#define MZ_MALLOC (   x)    malloc(x)

◆ MZ_MAX

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

◆ MZ_MIN

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

◆ MZ_READ_LE16

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

◆ MZ_READ_LE32

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

◆ MZ_REALLOC

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

◆ MZ_SWAP_UINT32

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

◆ MZ_TOLOWER

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

◆ MZ_TRUE

#define MZ_TRUE   (1)

◆ MZ_VER_MAJOR

#define MZ_VER_MAJOR   9

◆ MZ_VER_MINOR

#define MZ_VER_MINOR   1

◆ MZ_VER_REVISION

#define MZ_VER_REVISION   15

◆ MZ_VER_SUBREVISION

#define MZ_VER_SUBREVISION   0

◆ MZ_VERNUM

#define MZ_VERNUM   0x91F0

◆ MZ_VERSION

#define MZ_VERSION   "9.1.15"

◆ MZ_WRITE_LE16

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

◆ MZ_WRITE_LE32

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

◆ MZ_ZIP_ARRAY_ELEMENT

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

◆ MZ_ZIP_ARRAY_SET_ELEMENT_SIZE

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

◆ TDEFL_LESS_MEMORY

#define TDEFL_LESS_MEMORY   0

◆ TDEFL_PROBE

#define TDEFL_PROBE
Value:
next_probe_pos = d->m_next[probe_pos]; \
if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) return; \
probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) break;
Definition: miniz.h:849
unsigned short mz_uint16
Definition: miniz.h:479

◆ TDEFL_PUT_BITS

#define TDEFL_PUT_BITS (   b,
 
)
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; \
} \
#define MZ_ASSERT(x)
Definition: miniz.h:947
unsigned int mz_uint
Definition: miniz.h:481
unsigned char mz_uint8
Definition: miniz.h:477
#define MZ_MACRO_END
Definition: miniz.h:493

◆ 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; } }
unsigned short mz_uint16
Definition: miniz.h:479
unsigned char mz_uint8
Definition: miniz.h:477

◆ 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; } }
unsigned short mz_uint16
Definition: miniz.h:479
unsigned char mz_uint8
Definition: miniz.h:477

◆ TINFL_BITBUF_SIZE

#define TINFL_BITBUF_SIZE   (32)

◆ TINFL_CR_BEGIN

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

◆ TINFL_CR_FINISH

#define TINFL_CR_FINISH   }

◆ TINFL_CR_RETURN

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

◆ TINFL_CR_RETURN_FOREVER

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

◆ TINFL_DECOMPRESS_MEM_TO_MEM_FAILED

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

◆ tinfl_get_adler32

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

◆ TINFL_GET_BITS

#define TINFL_GET_BITS (   state_index,
  b,
 
)    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,
 
)
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
Definition: miniz.h:736
Definition: miniz.h:699
#define MZ_MACRO_END
Definition: miniz.h:493

◆ TINFL_HUFF_BITBUF_FILL

#define TINFL_HUFF_BITBUF_FILL (   state_index,
  pHuff 
)
Value:
do { \
temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
if (temp >= 0) { \
code_len = temp >> 9; \
if ((code_len) && (num_bits >= code_len)) \
break; \
} else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \
code_len = TINFL_FAST_LOOKUP_BITS; \
do { \
temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \
} while ((temp < 0) && (num_bits >= (code_len + 1))); if (temp >= 0) break; \
} TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; \
} while (num_bits < 15);
Definition: miniz.h:752
mz_uint32 tinfl_bit_buf_t
Definition: miniz.h:769
#define TINFL_GET_BYTE(state_index, c)
Definition: miniz.h:1378
Definition: miniz.h:752

◆ TINFL_HUFF_DECODE

#define TINFL_HUFF_DECODE (   state_index,
  sym,
  pHuff 
)
Value:
do { \
int temp; mz_uint code_len, c; \
if (num_bits < 15) { \
if ((pIn_buf_end - pIn_buf_cur) < 2) { \
TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \
} else { \
bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); pIn_buf_cur += 2; num_bits += 16; \
} \
} \
if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \
code_len = temp >> 9, temp &= 511; \
else { \
code_len = TINFL_FAST_LOOKUP_BITS; do { temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; } while (temp < 0); \
} sym = temp; bit_buf >>= code_len; num_bits -= code_len; } MZ_MACRO_END
Definition: miniz.h:752
mz_uint32 tinfl_bit_buf_t
Definition: miniz.h:769
unsigned int mz_uint
Definition: miniz.h:481
#define MZ_MACRO_END
Definition: miniz.h:493
Definition: miniz.h:752

◆ tinfl_init

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

◆ TINFL_LZ_DICT_SIZE

#define TINFL_LZ_DICT_SIZE   32768

◆ TINFL_MEMCPY

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

◆ TINFL_MEMSET

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

◆ TINFL_NEED_BITS

#define TINFL_NEED_BITS (   state_index,
 
)    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,
 
)    do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END

◆ uncompress

#define uncompress   mz_uncompress

◆ Z_BEST_COMPRESSION

#define Z_BEST_COMPRESSION   MZ_BEST_COMPRESSION

◆ Z_BEST_SPEED

#define Z_BEST_SPEED   MZ_BEST_SPEED

◆ Z_BLOCK

#define Z_BLOCK   MZ_BLOCK

◆ Z_BUF_ERROR

#define Z_BUF_ERROR   MZ_BUF_ERROR

◆ Z_DATA_ERROR

#define Z_DATA_ERROR   MZ_DATA_ERROR

◆ Z_DEFAULT_COMPRESSION

#define Z_DEFAULT_COMPRESSION   MZ_DEFAULT_COMPRESSION

◆ Z_DEFAULT_STRATEGY

#define Z_DEFAULT_STRATEGY   MZ_DEFAULT_STRATEGY

◆ Z_DEFAULT_WINDOW_BITS

#define Z_DEFAULT_WINDOW_BITS   MZ_DEFAULT_WINDOW_BITS

◆ Z_DEFLATED

#define Z_DEFLATED   MZ_DEFLATED

◆ Z_ERRNO

#define Z_ERRNO   MZ_ERRNO

◆ Z_FILTERED

#define Z_FILTERED   MZ_FILTERED

◆ Z_FINISH

#define Z_FINISH   MZ_FINISH

◆ Z_FIXED

#define Z_FIXED   MZ_FIXED

◆ Z_FULL_FLUSH

#define Z_FULL_FLUSH   MZ_FULL_FLUSH

◆ Z_HUFFMAN_ONLY

#define Z_HUFFMAN_ONLY   MZ_HUFFMAN_ONLY

◆ Z_MEM_ERROR

#define Z_MEM_ERROR   MZ_MEM_ERROR

◆ Z_NEED_DICT

#define Z_NEED_DICT   MZ_NEED_DICT

◆ Z_NO_COMPRESSION

#define Z_NO_COMPRESSION   MZ_NO_COMPRESSION

◆ Z_NO_FLUSH

#define Z_NO_FLUSH   MZ_NO_FLUSH

◆ Z_NULL

#define Z_NULL   0

◆ Z_OK

#define Z_OK   MZ_OK

◆ Z_PARAM_ERROR

#define Z_PARAM_ERROR   MZ_PARAM_ERROR

◆ Z_PARTIAL_FLUSH

#define Z_PARTIAL_FLUSH   MZ_PARTIAL_FLUSH

◆ Z_RLE

#define Z_RLE   MZ_RLE

◆ z_stream

#define z_stream   mz_stream

◆ Z_STREAM_END

#define Z_STREAM_END   MZ_STREAM_END

◆ Z_STREAM_ERROR

#define Z_STREAM_ERROR   MZ_STREAM_ERROR

◆ Z_SYNC_FLUSH

#define Z_SYNC_FLUSH   MZ_SYNC_FLUSH

◆ Z_VERSION_ERROR

#define Z_VERSION_ERROR   MZ_VERSION_ERROR

◆ zError

#define zError   mz_error

◆ ZLIB_VER_MAJOR

#define ZLIB_VER_MAJOR   MZ_VER_MAJOR

◆ ZLIB_VER_MINOR

#define ZLIB_VER_MINOR   MZ_VER_MINOR

◆ ZLIB_VER_REVISION

#define ZLIB_VER_REVISION   MZ_VER_REVISION

◆ ZLIB_VER_SUBREVISION

#define ZLIB_VER_SUBREVISION   MZ_VER_SUBREVISION

◆ ZLIB_VERNUM

#define ZLIB_VERNUM   MZ_VERNUM

◆ ZLIB_VERSION

#define ZLIB_VERSION   MZ_VERSION

◆ zlib_version

#define zlib_version   mz_version()

◆ zlibVersion

#define zlibVersion   mz_version

Typedef Documentation

◆ Byte

typedef unsigned char Byte

◆ Bytef

typedef Byte Bytef

◆ charf

typedef char charf

◆ intf

typedef int intf

◆ mz_alloc_func

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

◆ mz_bool

typedef int mz_bool

◆ mz_file_read_func

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

◆ mz_file_write_func

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

◆ mz_free_func

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

◆ mz_int16

typedef signed short mz_int16

◆ mz_int64

typedef long long mz_int64

◆ mz_realloc_func

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

◆ mz_streamp

◆ mz_uint

typedef unsigned int mz_uint

◆ mz_uint16

typedef unsigned short mz_uint16

◆ mz_uint32

typedef unsigned int mz_uint32

◆ mz_uint64

typedef unsigned long long mz_uint64

◆ mz_uint8

typedef unsigned char mz_uint8

◆ mz_ulong

typedef unsigned long mz_ulong

◆ mz_validate_uint16

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

◆ mz_validate_uint32

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

◆ mz_validate_uint64

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

◆ tdefl_put_buf_func_ptr

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

◆ tinfl_bit_buf_t

◆ tinfl_put_buf_func_ptr

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

◆ uInt

typedef unsigned int uInt

◆ uIntf

typedef uInt uIntf

◆ uLong

typedef mz_ulong uLong

◆ uLongf

typedef uLong uLongf

◆ voidp

typedef void* voidp

◆ voidpc

typedef void* const voidpc

◆ voidpf

typedef void* voidpf

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
MZ_DEFAULT_STRATEGY 
MZ_FILTERED 
MZ_HUFFMAN_ONLY 
MZ_RLE 
MZ_FIXED 

◆ anonymous enum

anonymous enum
Enumerator
MZ_NO_FLUSH 
MZ_PARTIAL_FLUSH 
MZ_SYNC_FLUSH 
MZ_FULL_FLUSH 
MZ_FINISH 
MZ_BLOCK 

◆ anonymous enum

anonymous enum
Enumerator
MZ_OK 
MZ_STREAM_END 
MZ_NEED_DICT 
MZ_ERRNO 
MZ_STREAM_ERROR 
MZ_DATA_ERROR 
MZ_MEM_ERROR 
MZ_BUF_ERROR 
MZ_VERSION_ERROR 
MZ_PARAM_ERROR 

◆ anonymous enum

anonymous enum
Enumerator
MZ_NO_COMPRESSION 
MZ_BEST_SPEED 
MZ_BEST_COMPRESSION 
MZ_UBER_COMPRESSION 
MZ_DEFAULT_LEVEL 
MZ_DEFAULT_COMPRESSION 

◆ anonymous enum

anonymous enum
Enumerator
MZ_ZIP_MAX_IO_BUF_SIZE 
MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE 
MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE 

◆ anonymous enum

anonymous enum
Enumerator
TINFL_FLAG_PARSE_ZLIB_HEADER 
TINFL_FLAG_HAS_MORE_INPUT 
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF 
TINFL_FLAG_COMPUTE_ADLER32 

◆ anonymous enum

anonymous enum
Enumerator
TINFL_MAX_HUFF_TABLES 
TINFL_MAX_HUFF_SYMBOLS_0 
TINFL_MAX_HUFF_SYMBOLS_1 
TINFL_MAX_HUFF_SYMBOLS_2 
TINFL_FAST_LOOKUP_BITS 
TINFL_FAST_LOOKUP_SIZE 

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_HUFFMAN_ONLY 
TDEFL_DEFAULT_MAX_PROBES 
TDEFL_MAX_PROBES_MASK 

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_WRITE_ZLIB_HEADER 
TDEFL_COMPUTE_ADLER32 
TDEFL_GREEDY_PARSING_FLAG 
TDEFL_NONDETERMINISTIC_PARSING_FLAG 
TDEFL_RLE_MATCHES 
TDEFL_FILTER_MATCHES 
TDEFL_FORCE_ALL_STATIC_BLOCKS 
TDEFL_FORCE_ALL_RAW_BLOCKS 

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_MAX_HUFF_TABLES 
TDEFL_MAX_HUFF_SYMBOLS_0 
TDEFL_MAX_HUFF_SYMBOLS_1 
TDEFL_MAX_HUFF_SYMBOLS_2 
TDEFL_LZ_DICT_SIZE 
TDEFL_LZ_DICT_SIZE_MASK 
TDEFL_MIN_MATCH_LEN 
TDEFL_MAX_MATCH_LEN 

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_LZ_CODE_BUF_SIZE 
TDEFL_OUT_BUF_SIZE 
TDEFL_MAX_HUFF_SYMBOLS 
TDEFL_LZ_HASH_BITS 
TDEFL_LEVEL1_HASH_SIZE_MASK 
TDEFL_LZ_HASH_SHIFT 
TDEFL_LZ_HASH_SIZE 

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_MAX_SUPPORTED_HUFF_CODESIZE 

◆ anonymous enum

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

◆ mz_zip_flags

Enumerator
MZ_ZIP_FLAG_CASE_SENSITIVE 
MZ_ZIP_FLAG_IGNORE_PATH 
MZ_ZIP_FLAG_COMPRESSED_DATA 
MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY 

◆ mz_zip_mode

Enumerator
MZ_ZIP_MODE_INVALID 
MZ_ZIP_MODE_READING 
MZ_ZIP_MODE_WRITING 
MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED 

◆ tdefl_flush

Enumerator
TDEFL_NO_FLUSH 
TDEFL_SYNC_FLUSH 
TDEFL_FULL_FLUSH 
TDEFL_FINISH 

◆ tdefl_status

Enumerator
TDEFL_STATUS_BAD_PARAM 
TDEFL_STATUS_PUT_BUF_FAILED 
TDEFL_STATUS_OKAY 
TDEFL_STATUS_DONE 

◆ 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

◆ def_alloc_func()

static void* def_alloc_func ( void *  opaque,
size_t  items,
size_t  size 
)
static

◆ def_free_func()

static void def_free_func ( void *  opaque,
void *  address 
)
static

◆ def_realloc_func()

static void* def_realloc_func ( void *  opaque,
void *  address,
size_t  items,
size_t  size 
)
static

◆ mz_adler32()

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

◆ mz_compress()

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

◆ mz_compress2()

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

◆ mz_compressBound()

mz_ulong mz_compressBound ( mz_ulong  source_len)

◆ mz_crc32()

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

◆ mz_deflate()

int mz_deflate ( mz_streamp  pStream,
int  flush 
)

◆ mz_deflateBound()

mz_ulong mz_deflateBound ( mz_streamp  pStream,
mz_ulong  source_len 
)

◆ mz_deflateEnd()

int mz_deflateEnd ( mz_streamp  pStream)

◆ mz_deflateInit()

int mz_deflateInit ( mz_streamp  pStream,
int  level 
)

◆ mz_deflateInit2()

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

◆ mz_deflateReset()

int mz_deflateReset ( mz_streamp  pStream)

◆ mz_error()

const char * mz_error ( int  err)

◆ mz_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_uncompress()

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

◆ mz_version()

const char * mz_version ( void  )

◆ mz_write_le16()

static void mz_write_le16 ( mz_uint8 p,
mz_uint16  v 
)
static

◆ mz_write_le32()

static void mz_write_le32 ( mz_uint8 p,
mz_uint32  v 
)
static

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

static MZ_FORCEINLINE void mz_zip_array_clear ( mz_zip_archive pZip,
mz_zip_array pArray 
)
static

◆ mz_zip_array_ensure_capacity()

static mz_bool mz_zip_array_ensure_capacity ( mz_zip_archive pZip,
mz_zip_array pArray,
size_t  min_new_capacity,
mz_uint  growing 
)
static

◆ mz_zip_array_ensure_room()

static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room ( mz_zip_archive pZip,
mz_zip_array pArray,
size_t  n 
)
static

◆ mz_zip_array_push_back()

static MZ_FORCEINLINE mz_bool mz_zip_array_push_back ( mz_zip_archive pZip,
mz_zip_array pArray,
const void *  pElements,
size_t  n 
)
static

◆ mz_zip_array_reserve()

static MZ_FORCEINLINE mz_bool mz_zip_array_reserve ( mz_zip_archive pZip,
mz_zip_array pArray,
size_t  new_capacity,
mz_uint  growing 
)
static

◆ mz_zip_array_resize()

static MZ_FORCEINLINE mz_bool mz_zip_array_resize ( mz_zip_archive pZip,
mz_zip_array pArray,
size_t  new_size,
mz_uint  growing 
)
static

◆ mz_zip_dos_to_time_t()

static time_t mz_zip_dos_to_time_t ( int  dos_time,
int  dos_date 
)
static

◆ mz_zip_extract_archive_file_to_heap()

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

◆ mz_zip_file_read_func()

static size_t mz_zip_file_read_func ( void *  pOpaque,
mz_uint64  file_ofs,
void *  pBuf,
size_t  n 
)
static

◆ mz_zip_file_write_callback()

static size_t mz_zip_file_write_callback ( void *  pOpaque,
mz_uint64  ofs,
const void *  pBuf,
size_t  n 
)
static

◆ mz_zip_file_write_func()

static size_t mz_zip_file_write_func ( void *  pOpaque,
mz_uint64  file_ofs,
const void *  pBuf,
size_t  n 
)
static

◆ mz_zip_get_file_modified_time()

static mz_bool mz_zip_get_file_modified_time ( const char *  pFilename,
mz_uint16 pDOS_time,
mz_uint16 pDOS_date 
)
static

◆ mz_zip_heap_write_func()

static size_t mz_zip_heap_write_func ( void *  pOpaque,
mz_uint64  file_ofs,
const void *  pBuf,
size_t  n 
)
static

◆ mz_zip_mem_read_func()

static size_t mz_zip_mem_read_func ( void *  pOpaque,
mz_uint64  file_ofs,
void *  pBuf,
size_t  n 
)
static

◆ mz_zip_reader_end()

mz_bool mz_zip_reader_end ( mz_zip_archive pZip)

◆ mz_zip_reader_extract_file_to_callback()

mz_bool mz_zip_reader_extract_file_to_callback ( mz_zip_archive pZip,
const char *  pFilename,
mz_file_write_func  pCallback,
void *  pOpaque,
mz_uint  flags 
)

◆ mz_zip_reader_extract_file_to_file()

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

◆ mz_zip_reader_extract_file_to_heap()

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

◆ mz_zip_reader_extract_file_to_mem()

mz_bool mz_zip_reader_extract_file_to_mem ( mz_zip_archive pZip,
const char *  pFilename,
void *  pBuf,
size_t  buf_size,
mz_uint  flags 
)

◆ mz_zip_reader_extract_file_to_mem_no_alloc()

mz_bool mz_zip_reader_extract_file_to_mem_no_alloc ( mz_zip_archive pZip,
const char *  pFilename,
void *  pBuf,
size_t  buf_size,
mz_uint  flags,
void *  pUser_read_buf,
size_t  user_read_buf_size 
)

◆ mz_zip_reader_extract_to_callback()

mz_bool mz_zip_reader_extract_to_callback ( mz_zip_archive pZip,
mz_uint  file_index,
mz_file_write_func  pCallback,
void *  pOpaque,
mz_uint  flags 
)

◆ mz_zip_reader_extract_to_file()

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

◆ mz_zip_reader_extract_to_heap()

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

◆ mz_zip_reader_extract_to_mem()

mz_bool mz_zip_reader_extract_to_mem ( mz_zip_archive pZip,
mz_uint  file_index,
void *  pBuf,
size_t  buf_size,
mz_uint  flags 
)

◆ mz_zip_reader_extract_to_mem_no_alloc()

mz_bool mz_zip_reader_extract_to_mem_no_alloc ( mz_zip_archive pZip,
mz_uint  file_index,
void *  pBuf,
size_t  buf_size,
mz_uint  flags,
void *  pUser_read_buf,
size_t  user_read_buf_size 
)

◆ mz_zip_reader_file_stat()

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

◆ mz_zip_reader_filename_compare()

static MZ_FORCEINLINE int mz_zip_reader_filename_compare ( const mz_zip_array pCentral_dir_array,
const mz_zip_array pCentral_dir_offsets,
mz_uint  l_index,
const char *  pR,
mz_uint  r_len 
)
static

◆ mz_zip_reader_filename_less()

static MZ_FORCEINLINE mz_bool mz_zip_reader_filename_less ( const mz_zip_array pCentral_dir_array,
const mz_zip_array pCentral_dir_offsets,
mz_uint  l_index,
mz_uint  r_index 
)
static

◆ mz_zip_reader_get_cdh()

static MZ_FORCEINLINE const mz_uint8* mz_zip_reader_get_cdh ( mz_zip_archive pZip,
mz_uint  file_index 
)
static

◆ mz_zip_reader_get_filename()

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

◆ mz_zip_reader_get_num_files()

mz_uint mz_zip_reader_get_num_files ( mz_zip_archive pZip)

◆ mz_zip_reader_init()

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

◆ mz_zip_reader_init_file()

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

◆ mz_zip_reader_init_internal()

static mz_bool mz_zip_reader_init_internal ( mz_zip_archive pZip,
mz_uint32  flags 
)
static

◆ mz_zip_reader_init_mem()

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

◆ mz_zip_reader_is_file_a_directory()

mz_bool mz_zip_reader_is_file_a_directory ( mz_zip_archive pZip,
mz_uint  file_index 
)

◆ mz_zip_reader_is_file_encrypted()

mz_bool mz_zip_reader_is_file_encrypted ( mz_zip_archive pZip,
mz_uint  file_index 
)

◆ mz_zip_reader_locate_file()

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

◆ mz_zip_reader_locate_file_binary_search()

static int mz_zip_reader_locate_file_binary_search ( mz_zip_archive pZip,
const char *  pFilename 
)
static

◆ mz_zip_reader_read_central_dir()

static mz_bool mz_zip_reader_read_central_dir ( mz_zip_archive pZip,
mz_uint32  flags 
)
static

◆ mz_zip_reader_sort_central_dir_offsets_by_filename()

static void mz_zip_reader_sort_central_dir_offsets_by_filename ( mz_zip_archive pZip)
static

◆ mz_zip_reader_string_equal()

static MZ_FORCEINLINE mz_bool mz_zip_reader_string_equal ( const char *  pA,
const char *  pB,
mz_uint  len,
mz_uint  flags 
)
static

◆ mz_zip_set_file_times()

static mz_bool mz_zip_set_file_times ( const char *  pFilename,
time_t  access_time,
time_t  modified_time 
)
static

◆ mz_zip_time_to_dos_time()

static void mz_zip_time_to_dos_time ( time_t  time,
mz_uint16 pDOS_time,
mz_uint16 pDOS_date 
)
static

◆ mz_zip_writer_add_file()

mz_bool mz_zip_writer_add_file ( mz_zip_archive pZip,
const char *  pArchive_name,
const char *  pSrc_filename,
const void *  pComment,
mz_uint16  comment_size,
mz_uint  level_and_flags 
)

◆ mz_zip_writer_add_from_zip_reader()

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

◆ mz_zip_writer_add_mem()

mz_bool mz_zip_writer_add_mem ( mz_zip_archive pZip,
const char *  pArchive_name,
const void *  pBuf,
size_t  buf_size,
mz_uint  level_and_flags 
)

◆ mz_zip_writer_add_mem_ex()

mz_bool mz_zip_writer_add_mem_ex ( mz_zip_archive pZip,
const char *  pArchive_name,
const void *  pBuf,
size_t  buf_size,
const void *  pComment,
mz_uint16  comment_size,
mz_uint  level_and_flags,
mz_uint64  uncomp_size,
mz_uint32  uncomp_crc32 
)

◆ mz_zip_writer_add_put_buf_callback()

static mz_bool mz_zip_writer_add_put_buf_callback ( const void *  pBuf,
int  len,
void *  pUser 
)
static

◆ mz_zip_writer_add_to_central_dir()

static mz_bool mz_zip_writer_add_to_central_dir ( mz_zip_archive pZip,
const char *  pFilename,
mz_uint16  filename_size,
const void *  pExtra,
mz_uint16  extra_size,
const void *  pComment,
mz_uint16  comment_size,
mz_uint64  uncomp_size,
mz_uint64  comp_size,
mz_uint32  uncomp_crc32,
mz_uint16  method,
mz_uint16  bit_flags,
mz_uint16  dos_time,
mz_uint16  dos_date,
mz_uint64  local_header_ofs,
mz_uint32  ext_attributes 
)
static

◆ mz_zip_writer_compute_padding_needed_for_file_alignment()

static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment ( mz_zip_archive pZip)
static

◆ mz_zip_writer_create_central_dir_header()

static mz_bool mz_zip_writer_create_central_dir_header ( mz_zip_archive pZip,
mz_uint8 pDst,
mz_uint16  filename_size,
mz_uint16  extra_size,
mz_uint16  comment_size,
mz_uint64  uncomp_size,
mz_uint64  comp_size,
mz_uint32  uncomp_crc32,
mz_uint16  method,
mz_uint16  bit_flags,
mz_uint16  dos_time,
mz_uint16  dos_date,
mz_uint64  local_header_ofs,
mz_uint32  ext_attributes 
)
static

◆ mz_zip_writer_create_local_dir_header()

static mz_bool mz_zip_writer_create_local_dir_header ( mz_zip_archive pZip,
mz_uint8 pDst,
mz_uint16  filename_size,
mz_uint16  extra_size,
mz_uint64  uncomp_size,
mz_uint64  comp_size,
mz_uint32  uncomp_crc32,
mz_uint16  method,
mz_uint16  bit_flags,
mz_uint16  dos_time,
mz_uint16  dos_date 
)
static

◆ mz_zip_writer_end()

mz_bool mz_zip_writer_end ( mz_zip_archive pZip)

◆ mz_zip_writer_finalize_archive()

mz_bool mz_zip_writer_finalize_archive ( mz_zip_archive pZip)

◆ mz_zip_writer_finalize_heap_archive()

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

◆ mz_zip_writer_init()

mz_bool mz_zip_writer_init ( mz_zip_archive pZip,
mz_uint64  existing_size 
)

◆ mz_zip_writer_init_file()

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

◆ mz_zip_writer_init_from_reader()

mz_bool mz_zip_writer_init_from_reader ( mz_zip_archive pZip,
const char *  pFilename 
)

◆ mz_zip_writer_init_heap()

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

◆ mz_zip_writer_validate_archive_name()

static mz_bool mz_zip_writer_validate_archive_name ( const char *  pArchive_name)
static

◆ mz_zip_writer_write_zeros()

static mz_bool mz_zip_writer_write_zeros ( mz_zip_archive pZip,
mz_uint64  cur_file_ofs,
mz_uint32  n 
)
static

◆ tdefl_calculate_minimum_redundancy()

static void tdefl_calculate_minimum_redundancy ( tdefl_sym_freq A,
int  n 
)
static

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

static mz_bool tdefl_compress_block ( tdefl_compressor d,
mz_bool  static_block 
)
static

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

static mz_bool tdefl_compress_lz_codes ( tdefl_compressor d)
static

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

static mz_bool tdefl_compress_normal ( tdefl_compressor d)
static

◆ tdefl_create_comp_flags_from_zip_params()

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

◆ tdefl_find_match()

static MZ_FORCEINLINE void tdefl_find_match ( tdefl_compressor d,
mz_uint  lookahead_pos,
mz_uint  max_dist,
mz_uint  max_match_len,
mz_uint pMatch_dist,
mz_uint pMatch_len 
)
static

◆ tdefl_flush_block()

static int tdefl_flush_block ( tdefl_compressor d,
int  flush 
)
static

◆ tdefl_flush_output_buffer()

static tdefl_status tdefl_flush_output_buffer ( tdefl_compressor d)
static

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

static void tdefl_huffman_enforce_max_code_size ( int *  pNum_codes,
int  code_list_len,
int  max_code_size 
)
static

◆ tdefl_init()

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

◆ tdefl_optimize_huffman_table()

static void tdefl_optimize_huffman_table ( tdefl_compressor d,
int  table_num,
int  table_len,
int  code_size_limit,
int  static_table 
)
static

◆ tdefl_output_buffer_putter()

static mz_bool tdefl_output_buffer_putter ( const void *  pBuf,
int  len,
void *  pUser 
)
static

◆ tdefl_radix_sort_syms()

static tdefl_sym_freq* tdefl_radix_sort_syms ( mz_uint  num_syms,
tdefl_sym_freq pSyms0,
tdefl_sym_freq pSyms1 
)
static

◆ tdefl_record_literal()

static MZ_FORCEINLINE void tdefl_record_literal ( tdefl_compressor d,
mz_uint8  lit 
)
static

◆ tdefl_record_match()

static MZ_FORCEINLINE void tdefl_record_match ( tdefl_compressor d,
mz_uint  match_len,
mz_uint  match_dist 
)
static

◆ tdefl_start_dynamic_block()

static void tdefl_start_dynamic_block ( tdefl_compressor d)
static

◆ tdefl_start_static_block()

static void tdefl_start_static_block ( tdefl_compressor d)
static

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

Variable Documentation

◆ mz_bitmasks

const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF }
static

◆ s_tdefl_large_dist_extra

const mz_uint8 s_tdefl_large_dist_extra[128]
static
Initial value:
= {
0,0,8,8,9,9,9,9,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13 }

◆ s_tdefl_large_dist_sym

const mz_uint8 s_tdefl_large_dist_sym[128]
static
Initial value:
= {
0,0,18,19,20,20,21,21,22,22,22,22,23,23,23,23,24,24,24,24,24,24,24,24,25,25,25,25,25,25,25,25,26,26,26,26,26,26,26,26,26,26,26,26,
26,26,26,26,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
28,28,28,28,28,28,28,28,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29 }

◆ s_tdefl_len_extra

const mz_uint8 s_tdefl_len_extra[256]
static
Initial value:
= {
0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0 }

◆ s_tdefl_len_sym

const mz_uint16 s_tdefl_len_sym[256]
static
Initial value:
= {
257,258,259,260,261,262,263,264,265,265,266,266,267,267,268,268,269,269,269,269,270,270,270,270,271,271,271,271,272,272,272,272,
273,273,273,273,273,273,273,273,274,274,274,274,274,274,274,274,275,275,275,275,275,275,275,275,276,276,276,276,276,276,276,276,
277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,
279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280,
281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,
282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,
283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,
284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,285 }

◆ s_tdefl_num_probes

const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 }
static

◆ s_tdefl_packed_code_size_syms_swizzle

mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }
static

◆ s_tdefl_small_dist_extra

const mz_uint8 s_tdefl_small_dist_extra[512]
static
Initial value:
= {
0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7 }

◆ s_tdefl_small_dist_sym

const mz_uint8 s_tdefl_small_dist_sym[512]
static
Initial value:
= {
0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,
11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,
13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16,
16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17 }