#include <stddef.h>
#include <time.h>
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

Include dependency graph for miniz.h:

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

Go to the source code of this file.

Classes
struct	mz_stream_s

struct	tdefl_compressor

struct	tinfl_huff_table

struct	tinfl_decompressor_tag

struct	mz_zip_archive_file_stat

struct	mz_zip_archive

struct	mz_zip_reader_extract_iter_state

struct	mz_zip_writer_add_state

struct	mz_zip_writer_staged_context

Macros
#define	MINIZ_X86_OR_X64_CPU 0

#define	MINIZ_LITTLE_ENDIAN 1

#define	MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0

#define	MINIZ_HAS_64BIT_REGISTERS 0

#define	MZ_ADLER32_INIT (1)

#define	MZ_CRC32_INIT (0)

#define	MZ_DEFLATED 8

#define	MZ_VERSION "10.1.0"

#define	MZ_VERNUM 0xA100

#define	MZ_VER_MAJOR 10

#define	MZ_VER_MINOR 1

#define	MZ_VER_REVISION 0

#define	MZ_VER_SUBREVISION 0

#define	MZ_DEFAULT_WINDOW_BITS 15

#define	Z_NULL 0

#define	Z_NO_FLUSH MZ_NO_FLUSH

#define	Z_PARTIAL_FLUSH MZ_PARTIAL_FLUSH

#define	Z_SYNC_FLUSH MZ_SYNC_FLUSH

#define	Z_FULL_FLUSH MZ_FULL_FLUSH

#define	Z_FINISH MZ_FINISH

#define	Z_BLOCK MZ_BLOCK

#define	Z_OK MZ_OK

#define	Z_STREAM_END MZ_STREAM_END

#define	Z_NEED_DICT MZ_NEED_DICT

#define	Z_ERRNO MZ_ERRNO

#define	Z_STREAM_ERROR MZ_STREAM_ERROR

#define	Z_DATA_ERROR MZ_DATA_ERROR

#define	Z_MEM_ERROR MZ_MEM_ERROR

#define	Z_BUF_ERROR MZ_BUF_ERROR

#define	Z_VERSION_ERROR MZ_VERSION_ERROR

#define	Z_PARAM_ERROR MZ_PARAM_ERROR

#define	Z_NO_COMPRESSION MZ_NO_COMPRESSION

#define	Z_BEST_SPEED MZ_BEST_SPEED

#define	Z_BEST_COMPRESSION MZ_BEST_COMPRESSION

#define	Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION

#define	Z_DEFAULT_STRATEGY MZ_DEFAULT_STRATEGY

#define	Z_FILTERED MZ_FILTERED

#define	Z_HUFFMAN_ONLY MZ_HUFFMAN_ONLY

#define	Z_RLE MZ_RLE

#define	Z_FIXED MZ_FIXED

#define	Z_DEFLATED MZ_DEFLATED

#define	Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS

#define	alloc_func mz_alloc_func

#define	free_func mz_free_func

#define	internal_state mz_internal_state

#define	z_stream mz_stream

#define	deflateInit mz_deflateInit

#define	deflateInit2 mz_deflateInit2

#define	deflateReset mz_deflateReset

#define	deflate mz_deflate

#define	deflateEnd mz_deflateEnd

#define	deflateBound mz_deflateBound

#define	compress mz_compress

#define	compress2 mz_compress2

#define	compressBound mz_compressBound

#define	inflateInit mz_inflateInit

#define	inflateInit2 mz_inflateInit2

#define	inflateReset mz_inflateReset

#define	inflate mz_inflate

#define	inflateEnd mz_inflateEnd

#define	uncompress mz_uncompress

#define	crc32 mz_crc32

#define	adler32 mz_adler32

#define	MAX_WBITS 15

#define	MAX_MEM_LEVEL 9

#define	zError mz_error

#define	ZLIB_VERSION MZ_VERSION

#define	ZLIB_VERNUM MZ_VERNUM

#define	ZLIB_VER_MAJOR MZ_VER_MAJOR

#define	ZLIB_VER_MINOR MZ_VER_MINOR

#define	ZLIB_VER_REVISION MZ_VER_REVISION

#define	ZLIB_VER_SUBREVISION MZ_VER_SUBREVISION

#define	zlibVersion mz_version

#define	zlib_version mz_version()

#define	MZ_FALSE (0)

#define	MZ_TRUE (1)

#define	MZ_MACRO_END while (0)

#define	MZ_FILE FILE

#define	MZ_TIME_T time_t

#define	MZ_ASSERT(x) assert(x)

#define	MZ_MALLOC(x) malloc(x)

#define	MZ_FREE(x) free(x)

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

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

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

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

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

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

#define	MZ_READ_LE64(p) (((mz_uint64)MZ_READ_LE32(p)) \| (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) << 32U))

#define	MZ_FORCEINLINE inline

#define	MZ_UINT16_MAX (0xFFFFU)

#define	MZ_UINT32_MAX (0xFFFFFFFFU)

#define	TDEFL_LESS_MEMORY 0

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

#define	TINFL_LZ_DICT_SIZE 32768

#define	tinfl_init(r)

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

#define	TINFL_USE_64BIT_BITBUF 0

#define	TINFL_BITBUF_SIZE (32)

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

Typedefs
typedef unsigned long	mz_ulong

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

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

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

typedef struct mz_stream_s	mz_stream

typedef mz_stream *	mz_streamp

typedef unsigned char	Byte

typedef unsigned int	uInt

typedef mz_ulong	uLong

typedef Byte	Bytef

typedef uInt	uIntf

typedef char	charf

typedef int	intf

typedef void *	voidpf

typedef uLong	uLongf

typedef void *	voidp

typedef void *const	voidpc

typedef unsigned char	mz_uint8

typedef signed short	mz_int16

typedef unsigned short	mz_uint16

typedef unsigned int	mz_uint32

typedef unsigned int	mz_uint

typedef int64_t	mz_int64

typedef uint64_t	mz_uint64

typedef int	mz_bool

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

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

typedef struct tinfl_decompressor_tag	tinfl_decompressor

typedef mz_uint32	tinfl_bit_buf_t

typedef 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 mz_bool(*	mz_file_needs_keepalive) (void *pOpaque)

typedef struct mz_zip_internal_state_tag	mz_zip_internal_state

typedef struct mz_zip_writer_staged_context	mz_zip_writer_staged_context

Enumerations
enum	{ MZ_DEFAULT_STRATEGY = 0 , MZ_FILTERED = 1 , MZ_HUFFMAN_ONLY = 2 , MZ_RLE = 3 , MZ_FIXED = 4 }

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_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	{ TDEFL_HUFFMAN_ONLY = 0 , TDEFL_DEFAULT_MAX_PROBES = 128 , TDEFL_MAX_PROBES_MASK = 0xFFF }

enum	{ TDEFL_WRITE_ZLIB_HEADER = 0x01000 , TDEFL_COMPUTE_ADLER32 = 0x02000 , TDEFL_GREEDY_PARSING_FLAG = 0x04000 , TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000 , TDEFL_RLE_MATCHES = 0x10000 , TDEFL_FILTER_MATCHES = 0x20000 , TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000 , TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000 }

enum	{ TDEFL_MAX_HUFF_TABLES = 3 , TDEFL_MAX_HUFF_SYMBOLS_0 = 288 , TDEFL_MAX_HUFF_SYMBOLS_1 = 32 , TDEFL_MAX_HUFF_SYMBOLS_2 = 19 , TDEFL_LZ_DICT_SIZE = 32768 , TDEFL_LZ_DICT_SIZE_MASK = TDEFL_LZ_DICT_SIZE - 1 , TDEFL_MIN_MATCH_LEN = 3 , TDEFL_MAX_MATCH_LEN = 258 }

enum	{ TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024 , TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13) / 10 , TDEFL_MAX_HUFF_SYMBOLS = 288 , TDEFL_LZ_HASH_BITS = 15 , TDEFL_LEVEL1_HASH_SIZE_MASK = 4095 , TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3 , TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS }

enum	tdefl_status { TDEFL_STATUS_BAD_PARAM = -2 , TDEFL_STATUS_PUT_BUF_FAILED = -1 , TDEFL_STATUS_OKAY = 0 , TDEFL_STATUS_DONE = 1 }

enum	tdefl_flush { TDEFL_NO_FLUSH = 0 , TDEFL_SYNC_FLUSH = 2 , TDEFL_FULL_FLUSH = 3 , TDEFL_FINISH = 4 }

enum	{ TINFL_FLAG_PARSE_ZLIB_HEADER = 1 , TINFL_FLAG_HAS_MORE_INPUT = 2 , TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4 , TINFL_FLAG_COMPUTE_ADLER32 = 8 }

enum	tinfl_status { TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS = -4 , TINFL_STATUS_BAD_PARAM = -3 , TINFL_STATUS_ADLER32_MISMATCH = -2 , TINFL_STATUS_FAILED = -1 , TINFL_STATUS_DONE = 0 , TINFL_STATUS_NEEDS_MORE_INPUT = 1 , TINFL_STATUS_HAS_MORE_OUTPUT = 2 }

enum	{ TINFL_MAX_HUFF_TABLES = 3 , TINFL_MAX_HUFF_SYMBOLS_0 = 288 , TINFL_MAX_HUFF_SYMBOLS_1 = 32 , TINFL_MAX_HUFF_SYMBOLS_2 = 19 , TINFL_FAST_LOOKUP_BITS = 10 , TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS }

enum	{ MZ_ZIP_MAX_IO_BUF_SIZE = 64 * 1024 , MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 512 , MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 512 }

enum	mz_zip_mode { MZ_ZIP_MODE_INVALID = 0 , MZ_ZIP_MODE_READING = 1 , MZ_ZIP_MODE_WRITING = 2 , MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3 }

enum	mz_zip_flags { MZ_ZIP_FLAG_CASE_SENSITIVE = 0x0100 , MZ_ZIP_FLAG_IGNORE_PATH = 0x0200 , MZ_ZIP_FLAG_COMPRESSED_DATA = 0x0400 , MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY = 0x0800 , MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG = 0x1000 , MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000 , MZ_ZIP_FLAG_WRITE_ZIP64 = 0x4000 , MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000 , MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000 }

enum	mz_zip_type { MZ_ZIP_TYPE_INVALID = 0 , MZ_ZIP_TYPE_USER , MZ_ZIP_TYPE_MEMORY , MZ_ZIP_TYPE_HEAP , MZ_ZIP_TYPE_FILE , MZ_ZIP_TYPE_CFILE , MZ_ZIP_TOTAL_TYPES }

enum	mz_zip_error { MZ_ZIP_NO_ERROR = 0 , MZ_ZIP_UNDEFINED_ERROR , MZ_ZIP_TOO_MANY_FILES , MZ_ZIP_FILE_TOO_LARGE , MZ_ZIP_UNSUPPORTED_METHOD , MZ_ZIP_UNSUPPORTED_ENCRYPTION , MZ_ZIP_UNSUPPORTED_FEATURE , MZ_ZIP_FAILED_FINDING_CENTRAL_DIR , MZ_ZIP_NOT_AN_ARCHIVE , MZ_ZIP_INVALID_HEADER_OR_CORRUPTED , MZ_ZIP_UNSUPPORTED_MULTIDISK , MZ_ZIP_DECOMPRESSION_FAILED , MZ_ZIP_COMPRESSION_FAILED , MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE , MZ_ZIP_CRC_CHECK_FAILED , MZ_ZIP_UNSUPPORTED_CDIR_SIZE , MZ_ZIP_ALLOC_FAILED , MZ_ZIP_FILE_OPEN_FAILED , MZ_ZIP_FILE_CREATE_FAILED , MZ_ZIP_FILE_WRITE_FAILED , MZ_ZIP_FILE_READ_FAILED , MZ_ZIP_FILE_CLOSE_FAILED , MZ_ZIP_FILE_SEEK_FAILED , MZ_ZIP_FILE_STAT_FAILED , MZ_ZIP_INVALID_PARAMETER , MZ_ZIP_INVALID_FILENAME , MZ_ZIP_BUF_TOO_SMALL , MZ_ZIP_INTERNAL_ERROR , MZ_ZIP_FILE_NOT_FOUND , MZ_ZIP_ARCHIVE_TOO_LARGE , MZ_ZIP_VALIDATION_FAILED , MZ_ZIP_WRITE_CALLBACK_FAILED , MZ_ZIP_TOTAL_ERRORS }

Functions
void	mz_free (void *p)

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

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

const char *	mz_version (void)

int	mz_deflateInit (mz_streamp pStream, int level)

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

int	mz_deflateReset (mz_streamp pStream)

int	mz_deflate (mz_streamp pStream, int flush)

int	mz_deflateEnd (mz_streamp pStream)

mz_ulong	mz_deflateBound (mz_streamp pStream, mz_ulong source_len)

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

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

mz_ulong	mz_compressBound (mz_ulong source_len)

int	mz_inflateInit (mz_streamp pStream)

int	mz_inflateInit2 (mz_streamp pStream, int window_bits)

int	mz_inflateReset (mz_streamp pStream)

int	mz_inflate (mz_streamp pStream, int flush)

int	mz_inflateEnd (mz_streamp pStream)

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

const char *	mz_error (int err)

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

void	miniz_def_free_func (void opaque, void address)

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

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

size_t	tdefl_compress_mem_to_mem (void pOut_buf, size_t out_buf_len, const void pSrc_buf, size_t src_buf_len, int flags)

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

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

mz_bool	tdefl_compress_mem_to_output (const void pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void pPut_buf_user, int flags)

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

tdefl_status	tdefl_compress (tdefl_compressor d, const void pIn_buf, size_t pIn_buf_size, void pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)

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

tdefl_status	tdefl_get_prev_return_status (tdefl_compressor *d)

mz_uint32	tdefl_get_adler32 (tdefl_compressor *d)

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

tdefl_compressor *	tdefl_compressor_alloc (void)

void	tdefl_compressor_free (tdefl_compressor *pComp)

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)

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)

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_end (mz_zip_archive *pZip)

void	mz_zip_zero_struct (mz_zip_archive *pZip)

mz_zip_mode	mz_zip_get_mode (mz_zip_archive *pZip)

mz_zip_type	mz_zip_get_type (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_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_reader_is_file_a_directory (mz_zip_archive *pZip, mz_uint file_index)

mz_bool	mz_zip_reader_is_file_encrypted (mz_zip_archive *pZip, mz_uint file_index)

mz_bool	mz_zip_reader_is_file_supported (mz_zip_archive *pZip, mz_uint file_index)

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

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

int	mz_zip_reader_locate_file_v2 (mz_zip_archive pZip, const char pName, const char pComment, mz_uint flags, mz_uint32 file_index)

mz_uint	mz_zip_reader_get_filename_from_extra (mz_zip_archive pZip, mz_uint file_index, char buffer, mz_uint extra_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_is_zip64 (mz_zip_archive *pZip)

size_t	mz_zip_get_central_dir_size (mz_zip_archive *pZip)

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 File, 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_end (mz_zip_archive *pZip)

mz_bool	mz_zip_writer_init (mz_zip_archive *pZip, mz_uint64 existing_size)

mz_bool	mz_zip_writer_init_v2 (mz_zip_archive *pZip, mz_uint64 existing_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_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_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 (mz_zip_archive pZip, const char pFilename)

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

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_local, mz_uint user_extra_data_local_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_local, mz_uint user_extra_data_local_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_cfile (mz_zip_archive pZip, const char pArchive_name, MZ_FILE pSrc_file, mz_uint64 size_to_add, const MZ_TIME_T pFile_time, const void pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char user_extra_data_local, mz_uint user_extra_data_local_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)

mz_bool	mz_zip_writer_add_staged_open (mz_zip_archive pZip, mz_zip_writer_staged_context pContext, const char pArchive_name, 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_staged_data (mz_zip_writer_staged_context pContext, const char pRead_buf, size_t n)

mz_bool	mz_zip_writer_add_staged_finish (mz_zip_writer_staged_context *pContext)

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 (const char pZip_filename, const char pArchive_name, size_t *pSize, mz_uint flags)

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)

Class Documentation

◆ mz_stream_s

struct mz_stream_s

Class Members
mz_ulong	adler
unsigned int	avail_in
unsigned int	avail_out
int	data_type
char *	msg
const unsigned char *	next_in
unsigned char *	next_out
void *	opaque
mz_ulong	reserved
struct mz_internal_state *	state
mz_ulong	total_in
mz_ulong	total_out
mz_alloc_func	zalloc
mz_free_func	zfree

◆ tdefl_compressor

struct tdefl_compressor

Class Members
mz_uint	m_adler32
mz_uint	m_bit_buffer
mz_uint	m_bits_in
mz_uint	m_block_index
mz_uint8	m_dict[TDEFL_LZ_DICT_SIZE+TDEFL_MAX_MATCH_LEN - 1]
mz_uint	m_dict_size
mz_uint	m_finished
mz_uint	m_flags
tdefl_flush	m_flush
int	m_greedy_parsing
mz_uint16	m_hash[TDEFL_LZ_HASH_SIZE]
mz_uint8	m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]
mz_uint16	m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]
mz_uint16	m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]
mz_uint	m_lookahead_pos
mz_uint	m_lookahead_size
mz_uint8	m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE]
mz_uint	m_lz_code_buf_dict_pos
mz_uint	m_max_probes[2]
mz_uint16	m_next[TDEFL_LZ_DICT_SIZE]
mz_uint	m_num_flags_left
size_t	m_out_buf_ofs
mz_uint8	m_output_buf[TDEFL_OUT_BUF_SIZE]
mz_uint	m_output_flush_ofs
mz_uint	m_output_flush_remaining
const void *	m_pIn_buf
size_t *	m_pIn_buf_size
mz_uint8 *	m_pLZ_code_buf
mz_uint8 *	m_pLZ_flags
void *	m_pOut_buf
size_t *	m_pOut_buf_size
mz_uint8 *	m_pOutput_buf
mz_uint8 *	m_pOutput_buf_end
tdefl_put_buf_func_ptr	m_pPut_buf_func
void *	m_pPut_buf_user
tdefl_status	m_prev_return_status
const mz_uint8 *	m_pSrc
mz_uint	m_saved_lit
mz_uint	m_saved_match_dist
mz_uint	m_saved_match_len
size_t	m_src_buf_left
mz_uint	m_total_lz_bytes
mz_uint	m_wants_to_finish

◆ tinfl_huff_table

struct tinfl_huff_table

Class Members
mz_uint8	m_code_size[TINFL_MAX_HUFF_SYMBOLS_0]
mz_int16	m_look_up[TINFL_FAST_LOOKUP_SIZE]
mz_int16	m_tree[TINFL_MAX_HUFF_SYMBOLS_0 *2]

◆ tinfl_decompressor_tag

struct tinfl_decompressor_tag

Collaboration diagram for tinfl_decompressor_tag:

Class Members
tinfl_bit_buf_t	m_bit_buf
mz_uint32	m_check_adler32
mz_uint32	m_counter
mz_uint32	m_dist
size_t	m_dist_from_out_buf_start
mz_uint32	m_final
mz_uint8	m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0+TINFL_MAX_HUFF_SYMBOLS_1+137]
mz_uint32	m_num_bits
mz_uint32	m_num_extra
mz_uint8	m_raw_header[4]
mz_uint32	m_state
mz_uint32	m_table_sizes[TINFL_MAX_HUFF_TABLES]
tinfl_huff_table	m_tables[TINFL_MAX_HUFF_TABLES]
mz_uint32	m_type
mz_uint32	m_z_adler32
mz_uint32	m_zhdr0
mz_uint32	m_zhdr1

◆ mz_zip_archive_file_stat

struct mz_zip_archive_file_stat

Class Members
mz_uint16	m_bit_flag
mz_uint64	m_central_dir_ofs
char	m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE]
mz_uint32	m_comment_size
mz_uint64	m_comp_size
mz_uint32	m_crc32
mz_uint32	m_external_attr
mz_uint32	m_file_index
char	m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE]
mz_uint16	m_internal_attr
mz_bool	m_is_directory
mz_bool	m_is_encrypted
mz_bool	m_is_supported
mz_uint64	m_local_header_ofs
mz_uint16	m_method
MZ_TIME_T	m_time
mz_uint64	m_uncomp_size
mz_uint16	m_version_made_by
mz_uint16	m_version_needed

◆ mz_zip_archive

struct mz_zip_archive

Collaboration diagram for mz_zip_archive:

Class Members
mz_uint64	m_archive_size
mz_uint64	m_central_directory_file_ofs
mz_uint64	m_file_offset_alignment
mz_zip_error	m_last_error
mz_alloc_func	m_pAlloc
void *	m_pAlloc_opaque
mz_free_func	m_pFree
void *	m_pIO_opaque
mz_file_needs_keepalive	m_pNeeds_keepalive
mz_file_read_func	m_pRead
mz_realloc_func	m_pRealloc
mz_zip_internal_state *	m_pState
mz_file_write_func	m_pWrite
mz_uint32	m_total_files
mz_zip_mode	m_zip_mode
mz_zip_type	m_zip_type

◆ mz_zip_reader_extract_iter_state

struct mz_zip_reader_extract_iter_state

Collaboration diagram for mz_zip_reader_extract_iter_state:

Class Members
mz_uint64	comp_remaining
mz_uint64	cur_file_ofs
mz_uint	file_crc32
mz_zip_archive_file_stat	file_stat
mz_uint	flags
tinfl_decompressor	inflator
size_t	out_blk_remain
mz_uint64	out_buf_ofs
void *	pRead_buf
void *	pWrite_buf
mz_zip_archive *	pZip
mz_uint64	read_buf_avail
mz_uint64	read_buf_ofs
mz_uint64	read_buf_size
int	status

◆ mz_zip_writer_add_state

struct mz_zip_writer_add_state

Collaboration diagram for mz_zip_writer_add_state:

Class Members
mz_uint64	m_comp_size
mz_uint64	m_cur_archive_file_ofs
mz_zip_archive *	m_pZip

◆ mz_zip_writer_staged_context

struct mz_zip_writer_staged_context

Collaboration diagram for mz_zip_writer_staged_context:

Class Members
mz_zip_writer_add_state	add_state
size_t	archive_name_size
mz_uint16	comment_size
mz_uint64	comp_size
mz_uint64	cur_archive_file_ofs
mz_uint16	dos_date
mz_uint16	dos_time
mz_uint16	ext_attributes
mz_uint8	extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE]
mz_uint32	extra_size
mz_uint64	file_ofs
mz_uint16	gen_flags
mz_uint64	local_dir_header_ofs
mz_uint64	max_size
mz_uint16	method
const char *	pArchive_name
const void *	pComment
tdefl_compressor *	pCompressor
mz_uint8 *	pExtra_data
mz_zip_archive *	pZip
mz_uint	uncomp_crc32
mz_uint64	uncomp_size
const char *	user_extra_data_central
mz_uint	user_extra_data_central_len

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

◆ inflateReset

#define inflateReset mz_inflateReset

◆ internal_state

#define internal_state mz_internal_state

◆ MAX_MEM_LEVEL

#define MAX_MEM_LEVEL 9

◆ MAX_WBITS

#define MAX_WBITS 15

◆ MINIZ_HAS_64BIT_REGISTERS

#define MINIZ_HAS_64BIT_REGISTERS 0

◆ MINIZ_LITTLE_ENDIAN

#define MINIZ_LITTLE_ENDIAN 1

◆ MINIZ_USE_UNALIGNED_LOADS_AND_STORES

#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0

◆ MINIZ_X86_OR_X64_CPU

#define MINIZ_X86_OR_X64_CPU 0

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

#define MZ_FALSE (0)

◆ MZ_FILE

#define MZ_FILE FILE

◆ MZ_FORCEINLINE

#define MZ_FORCEINLINE inline

◆ MZ_FREE

#define MZ_FREE ( x ) free(x)

◆ MZ_MACRO_END

#define MZ_MACRO_END while (0)

◆ MZ_MALLOC

#define MZ_MALLOC ( x ) malloc(x)

◆ MZ_MAX

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

◆ MZ_MIN

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

◆ MZ_READ_LE16

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

◆ MZ_READ_LE32

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

◆ MZ_READ_LE64

#define MZ_READ_LE64 ( p ) (((mz_uint64)MZ_READ_LE32(p)) | (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) << 32U))

◆ MZ_REALLOC

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

◆ MZ_TIME_T

#define MZ_TIME_T time_t

◆ MZ_TRUE

#define MZ_TRUE (1)

◆ MZ_UINT16_MAX

#define MZ_UINT16_MAX (0xFFFFU)

◆ MZ_UINT32_MAX

#define MZ_UINT32_MAX (0xFFFFFFFFU)

◆ MZ_VER_MAJOR

#define MZ_VER_MAJOR 10

◆ MZ_VER_MINOR

#define MZ_VER_MINOR 1

◆ MZ_VER_REVISION

#define MZ_VER_REVISION 0

◆ MZ_VER_SUBREVISION

#define MZ_VER_SUBREVISION 0

◆ MZ_VERNUM

#define MZ_VERNUM 0xA100

◆ MZ_VERSION

#define MZ_VERSION "10.1.0"

◆ MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE

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

◆ TDEFL_LESS_MEMORY

#define TDEFL_LESS_MEMORY 0

◆ TINFL_BITBUF_SIZE

#define TINFL_BITBUF_SIZE (32)

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

#define tinfl_init ( r )

Value:

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

◆ TINFL_LZ_DICT_SIZE

#define TINFL_LZ_DICT_SIZE 32768

◆ TINFL_USE_64BIT_BITBUF

#define TINFL_USE_64BIT_BITBUF 0

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

typedef mz_bool(* mz_file_needs_keepalive) (void *pOpaque)

◆ 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 int64_t mz_int64

◆ mz_realloc_func

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

◆ mz_stream

typedef struct mz_stream_s mz_stream

◆ mz_streamp

typedef mz_stream* mz_streamp

◆ mz_uint

typedef unsigned int mz_uint

◆ mz_uint16

typedef unsigned short mz_uint16

◆ mz_uint32

typedef unsigned int mz_uint32

◆ mz_uint64

typedef uint64_t mz_uint64

◆ mz_uint8

typedef unsigned char mz_uint8

◆ mz_ulong

typedef unsigned long mz_ulong

◆ mz_zip_internal_state

typedef struct mz_zip_internal_state_tag mz_zip_internal_state

◆ mz_zip_writer_staged_context

typedef struct mz_zip_writer_staged_context mz_zip_writer_staged_context

◆ tdefl_put_buf_func_ptr

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

◆ tinfl_bit_buf_t

typedef mz_uint32 tinfl_bit_buf_t

◆ tinfl_decompressor

typedef struct tinfl_decompressor_tag tinfl_decompressor

◆ tinfl_put_buf_func_ptr

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

◆ uInt

typedef unsigned int uInt

◆ uIntf

typedef uInt uIntf

◆ uLong

typedef mz_ulong uLong

◆ uLongf

typedef uLong uLongf

◆ voidp

typedef void* voidp

◆ voidpc

typedef void* const voidpc

◆ voidpf

typedef void* voidpf

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
MZ_DEFAULT_STRATEGY
MZ_FILTERED
MZ_HUFFMAN_ONLY
MZ_RLE
MZ_FIXED

{
    MZ_DEFAULT_STRATEGY = 0,
    MZ_FILTERED = 1,
    MZ_HUFFMAN_ONLY = 2,
    MZ_RLE = 3,
    MZ_FIXED = 4
};

◆ anonymous enum

anonymous enum

Enumerator
MZ_NO_COMPRESSION
MZ_BEST_SPEED
MZ_BEST_COMPRESSION
MZ_UBER_COMPRESSION
MZ_DEFAULT_LEVEL
MZ_DEFAULT_COMPRESSION

{
    MZ_NO_COMPRESSION = 0,
    MZ_BEST_SPEED = 1,
    MZ_BEST_COMPRESSION = 9,
    MZ_UBER_COMPRESSION = 10,
    MZ_DEFAULT_LEVEL = 6,
    MZ_DEFAULT_COMPRESSION = -1
};

◆ anonymous enum

anonymous enum

Enumerator
MZ_NO_FLUSH
MZ_PARTIAL_FLUSH
MZ_SYNC_FLUSH
MZ_FULL_FLUSH
MZ_FINISH
MZ_BLOCK

{
    MZ_NO_FLUSH = 0,
    MZ_PARTIAL_FLUSH = 1,
    MZ_SYNC_FLUSH = 2,
    MZ_FULL_FLUSH = 3,
    MZ_FINISH = 4,
    MZ_BLOCK = 5
};

◆ 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

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

◆ anonymous enum

anonymous enum

Enumerator
TDEFL_HUFFMAN_ONLY
TDEFL_DEFAULT_MAX_PROBES
TDEFL_MAX_PROBES_MASK

{
    TDEFL_HUFFMAN_ONLY = 0,
    TDEFL_DEFAULT_MAX_PROBES = 128,
    TDEFL_MAX_PROBES_MASK = 0xFFF
};

◆ 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

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

◆ 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

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

◆ 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

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

◆ 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

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

◆ 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

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

◆ anonymous enum

anonymous enum

Enumerator
MZ_ZIP_MAX_IO_BUF_SIZE
MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE
MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE

{
    /* Note: These enums can be reduced as needed to save memory or stack space - they are pretty conservative. */
    MZ_ZIP_MAX_IO_BUF_SIZE = 64 * 1024,
    MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 512,
    MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 512
};

◆ mz_zip_error

enum mz_zip_error

Enumerator
MZ_ZIP_NO_ERROR
MZ_ZIP_UNDEFINED_ERROR
MZ_ZIP_TOO_MANY_FILES
MZ_ZIP_FILE_TOO_LARGE
MZ_ZIP_UNSUPPORTED_METHOD
MZ_ZIP_UNSUPPORTED_ENCRYPTION
MZ_ZIP_UNSUPPORTED_FEATURE
MZ_ZIP_FAILED_FINDING_CENTRAL_DIR
MZ_ZIP_NOT_AN_ARCHIVE
MZ_ZIP_INVALID_HEADER_OR_CORRUPTED
MZ_ZIP_UNSUPPORTED_MULTIDISK
MZ_ZIP_DECOMPRESSION_FAILED
MZ_ZIP_COMPRESSION_FAILED
MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE
MZ_ZIP_CRC_CHECK_FAILED
MZ_ZIP_UNSUPPORTED_CDIR_SIZE
MZ_ZIP_ALLOC_FAILED
MZ_ZIP_FILE_OPEN_FAILED
MZ_ZIP_FILE_CREATE_FAILED
MZ_ZIP_FILE_WRITE_FAILED
MZ_ZIP_FILE_READ_FAILED
MZ_ZIP_FILE_CLOSE_FAILED
MZ_ZIP_FILE_SEEK_FAILED
MZ_ZIP_FILE_STAT_FAILED
MZ_ZIP_INVALID_PARAMETER
MZ_ZIP_INVALID_FILENAME
MZ_ZIP_BUF_TOO_SMALL
MZ_ZIP_INTERNAL_ERROR
MZ_ZIP_FILE_NOT_FOUND
MZ_ZIP_ARCHIVE_TOO_LARGE
MZ_ZIP_VALIDATION_FAILED
MZ_ZIP_WRITE_CALLBACK_FAILED
MZ_ZIP_TOTAL_ERRORS

             {
    MZ_ZIP_NO_ERROR = 0,
    MZ_ZIP_UNDEFINED_ERROR,
    MZ_ZIP_TOO_MANY_FILES,
    MZ_ZIP_FILE_TOO_LARGE,
    MZ_ZIP_UNSUPPORTED_METHOD,
    MZ_ZIP_UNSUPPORTED_ENCRYPTION,
    MZ_ZIP_UNSUPPORTED_FEATURE,
    MZ_ZIP_FAILED_FINDING_CENTRAL_DIR,
    MZ_ZIP_NOT_AN_ARCHIVE,
    MZ_ZIP_INVALID_HEADER_OR_CORRUPTED,
    MZ_ZIP_UNSUPPORTED_MULTIDISK,
    MZ_ZIP_DECOMPRESSION_FAILED,
    MZ_ZIP_COMPRESSION_FAILED,
    MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE,
    MZ_ZIP_CRC_CHECK_FAILED,
    MZ_ZIP_UNSUPPORTED_CDIR_SIZE,
    MZ_ZIP_ALLOC_FAILED,
    MZ_ZIP_FILE_OPEN_FAILED,
    MZ_ZIP_FILE_CREATE_FAILED,
    MZ_ZIP_FILE_WRITE_FAILED,
    MZ_ZIP_FILE_READ_FAILED,
    MZ_ZIP_FILE_CLOSE_FAILED,
    MZ_ZIP_FILE_SEEK_FAILED,
    MZ_ZIP_FILE_STAT_FAILED,
    MZ_ZIP_INVALID_PARAMETER,
    MZ_ZIP_INVALID_FILENAME,
    MZ_ZIP_BUF_TOO_SMALL,
    MZ_ZIP_INTERNAL_ERROR,
    MZ_ZIP_FILE_NOT_FOUND,
    MZ_ZIP_ARCHIVE_TOO_LARGE,
    MZ_ZIP_VALIDATION_FAILED,
    MZ_ZIP_WRITE_CALLBACK_FAILED,
    MZ_ZIP_TOTAL_ERRORS
} mz_zip_error;

◆ mz_zip_flags

enum mz_zip_flags

Enumerator
MZ_ZIP_FLAG_CASE_SENSITIVE
MZ_ZIP_FLAG_IGNORE_PATH
MZ_ZIP_FLAG_COMPRESSED_DATA
MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY
MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG
MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY
MZ_ZIP_FLAG_WRITE_ZIP64
MZ_ZIP_FLAG_WRITE_ALLOW_READING
MZ_ZIP_FLAG_ASCII_FILENAME

             {
    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,
    MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG = 0x1000, /* if enabled, mz_zip_reader_locate_file() will be called on each file as its validated to ensure the func finds the file in the central dir (intended for testing) */
    MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000,     /* validate the local headers, but don't decompress the entire file and check the crc32 */
    MZ_ZIP_FLAG_WRITE_ZIP64 = 0x4000,               /* always use the zip64 file format, instead of the original zip file format with automatic switch to zip64. Use as flags parameter with mz_zip_writer_init*_v2 */
    MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000,
    MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000
} mz_zip_flags;

◆ mz_zip_mode

enum mz_zip_mode

Enumerator
MZ_ZIP_MODE_INVALID
MZ_ZIP_MODE_READING
MZ_ZIP_MODE_WRITING
MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED

             {
    MZ_ZIP_MODE_INVALID = 0,
    MZ_ZIP_MODE_READING = 1,
    MZ_ZIP_MODE_WRITING = 2,
    MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3
} mz_zip_mode;

◆ mz_zip_type

enum mz_zip_type

Enumerator
MZ_ZIP_TYPE_INVALID
MZ_ZIP_TYPE_USER
MZ_ZIP_TYPE_MEMORY
MZ_ZIP_TYPE_HEAP
MZ_ZIP_TYPE_FILE
MZ_ZIP_TYPE_CFILE
MZ_ZIP_TOTAL_TYPES

             {
    MZ_ZIP_TYPE_INVALID = 0,
    MZ_ZIP_TYPE_USER,
    MZ_ZIP_TYPE_MEMORY,
    MZ_ZIP_TYPE_HEAP,
    MZ_ZIP_TYPE_FILE,
    MZ_ZIP_TYPE_CFILE,
    MZ_ZIP_TOTAL_TYPES
} mz_zip_type;

◆ tdefl_flush

enum tdefl_flush

Enumerator
TDEFL_NO_FLUSH
TDEFL_SYNC_FLUSH
TDEFL_FULL_FLUSH
TDEFL_FINISH

             {
    TDEFL_NO_FLUSH = 0,
    TDEFL_SYNC_FLUSH = 2,
    TDEFL_FULL_FLUSH = 3,
    TDEFL_FINISH = 4
} tdefl_flush;

◆ tdefl_status

enum tdefl_status

Enumerator
TDEFL_STATUS_BAD_PARAM
TDEFL_STATUS_PUT_BUF_FAILED
TDEFL_STATUS_OKAY
TDEFL_STATUS_DONE

             {
    TDEFL_STATUS_BAD_PARAM = -2,
    TDEFL_STATUS_PUT_BUF_FAILED = -1,
    TDEFL_STATUS_OKAY = 0,
    TDEFL_STATUS_DONE = 1
} tdefl_status;

◆ tinfl_status

enum tinfl_status

Enumerator
TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS
TINFL_STATUS_BAD_PARAM
TINFL_STATUS_ADLER32_MISMATCH
TINFL_STATUS_FAILED
TINFL_STATUS_DONE
TINFL_STATUS_NEEDS_MORE_INPUT
TINFL_STATUS_HAS_MORE_OUTPUT

             {
    /* This flags indicates the inflator needs 1 or more input bytes to make forward progress, but the caller is indicating that no more are available. The compressed data */
    /* is probably corrupted. If you call the inflator again with more bytes it'll try to continue processing the input but this is a BAD sign (either the data is corrupted or you called it incorrectly). */
    /* If you call it again with no input you'll just get TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS again. */
    TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS = -4,
 
    /* This flag indicates that one or more of the input parameters was obviously bogus. (You can try calling it again, but if you get this error the calling code is wrong.) */
    TINFL_STATUS_BAD_PARAM = -3,
 
    /* This flags indicate the inflator is finished but the adler32 check of the uncompressed data didn't match. If you call it again it'll return TINFL_STATUS_DONE. */
    TINFL_STATUS_ADLER32_MISMATCH = -2,
 
    /* This flags indicate the inflator has somehow failed (bad code, corrupted input, etc.). If you call it again without resetting via tinfl_init() it it'll just keep on returning the same status failure code. */
    TINFL_STATUS_FAILED = -1,
 
    /* Any status code less than TINFL_STATUS_DONE must indicate a failure. */
 
    /* This flag indicates the inflator has returned every byte of uncompressed data that it can, has consumed every byte that it needed, has successfully reached the end of the deflate stream, and */
    /* if zlib headers and adler32 checking enabled that it has successfully checked the uncompressed data's adler32. If you call it again you'll just get TINFL_STATUS_DONE over and over again. */
    TINFL_STATUS_DONE = 0,
 
    /* This flag indicates the inflator MUST have more input data (even 1 byte) before it can make any more forward progress, or you need to clear the TINFL_FLAG_HAS_MORE_INPUT */
    /* flag on the next call if you don't have any more source data. If the source data was somehow corrupted it's also possible (but unlikely) for the inflator to keep on demanding input to */
    /* proceed, so be sure to properly set the TINFL_FLAG_HAS_MORE_INPUT flag. */
    TINFL_STATUS_NEEDS_MORE_INPUT = 1,
 
    /* This flag indicates the inflator definitely has 1 or more bytes of uncompressed data available, but it cannot write this data into the output buffer. */
    /* Note if the source compressed data was corrupted it's possible for the inflator to return a lot of uncompressed data to the caller. I've been assuming you know how much uncompressed data to expect */
    /* (either exact or worst case) and will stop calling the inflator and fail after receiving too much. In pure streaming scenarios where you have no idea how many bytes to expect this may not be possible */
    /* so I may need to add some code to address this. */
    TINFL_STATUS_HAS_MORE_OUTPUT = 2
} tinfl_status;

Function Documentation

◆ miniz_def_alloc_func()

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

{
    (void)opaque, (void)items, (void)size;
    return MZ_MALLOC(items * size);
}

References MZ_MALLOC, and void().

Referenced by mz_deflateInit2(), mz_inflateInit2(), mz_zip_reader_init_internal(), and mz_zip_writer_init_v2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ miniz_def_free_func()

void miniz_def_free_func	(	void *	opaque,
		void *	address
	)

{
    (void)opaque, (void)address;
    MZ_FREE(address);
}

References MZ_FREE, and void().

Referenced by mz_deflateInit2(), mz_inflateInit2(), mz_zip_reader_init_internal(), and mz_zip_writer_init_v2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ miniz_def_realloc_func()

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

{
    (void)opaque, (void)address, (void)items, (void)size;
    return MZ_REALLOC(address, items * size);
}

References MZ_REALLOC, and void().

Referenced by mz_zip_reader_init_internal(), and mz_zip_writer_init_v2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_adler32()

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

{
    mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16);
    size_t block_len = buf_len % 5552;
    if (!ptr)
        return MZ_ADLER32_INIT;
    while (buf_len)
    {
        for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
        {
            s1 += ptr[0], s2 += s1;
            s1 += ptr[1], s2 += s1;
            s1 += ptr[2], s2 += s1;
            s1 += ptr[3], s2 += s1;
            s1 += ptr[4], s2 += s1;
            s1 += ptr[5], s2 += s1;
            s1 += ptr[6], s2 += s1;
            s1 += ptr[7], s2 += s1;
        }
        for (; i < block_len; ++i)
            s1 += *ptr++, s2 += s1;
        s1 %= 65521U, s2 %= 65521U;
        buf_len -= block_len;
        block_len = 5552;
    }
    return (s2 << 16) + s1;
}

References MZ_ADLER32_INIT.

Referenced by tdefl_compress().

Here is the caller graph for this function:

◆ mz_compress()

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

{
    return mz_compress2(pDest, pDest_len, pSource, source_len, MZ_DEFAULT_COMPRESSION);
}

References mz_compress2(), and MZ_DEFAULT_COMPRESSION.

Here is the call graph for this function:

◆ mz_compress2()

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

{
    int status;
    mz_stream stream;
    memset(&stream, 0, sizeof(stream));
 
    /* In case mz_ulong is 64-bits (argh I hate longs). */
    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
        return MZ_PARAM_ERROR;
 
    stream.next_in = pSource;
    stream.avail_in = (mz_uint32)source_len;
    stream.next_out = pDest;
    stream.avail_out = (mz_uint32)*pDest_len;
 
    status = mz_deflateInit(&stream, level);
    if (status != MZ_OK)
        return status;
 
    status = mz_deflate(&stream, MZ_FINISH);
    if (status != MZ_STREAM_END)
    {
        mz_deflateEnd(&stream);
        return (status == MZ_OK) ? MZ_BUF_ERROR : status;
    }
 
    *pDest_len = stream.total_out;
    return mz_deflateEnd(&stream);
}

References mz_stream_s::avail_in, mz_stream_s::avail_out, MZ_BUF_ERROR, mz_deflate(), mz_deflateEnd(), mz_deflateInit(), MZ_FINISH, MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_END, mz_stream_s::next_in, mz_stream_s::next_out, and mz_stream_s::total_out.

Referenced by mz_compress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_compressBound()

mz_ulong mz_compressBound ( mz_ulong source_len )

{
    return mz_deflateBound(NULL, source_len);
}

References mz_deflateBound().

Here is the call graph for this function:

◆ mz_crc32()

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

{
    static const mz_uint32 s_crc_table[256] =
        {
          0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
          0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
          0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,
          0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
          0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
          0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
          0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,
          0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
          0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
          0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
          0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,
          0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
          0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,
          0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,
          0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
          0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
          0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,
          0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
          0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
          0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
          0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,
          0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,
          0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
          0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
          0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
          0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
          0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
          0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
          0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,
          0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
          0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,
          0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
          0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,
          0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
          0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
          0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
          0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
        };
 
    mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF;
    const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr;
 
    while (buf_len >= 4)
    {
        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF];
        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF];
        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF];
        pByte_buf += 4;
        buf_len -= 4;
    }
 
    while (buf_len)
    {
        crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
        ++pByte_buf;
        --buf_len;
    }
 
    return ~crc32;
}

References crc32.

Referenced by mz_zip_compute_crc32_callback(), mz_zip_reader_extract_iter_read(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_mem_no_alloc(), mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_read_buf_callback(), mz_zip_writer_add_staged_data(), and tdefl_write_image_to_png_file_in_memory_ex().

Here is the caller graph for this function:

◆ mz_deflate()

int mz_deflate	(	mz_streamp	pStream,
		int	flush
	)

{
    size_t in_bytes, out_bytes;
    mz_ulong orig_total_in, orig_total_out;
    int mz_status = MZ_OK;
 
    if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out))
        return MZ_STREAM_ERROR;
    if (!pStream->avail_out)
        return MZ_BUF_ERROR;
 
    if (flush == MZ_PARTIAL_FLUSH)
        flush = MZ_SYNC_FLUSH;
 
    if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE)
        return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
 
    orig_total_in = pStream->total_in;
    orig_total_out = pStream->total_out;
    for (;;)
    {
        tdefl_status defl_status;
        in_bytes = pStream->avail_in;
        out_bytes = pStream->avail_out;
 
        defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush);
        pStream->next_in += (mz_uint)in_bytes;
        pStream->avail_in -= (mz_uint)in_bytes;
        pStream->total_in += (mz_uint)in_bytes;
        pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
 
        pStream->next_out += (mz_uint)out_bytes;
        pStream->avail_out -= (mz_uint)out_bytes;
        pStream->total_out += (mz_uint)out_bytes;
 
        if (defl_status < 0)
        {
            mz_status = MZ_STREAM_ERROR;
            break;
        }
        else if (defl_status == TDEFL_STATUS_DONE)
        {
            mz_status = MZ_STREAM_END;
            break;
        }
        else if (!pStream->avail_out)
            break;
        else if ((!pStream->avail_in) && (flush != MZ_FINISH))
        {
            if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out))
                break;
            return MZ_BUF_ERROR; /* Can't make forward progress without some input.
 */
        }
    }
    return mz_status;
}

References mz_stream_s::adler, mz_stream_s::avail_in, mz_stream_s::avail_out, MZ_BUF_ERROR, MZ_FINISH, MZ_OK, MZ_PARTIAL_FLUSH, MZ_STREAM_END, MZ_STREAM_ERROR, MZ_SYNC_FLUSH, mz_stream_s::next_in, mz_stream_s::next_out, mz_stream_s::state, tdefl_compress(), tdefl_get_adler32(), TDEFL_STATUS_DONE, mz_stream_s::total_in, and mz_stream_s::total_out.

Referenced by mz_compress2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_deflateBound()

mz_ulong mz_deflateBound	(	mz_streamp	pStream,
		mz_ulong	source_len
	)

{
    (void)pStream;
    /* This is really over conservative. (And lame, but it's actually pretty tricky to compute a true upper bound given the way tdefl's blocking works.) */
    return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);
}

References MZ_MAX, and void().

Referenced by mz_compressBound().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_deflateEnd()

int mz_deflateEnd ( mz_streamp pStream )

{
    if (!pStream)
        return MZ_STREAM_ERROR;
    if (pStream->state)
    {
        pStream->zfree(pStream->opaque, pStream->state);
        pStream->state = NULL;
    }
    return MZ_OK;
}

References MZ_OK, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::state, and mz_stream_s::zfree.

Referenced by mz_compress2(), and mz_deflateInit2().

Here is the caller graph for this function:

◆ mz_deflateInit()

int mz_deflateInit	(	mz_streamp	pStream,
		int	level
	)

{
    return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY);
}

References MZ_DEFAULT_STRATEGY, MZ_DEFAULT_WINDOW_BITS, MZ_DEFLATED, and mz_deflateInit2().

Referenced by mz_compress2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_deflateInit2()

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

{
    tdefl_compressor *pComp;
    mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);
 
    if (!pStream)
        return MZ_STREAM_ERROR;
    if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)))
        return MZ_PARAM_ERROR;
 
    pStream->data_type = 0;
    pStream->adler = MZ_ADLER32_INIT;
    pStream->msg = NULL;
    pStream->reserved = 0;
    pStream->total_in = 0;
    pStream->total_out = 0;
    if (!pStream->zalloc)
        pStream->zalloc = miniz_def_alloc_func;
    if (!pStream->zfree)
        pStream->zfree = miniz_def_free_func;
 
    pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
    if (!pComp)
        return MZ_MEM_ERROR;
 
    pStream->state = (struct mz_internal_state *)pComp;
 
    if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
    {
        mz_deflateEnd(pStream);
        return MZ_PARAM_ERROR;
    }
 
    return MZ_OK;
}

References mz_stream_s::adler, mz_stream_s::data_type, miniz_def_alloc_func(), miniz_def_free_func(), mz_stream_s::msg, MZ_ADLER32_INIT, MZ_DEFAULT_WINDOW_BITS, MZ_DEFLATED, mz_deflateEnd(), MZ_MEM_ERROR, MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::reserved, mz_stream_s::state, TDEFL_COMPUTE_ADLER32, tdefl_create_comp_flags_from_zip_params(), tdefl_init(), TDEFL_STATUS_OKAY, mz_stream_s::total_in, mz_stream_s::total_out, mz_stream_s::zalloc, and mz_stream_s::zfree.

Referenced by mz_deflateInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_deflateReset()

int mz_deflateReset ( mz_streamp pStream )

{
    if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
        return MZ_STREAM_ERROR;
    pStream->total_in = pStream->total_out = 0;
    tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
    return MZ_OK;
}

References MZ_OK, MZ_STREAM_ERROR, mz_stream_s::state, tdefl_init(), mz_stream_s::total_in, mz_stream_s::total_out, mz_stream_s::zalloc, and mz_stream_s::zfree.

Here is the call graph for this function:

◆ mz_error()

const char * mz_error ( int err )

{
    static struct
    {
        int m_err;
        const char *m_pDesc;
    } s_error_descs[] =
        {
          { MZ_OK, "" }, { MZ_STREAM_END, "stream end" }, { MZ_NEED_DICT, "need dictionary" }, { MZ_ERRNO, "file error" }, { MZ_STREAM_ERROR, "stream error" }, { MZ_DATA_ERROR, "data error" }, { MZ_MEM_ERROR, "out of memory" }, { MZ_BUF_ERROR, "buf error" }, { MZ_VERSION_ERROR, "version error" }, { MZ_PARAM_ERROR, "parameter error" }
        };
    mz_uint i;
    for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i)
        if (s_error_descs[i].m_err == err)
            return s_error_descs[i].m_pDesc;
    return NULL;
}

References MZ_BUF_ERROR, MZ_DATA_ERROR, MZ_ERRNO, MZ_MEM_ERROR, MZ_NEED_DICT, MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_END, MZ_STREAM_ERROR, and MZ_VERSION_ERROR.

◆ mz_free()

void mz_free ( void * p )

{
    MZ_FREE(p);
}

References MZ_FREE.

Referenced by Slic3r::GCodeThumbnails::CompressedPNG::~CompressedPNG(), Slic3r::_3MF_Exporter::_add_thumbnail_file_to_archive(), and Slic3r::write_thumbnail().

Here is the caller graph for this function:

◆ mz_inflate()

int mz_inflate	(	mz_streamp	pStream,
		int	flush
	)

{
    inflate_state *pState;
    mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32;
    size_t in_bytes, out_bytes, orig_avail_in;
    tinfl_status status;
 
    if ((!pStream) || (!pStream->state))
        return MZ_STREAM_ERROR;
    if (flush == MZ_PARTIAL_FLUSH)
        flush = MZ_SYNC_FLUSH;
    if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH))
        return MZ_STREAM_ERROR;
 
    pState = (inflate_state *)pStream->state;
    if (pState->m_window_bits > 0)
        decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
    orig_avail_in = pStream->avail_in;
 
    first_call = pState->m_first_call;
    pState->m_first_call = 0;
    if (pState->m_last_status < 0)
        return MZ_DATA_ERROR;
 
    if (pState->m_has_flushed && (flush != MZ_FINISH))
        return MZ_STREAM_ERROR;
    pState->m_has_flushed |= (flush == MZ_FINISH);
 
    if ((flush == MZ_FINISH) && (first_call))
    {
        /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */
        decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF;
        in_bytes = pStream->avail_in;
        out_bytes = pStream->avail_out;
        status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags);
        pState->m_last_status = status;
        pStream->next_in += (mz_uint)in_bytes;
        pStream->avail_in -= (mz_uint)in_bytes;
        pStream->total_in += (mz_uint)in_bytes;
        pStream->adler = tinfl_get_adler32(&pState->m_decomp);
        pStream->next_out += (mz_uint)out_bytes;
        pStream->avail_out -= (mz_uint)out_bytes;
        pStream->total_out += (mz_uint)out_bytes;
 
        if (status < 0)
            return MZ_DATA_ERROR;
        else if (status != TINFL_STATUS_DONE)
        {
            pState->m_last_status = TINFL_STATUS_FAILED;
            return MZ_BUF_ERROR;
        }
        return MZ_STREAM_END;
    }
    /* flush != MZ_FINISH then we must assume there's more input. */
    if (flush != MZ_FINISH)
        decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT;
 
    if (pState->m_dict_avail)
    {
        n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
        memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
        pStream->next_out += n;
        pStream->avail_out -= n;
        pStream->total_out += n;
        pState->m_dict_avail -= n;
        pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
        return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
    }
 
    for (;;)
    {
        in_bytes = pStream->avail_in;
        out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs;
 
        status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags);
        pState->m_last_status = status;
 
        pStream->next_in += (mz_uint)in_bytes;
        pStream->avail_in -= (mz_uint)in_bytes;
        pStream->total_in += (mz_uint)in_bytes;
        pStream->adler = tinfl_get_adler32(&pState->m_decomp);
 
        pState->m_dict_avail = (mz_uint)out_bytes;
 
        n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
        memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
        pStream->next_out += n;
        pStream->avail_out -= n;
        pStream->total_out += n;
        pState->m_dict_avail -= n;
        pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
 
        if (status < 0)
            return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */
        else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in))
            return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */
        else if (flush == MZ_FINISH)
        {
            /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */
            if (status == TINFL_STATUS_DONE)
                return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END;
            /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong. */
            else if (!pStream->avail_out)
                return MZ_BUF_ERROR;
        }
        else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail))
            break;
    }
 
    return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
}

References mz_stream_s::adler, mz_stream_s::avail_in, mz_stream_s::avail_out, inflate_state::m_decomp, inflate_state::m_dict, inflate_state::m_dict_avail, inflate_state::m_dict_ofs, inflate_state::m_first_call, inflate_state::m_has_flushed, inflate_state::m_last_status, inflate_state::m_window_bits, MZ_BUF_ERROR, MZ_DATA_ERROR, MZ_FINISH, MZ_MIN, MZ_OK, MZ_PARTIAL_FLUSH, MZ_STREAM_END, MZ_STREAM_ERROR, MZ_SYNC_FLUSH, mz_stream_s::next_in, mz_stream_s::next_out, mz_stream_s::state, tinfl_decompress(), TINFL_FLAG_COMPUTE_ADLER32, TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_PARSE_ZLIB_HEADER, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_get_adler32, TINFL_LZ_DICT_SIZE, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, TINFL_STATUS_NEEDS_MORE_INPUT, mz_stream_s::total_in, and mz_stream_s::total_out.

Referenced by mz_uncompress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_inflateEnd()

int mz_inflateEnd ( mz_streamp pStream )

{
    if (!pStream)
        return MZ_STREAM_ERROR;
    if (pStream->state)
    {
        pStream->zfree(pStream->opaque, pStream->state);
        pStream->state = NULL;
    }
    return MZ_OK;
}

References MZ_OK, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::state, and mz_stream_s::zfree.

Referenced by mz_uncompress().

Here is the caller graph for this function:

◆ mz_inflateInit()

int mz_inflateInit ( mz_streamp pStream )

{
    return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS);
}

References MZ_DEFAULT_WINDOW_BITS, and mz_inflateInit2().

Referenced by mz_uncompress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_inflateInit2()

int mz_inflateInit2	(	mz_streamp	pStream,
		int	window_bits
	)

{
    inflate_state *pDecomp;
    if (!pStream)
        return MZ_STREAM_ERROR;
    if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))
        return MZ_PARAM_ERROR;
 
    pStream->data_type = 0;
    pStream->adler = 0;
    pStream->msg = NULL;
    pStream->total_in = 0;
    pStream->total_out = 0;
    pStream->reserved = 0;
    if (!pStream->zalloc)
        pStream->zalloc = miniz_def_alloc_func;
    if (!pStream->zfree)
        pStream->zfree = miniz_def_free_func;
 
    pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
    if (!pDecomp)
        return MZ_MEM_ERROR;
 
    pStream->state = (struct mz_internal_state *)pDecomp;
 
    tinfl_init(&pDecomp->m_decomp);
    pDecomp->m_dict_ofs = 0;
    pDecomp->m_dict_avail = 0;
    pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
    pDecomp->m_first_call = 1;
    pDecomp->m_has_flushed = 0;
    pDecomp->m_window_bits = window_bits;
 
    return MZ_OK;
}

References mz_stream_s::adler, mz_stream_s::data_type, inflate_state::m_decomp, inflate_state::m_dict_avail, inflate_state::m_dict_ofs, inflate_state::m_first_call, inflate_state::m_has_flushed, inflate_state::m_last_status, inflate_state::m_window_bits, miniz_def_alloc_func(), miniz_def_free_func(), mz_stream_s::msg, MZ_DEFAULT_WINDOW_BITS, MZ_MEM_ERROR, MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::reserved, mz_stream_s::state, tinfl_init, TINFL_STATUS_NEEDS_MORE_INPUT, mz_stream_s::total_in, mz_stream_s::total_out, mz_stream_s::zalloc, and mz_stream_s::zfree.

Referenced by mz_inflateInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_inflateReset()

int mz_inflateReset ( mz_streamp pStream )

{
    inflate_state *pDecomp;
    if (!pStream)
        return MZ_STREAM_ERROR;
 
    pStream->data_type = 0;
    pStream->adler = 0;
    pStream->msg = NULL;
    pStream->total_in = 0;
    pStream->total_out = 0;
    pStream->reserved = 0;
 
    pDecomp = (inflate_state *)pStream->state;
 
    tinfl_init(&pDecomp->m_decomp);
    pDecomp->m_dict_ofs = 0;
    pDecomp->m_dict_avail = 0;
    pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
    pDecomp->m_first_call = 1;
    pDecomp->m_has_flushed = 0;
    /* pDecomp->m_window_bits = window_bits */;
 
    return MZ_OK;
}

References mz_stream_s::adler, mz_stream_s::data_type, inflate_state::m_decomp, inflate_state::m_dict_avail, inflate_state::m_dict_ofs, inflate_state::m_first_call, inflate_state::m_has_flushed, inflate_state::m_last_status, mz_stream_s::msg, MZ_OK, MZ_STREAM_ERROR, mz_stream_s::reserved, mz_stream_s::state, tinfl_init, TINFL_STATUS_NEEDS_MORE_INPUT, mz_stream_s::total_in, and mz_stream_s::total_out.

◆ mz_uncompress()

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

{
    mz_stream stream;
    int status;
    memset(&stream, 0, sizeof(stream));
 
    /* In case mz_ulong is 64-bits (argh I hate longs). */
    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
        return MZ_PARAM_ERROR;
 
    stream.next_in = pSource;
    stream.avail_in = (mz_uint32)source_len;
    stream.next_out = pDest;
    stream.avail_out = (mz_uint32)*pDest_len;
 
    status = mz_inflateInit(&stream);
    if (status != MZ_OK)
        return status;
 
    status = mz_inflate(&stream, MZ_FINISH);
    if (status != MZ_STREAM_END)
    {
        mz_inflateEnd(&stream);
        return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
    }
    *pDest_len = stream.total_out;
 
    return mz_inflateEnd(&stream);
}

References mz_stream_s::avail_in, mz_stream_s::avail_out, MZ_BUF_ERROR, MZ_DATA_ERROR, MZ_FINISH, mz_inflate(), mz_inflateEnd(), mz_inflateInit(), MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_END, mz_stream_s::next_in, mz_stream_s::next_out, and mz_stream_s::total_out.

Here is the call graph for this function:

◆ mz_version()

const char * mz_version ( void )

{
    return MZ_VERSION;
}

References MZ_VERSION.

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

{
    return mz_zip_add_mem_to_archive_file_in_place_v2(pZip_filename, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, NULL);
}

References mz_zip_add_mem_to_archive_file_in_place_v2().

Here is the call graph for this function:

◆ 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_bool status, created_new_archive = MZ_FALSE;
    mz_zip_archive zip_archive;
    struct MZ_FILE_STAT_STRUCT file_stat;
    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
 
    mz_zip_zero_struct(&zip_archive);
    if ((int)level_and_flags < 0)
        level_and_flags = MZ_DEFAULT_LEVEL;
 
    if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION))
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_PARAMETER;
        return MZ_FALSE;
    }
 
    if (!mz_zip_writer_validate_archive_name(pArchive_name))
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_FILENAME;
        return MZ_FALSE;
    }
 
    /* Important: The regular non-64 bit version of stat() can fail here if the file is very large, which could cause the archive to be overwritten. */
    /* So be sure to compile with _LARGEFILE64_SOURCE 1 */
    if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0)
    {
        /* Create a new archive. */
        if (!mz_zip_writer_init_file_v2(&zip_archive, pZip_filename, 0, level_and_flags))
        {
            if (pErr)
                *pErr = zip_archive.m_last_error;
            return MZ_FALSE;
        }
 
        created_new_archive = MZ_TRUE;
    }
    else
    {
        /* Append to an existing archive. */
        if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
        {
            if (pErr)
                *pErr = zip_archive.m_last_error;
            return MZ_FALSE;
        }
 
        if (!mz_zip_writer_init_from_reader_v2(&zip_archive, pZip_filename, level_and_flags))
        {
            if (pErr)
                *pErr = zip_archive.m_last_error;
 
            mz_zip_reader_end_internal(&zip_archive, MZ_FALSE);
 
            return MZ_FALSE;
        }
    }
 
    status = mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);
    actual_err = zip_archive.m_last_error;
 
    /* Always finalize, even if adding failed for some reason, so we have a valid central directory. (This may not always succeed, but we can try.) */
    if (!mz_zip_writer_finalize_archive(&zip_archive))
    {
        if (!actual_err)
            actual_err = zip_archive.m_last_error;
 
        status = MZ_FALSE;
    }
 
    if (!mz_zip_writer_end_internal(&zip_archive, status))
    {
        if (!actual_err)
            actual_err = zip_archive.m_last_error;
 
        status = MZ_FALSE;
    }
 
    if ((!status) && (created_new_archive))
    {
        /* It's a new archive and something went wrong, so just delete it. */
        int ignoredStatus = MZ_DELETE_FILE(pZip_filename);
        (void)ignoredStatus;
    }
 
    if (pErr)
        *pErr = actual_err;
 
    return status;
}

References mz_zip_archive::m_last_error, MZ_DEFAULT_LEVEL, MZ_DELETE_FILE, MZ_FALSE, MZ_FILE_STAT, MZ_FILE_STAT_STRUCT, MZ_TRUE, MZ_UBER_COMPRESSION, MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, MZ_ZIP_INVALID_FILENAME, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, mz_zip_reader_end_internal(), mz_zip_reader_init_file_v2(), mz_zip_writer_add_mem_ex(), mz_zip_writer_end_internal(), mz_zip_writer_finalize_archive(), mz_zip_writer_init_file_v2(), mz_zip_writer_init_from_reader_v2(), mz_zip_writer_validate_archive_name(), mz_zip_zero_struct(), and void().

Referenced by mz_zip_add_mem_to_archive_file_in_place().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_clear_last_error()

mz_zip_error mz_zip_clear_last_error ( mz_zip_archive * pZip )

{
    return mz_zip_set_last_error(pZip, MZ_ZIP_NO_ERROR);
}

References MZ_ZIP_NO_ERROR, and mz_zip_set_last_error().

Here is the call graph for this function:

◆ mz_zip_end()

mz_bool mz_zip_end ( mz_zip_archive * pZip )

{
    if (!pZip)
        return MZ_FALSE;
 
    if (pZip->m_zip_mode == MZ_ZIP_MODE_READING)
        return mz_zip_reader_end(pZip);
#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
    else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))
        return mz_zip_writer_end(pZip);
#endif
 
    return MZ_FALSE;
}

References mz_zip_archive::m_zip_mode, MZ_FALSE, MZ_ZIP_MODE_READING, MZ_ZIP_MODE_WRITING, MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED, mz_zip_reader_end(), and mz_zip_writer_end().

Here is the call graph for this function:

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

{
    return mz_zip_extract_archive_file_to_heap_v2(pZip_filename, pArchive_name, NULL, pSize, flags, NULL);
}

References mz_zip_extract_archive_file_to_heap_v2().

Here is the call graph for this function:

◆ 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_uint32 file_index;
    mz_zip_archive zip_archive;
    void *p = NULL;
 
    if (pSize)
        *pSize = 0;
 
    if ((!pZip_filename) || (!pArchive_name))
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_PARAMETER;
 
        return NULL;
    }
 
    mz_zip_zero_struct(&zip_archive);
    if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
    {
        if (pErr)
            *pErr = zip_archive.m_last_error;
 
        return NULL;
    }
 
    if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, &file_index))
    {
        p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags);
    }
 
    mz_zip_reader_end_internal(&zip_archive, p != NULL);
 
    if (pErr)
        *pErr = zip_archive.m_last_error;
 
    return p;
}

References mz_zip_archive::m_last_error, MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, MZ_ZIP_INVALID_PARAMETER, mz_zip_reader_end_internal(), mz_zip_reader_extract_to_heap(), mz_zip_reader_init_file_v2(), mz_zip_reader_locate_file_v2(), and mz_zip_zero_struct().

Referenced by mz_zip_extract_archive_file_to_heap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_get_archive_file_start_offset()

mz_uint64 mz_zip_get_archive_file_start_offset ( mz_zip_archive * pZip )

{
    if ((!pZip) || (!pZip->m_pState))
        return 0;
    return pZip->m_pState->m_file_archive_start_ofs;
}

References mz_zip_internal_state_tag::m_file_archive_start_ofs, and mz_zip_archive::m_pState.

◆ mz_zip_get_archive_size()

mz_uint64 mz_zip_get_archive_size ( mz_zip_archive * pZip )

{
    if (!pZip)
        return 0;
    return pZip->m_archive_size;
}

References mz_zip_archive::m_archive_size.

◆ mz_zip_get_central_dir_size()

size_t mz_zip_get_central_dir_size ( mz_zip_archive * pZip )

{
    if ((!pZip) || (!pZip->m_pState))
        return 0;
 
    return pZip->m_pState->m_central_dir.m_size;
}

References mz_zip_internal_state_tag::m_central_dir, mz_zip_archive::m_pState, and mz_zip_array::m_size.

◆ mz_zip_get_cfile()

MZ_FILE * mz_zip_get_cfile ( mz_zip_archive * pZip )

{
    if ((!pZip) || (!pZip->m_pState))
        return 0;
    return pZip->m_pState->m_pFile;
}

References mz_zip_internal_state_tag::m_pFile, and mz_zip_archive::m_pState.

Referenced by Slic3r::anonymous_namespace{miniz_extension.cpp}::close_zip().

Here is the caller graph for this function:

◆ mz_zip_get_error_string()

const char * mz_zip_get_error_string ( mz_zip_error mz_err )

{
    switch (mz_err)
    {
        case MZ_ZIP_NO_ERROR:
            return "no error";
        case MZ_ZIP_UNDEFINED_ERROR:
            return "undefined error";
        case MZ_ZIP_TOO_MANY_FILES:
            return "too many files";
        case MZ_ZIP_FILE_TOO_LARGE:
            return "file too large";
        case MZ_ZIP_UNSUPPORTED_METHOD:
            return "unsupported method";
        case MZ_ZIP_UNSUPPORTED_ENCRYPTION:
            return "unsupported encryption";
        case MZ_ZIP_UNSUPPORTED_FEATURE:
            return "unsupported feature";
        case MZ_ZIP_FAILED_FINDING_CENTRAL_DIR:
            return "failed finding central directory";
        case MZ_ZIP_NOT_AN_ARCHIVE:
            return "not a ZIP archive";
        case MZ_ZIP_INVALID_HEADER_OR_CORRUPTED:
            return "invalid header or archive is corrupted";
        case MZ_ZIP_UNSUPPORTED_MULTIDISK:
            return "unsupported multidisk archive";
        case MZ_ZIP_DECOMPRESSION_FAILED:
            return "decompression failed or archive is corrupted";
        case MZ_ZIP_COMPRESSION_FAILED:
            return "compression failed";
        case MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE:
            return "unexpected decompressed size";
        case MZ_ZIP_CRC_CHECK_FAILED:
            return "CRC-32 check failed";
        case MZ_ZIP_UNSUPPORTED_CDIR_SIZE:
            return "unsupported central directory size";
        case MZ_ZIP_ALLOC_FAILED:
            return "allocation failed";
        case MZ_ZIP_FILE_OPEN_FAILED:
            return "file open failed";
        case MZ_ZIP_FILE_CREATE_FAILED:
            return "file create failed";
        case MZ_ZIP_FILE_WRITE_FAILED:
            return "file write failed";
        case MZ_ZIP_FILE_READ_FAILED:
            return "file read failed";
        case MZ_ZIP_FILE_CLOSE_FAILED:
            return "file close failed";
        case MZ_ZIP_FILE_SEEK_FAILED:
            return "file seek failed";
        case MZ_ZIP_FILE_STAT_FAILED:
            return "file stat failed";
        case MZ_ZIP_INVALID_PARAMETER:
            return "invalid parameter";
        case MZ_ZIP_INVALID_FILENAME:
            return "invalid filename";
        case MZ_ZIP_BUF_TOO_SMALL:
            return "buffer too small";
        case MZ_ZIP_INTERNAL_ERROR:
            return "internal error";
        case MZ_ZIP_FILE_NOT_FOUND:
            return "file not found";
        case MZ_ZIP_ARCHIVE_TOO_LARGE:
            return "archive is too large";
        case MZ_ZIP_VALIDATION_FAILED:
            return "validation failed";
        case MZ_ZIP_WRITE_CALLBACK_FAILED:
            return "write calledback failed";
        default:
            break;
    }
 
    return "unknown error";
}

References MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARCHIVE_TOO_LARGE, MZ_ZIP_BUF_TOO_SMALL, MZ_ZIP_COMPRESSION_FAILED, MZ_ZIP_CRC_CHECK_FAILED, MZ_ZIP_DECOMPRESSION_FAILED, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR, MZ_ZIP_FILE_CLOSE_FAILED, MZ_ZIP_FILE_CREATE_FAILED, MZ_ZIP_FILE_NOT_FOUND, MZ_ZIP_FILE_OPEN_FAILED, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FILE_SEEK_FAILED, MZ_ZIP_FILE_STAT_FAILED, MZ_ZIP_FILE_TOO_LARGE, MZ_ZIP_FILE_WRITE_FAILED, MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_FILENAME, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, MZ_ZIP_NOT_AN_ARCHIVE, MZ_ZIP_TOO_MANY_FILES, MZ_ZIP_UNDEFINED_ERROR, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, MZ_ZIP_UNSUPPORTED_CDIR_SIZE, MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_FEATURE, MZ_ZIP_UNSUPPORTED_METHOD, MZ_ZIP_UNSUPPORTED_MULTIDISK, MZ_ZIP_VALIDATION_FAILED, and MZ_ZIP_WRITE_CALLBACK_FAILED.

Referenced by Slic3r::GUI::Plater::preview_zip_archive().

Here is the caller graph for this function:

◆ mz_zip_get_last_error()

mz_zip_error mz_zip_get_last_error ( mz_zip_archive * pZip )

{
    mz_zip_error prev_err;
 
    if (!pZip)
        return MZ_ZIP_INVALID_PARAMETER;
 
    prev_err = pZip->m_last_error;
 
    pZip->m_last_error = MZ_ZIP_NO_ERROR;
    return prev_err;
}

References mz_zip_archive::m_last_error, MZ_ZIP_INVALID_PARAMETER, and MZ_ZIP_NO_ERROR.

Referenced by Slic3r::GUI::Plater::preview_zip_archive().

Here is the caller graph for this function:

◆ mz_zip_get_mode()

mz_zip_mode mz_zip_get_mode ( mz_zip_archive * pZip )

{
    return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID;
}

References mz_zip_archive::m_zip_mode, and MZ_ZIP_MODE_INVALID.

◆ mz_zip_get_type()

mz_zip_type mz_zip_get_type ( mz_zip_archive * pZip )

{
    return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID;
}

References mz_zip_archive::m_zip_type, and MZ_ZIP_TYPE_INVALID.

◆ mz_zip_is_zip64()

mz_bool mz_zip_is_zip64 ( mz_zip_archive * pZip )

{
    if ((!pZip) || (!pZip->m_pState))
        return MZ_FALSE;
 
    return pZip->m_pState->m_zip64;
}

References mz_zip_archive::m_pState, mz_zip_internal_state_tag::m_zip64, and MZ_FALSE.

◆ mz_zip_peek_last_error()

mz_zip_error mz_zip_peek_last_error ( mz_zip_archive * pZip )

{
    if (!pZip)
        return MZ_ZIP_INVALID_PARAMETER;
 
    return pZip->m_last_error;
}

References mz_zip_archive::m_last_error, and MZ_ZIP_INVALID_PARAMETER.

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

{
    if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    return pZip->m_pRead(pZip->m_pIO_opaque, file_ofs, pBuf, n);
}

References mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

Here is the call graph for this function:

◆ mz_zip_reader_end()

mz_bool mz_zip_reader_end ( mz_zip_archive * pZip )

{
    return mz_zip_reader_end_internal(pZip, MZ_TRUE);
}

References MZ_TRUE, and mz_zip_reader_end_internal().

Referenced by Slic3r::anonymous_namespace{miniz_extension.cpp}::close_zip(), and mz_zip_end().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_uint32 file_index;
 
    /* Locate file index by name */
    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
        return NULL;
 
    /* Construct iterator */
    return mz_zip_reader_extract_iter_new(pZip, file_index, flags);
}

References mz_zip_reader_extract_iter_new(), and mz_zip_reader_locate_file_v2().

Here is the call graph for this function:

◆ 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_uint32 file_index;
    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
        return MZ_FALSE;
 
    return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, flags);
}

References MZ_FALSE, mz_zip_reader_extract_to_callback(), and mz_zip_reader_locate_file_v2().

Here is the call graph for this function:

◆ 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_uint32 file_index;
    if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
        return MZ_FALSE;
 
    return mz_zip_reader_extract_to_cfile(pZip, file_index, pFile, flags);
}

References MZ_FALSE, mz_zip_reader_extract_to_cfile(), and mz_zip_reader_locate_file_v2().

Here is the call graph for this function:

◆ 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_uint32 file_index;
    if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
        return MZ_FALSE;
 
    return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags);
}

References MZ_FALSE, mz_zip_reader_extract_to_file(), and mz_zip_reader_locate_file_v2().

Here is the call graph for this function:

◆ 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_uint32 file_index;
    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
    {
        if (pSize)
            *pSize = 0;
        return MZ_FALSE;
    }
    return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
}

References MZ_FALSE, mz_zip_reader_extract_to_heap(), and mz_zip_reader_locate_file_v2().

Here is the call graph for this function:

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

{
    return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, buf_size, flags, NULL, 0);
}

References mz_zip_reader_extract_file_to_mem_no_alloc().

Here is the call graph for this function:

◆ 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_uint32 file_index;
    if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
        return MZ_FALSE;
    return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size);
}

References MZ_FALSE, mz_zip_reader_extract_to_mem_no_alloc(), and mz_zip_reader_locate_file_v2().

Referenced by mz_zip_reader_extract_file_to_mem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_reader_extract_iter_free()

mz_bool mz_zip_reader_extract_iter_free ( mz_zip_reader_extract_iter_state * pState )

{
    int status;
 
    /* Argument sanity check */
    if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState))
        return MZ_FALSE;
 
    /* Was decompression completed and requested? */
    if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
    {
        /* Make sure the entire file was decompressed, and check its CRC. */
        if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size)
        {
            mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
            pState->status = TINFL_STATUS_FAILED;
        }
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
        else if (pState->file_crc32 != pState->file_stat.m_crc32)
        {
            mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
            pState->status = TINFL_STATUS_FAILED;
        }
#endif
    }
 
    /* Free buffers */
    if (!pState->pZip->m_pState->m_pMem)
        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf);
    if (pState->pWrite_buf)
        pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf);
 
    /* Save status */
    status = pState->status;
 
    /* Free context */
    pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState);
 
    return status == TINFL_STATUS_DONE;
}

Here is the call graph for this function:

◆ 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_state *pState;
    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
 
    /* Argument sanity check */
    if ((!pZip) || (!pZip->m_pState))
        return NULL;
 
    /* Allocate an iterator status structure */
    pState = (mz_zip_reader_extract_iter_state*)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_reader_extract_iter_state));
    if (!pState)
    {
        mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        return NULL;
    }
 
    /* Fetch file details */
    if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat))
    {
        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
        return NULL;
    }
 
    /* Encryption and patch files are not supported. */
    if (pState->file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
        return NULL;
    }
 
    /* This function only supports decompressing stored and deflate. */
    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED))
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
        return NULL;
    }
 
    /* Init state - save args */
    pState->pZip = pZip;
    pState->flags = flags;
 
    /* Init state - reset variables to defaults */
    pState->status = TINFL_STATUS_DONE;
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
    pState->file_crc32 = MZ_CRC32_INIT;
#endif
    pState->read_buf_ofs = 0;
    pState->out_buf_ofs = 0;
    pState->pRead_buf = NULL;
    pState->pWrite_buf = NULL;
    pState->out_blk_remain = 0;
 
    /* Read and parse the local directory entry. */
    pState->cur_file_ofs = pState->file_stat.m_local_header_ofs;
    if (pZip->m_pRead(pZip->m_pIO_opaque, pState->cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
    {
        mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
        return NULL;
    }
 
    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
        return NULL;
    }
 
    pState->cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
    if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > pZip->m_archive_size)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
        pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
        return NULL;
    }
 
    /* Decompress the file either directly from memory or from a file input buffer. */
    if (pZip->m_pState->m_pMem)
    {
        pState->pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + pState->cur_file_ofs;
        pState->read_buf_size = pState->read_buf_avail = pState->file_stat.m_comp_size;
        pState->comp_remaining = pState->file_stat.m_comp_size;
    }
    else
    {
        if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
        {
            /* Decompression required, therefore intermediate read buffer required */
            pState->read_buf_size = MZ_MIN(pState->file_stat.m_comp_size, MZ_ZIP_MAX_IO_BUF_SIZE);
            if (NULL == (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)pState->read_buf_size)))
            {
                mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
                pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
                return NULL;
            }
        }
        else
        {
            /* Decompression not required - we will be reading directly into user buffer, no temp buf required */
            pState->read_buf_size = 0;
        }
        pState->read_buf_avail = 0;
        pState->comp_remaining = pState->file_stat.m_comp_size;
    }
 
    if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
    {
        /* Decompression required, init decompressor */
        tinfl_init( &pState->inflator );
 
        /* Allocate write buffer */
        if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
        {
            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
            if (pState->pRead_buf)
                pZip->m_pFree(pZip->m_pAlloc_opaque, pState->pRead_buf);
            pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
            return NULL;
        }
    }
 
    return pState;
}

Referenced by mz_zip_reader_extract_file_iter_new().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    size_t copied_to_caller = 0;
 
    /* Argument sanity check */
    if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf))
        return 0;
 
    if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))
    {
        /* The file is stored or the caller has requested the compressed data, calc amount to return. */
        copied_to_caller = (size_t)MZ_MIN( buf_size, pState->comp_remaining );
 
        /* Zip is in memory....or requires reading from a file? */
        if (pState->pZip->m_pState->m_pMem)
        {
            /* Copy data to caller's buffer */
            memcpy( pvBuf, pState->pRead_buf, copied_to_caller );
            pState->pRead_buf = ((mz_uint8*)pState->pRead_buf) + copied_to_caller;
        }
        else
        {
            /* Read directly into caller's buffer */
            if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pvBuf, copied_to_caller) != copied_to_caller)
            {
                /* Failed to read all that was asked for, flag failure and alert user */
                mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
                pState->status = TINFL_STATUS_FAILED;
                copied_to_caller = 0;
            }
        }
 
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
        /* Compute CRC if not returning compressed data only */
        if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
            pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, (const mz_uint8 *)pvBuf, copied_to_caller);
#endif
 
        /* Advance offsets, dec counters */
        pState->cur_file_ofs += copied_to_caller;
        pState->out_buf_ofs += copied_to_caller;
        pState->comp_remaining -= copied_to_caller;
    }
    else
    {
        do
        {
            /* Calc ptr to write buffer - given current output pos and block size */
            mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pState->pWrite_buf + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
 
            /* Calc max output size - given current output pos and block size */
            size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
 
            if (!pState->out_blk_remain)
            {
                /* Read more data from file if none available (and reading from file) */
                if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem))
                {
                    /* Calc read size */
                    pState->read_buf_avail = MZ_MIN(pState->read_buf_size, pState->comp_remaining);
                    if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pState->pRead_buf, (size_t)pState->read_buf_avail) != pState->read_buf_avail)
                    {
                        mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
                        pState->status = TINFL_STATUS_FAILED;
                        break;
                    }
 
                    /* Advance offsets, dec counters */
                    pState->cur_file_ofs += pState->read_buf_avail;
                    pState->comp_remaining -= pState->read_buf_avail;
                    pState->read_buf_ofs = 0;
                }
 
                /* Perform decompression */
                in_buf_size = (size_t)pState->read_buf_avail;
                pState->status = tinfl_decompress(&pState->inflator, (const mz_uint8 *)pState->pRead_buf + pState->read_buf_ofs, &in_buf_size, (mz_uint8 *)pState->pWrite_buf, pWrite_buf_cur, &out_buf_size, pState->comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
                pState->read_buf_avail -= in_buf_size;
                pState->read_buf_ofs += in_buf_size;
 
                /* Update current output block size remaining */
                pState->out_blk_remain = out_buf_size;
            }
 
            if (pState->out_blk_remain)
            {
                /* Calc amount to return. */
                size_t to_copy = MZ_MIN( (buf_size - copied_to_caller), pState->out_blk_remain );
 
                /* Copy data to caller's buffer */
                memcpy( (uint8_t*)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy );
 
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
                /* Perform CRC */
                pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, pWrite_buf_cur, to_copy);
#endif
 
                /* Decrement data consumed from block */
                pState->out_blk_remain -= to_copy;
 
                /* Inc output offset, while performing sanity check */
                if ((pState->out_buf_ofs += to_copy) > pState->file_stat.m_uncomp_size)
                {
                    mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
                    pState->status = TINFL_STATUS_FAILED;
                    break;
                }
 
                /* Increment counter of data copied to caller */
                copied_to_caller += to_copy;
            }
        } while ( (copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT)) );
    }
 
    /* Return how many bytes were copied into user buffer */
    return copied_to_caller;
}

Here is the call graph for this function:

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

{
    int status = TINFL_STATUS_DONE;
    mz_uint file_crc32 = MZ_CRC32_INIT;
    mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;
    mz_zip_archive_file_stat file_stat;
    void *pRead_buf = NULL;
    void *pWrite_buf = NULL;
    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
 
    if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
        return MZ_FALSE;
 
    /* A directory or zero length file */
    if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
        return MZ_TRUE;
 
    /* Encryption and patch files are not supported. */
    if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
 
    /* This function only supports decompressing stored and deflate. */
    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
 
    /* Read and do some minimal validation of the local directory entry (this doesn't crack the zip64 stuff, which we already have from the central dir) */
    cur_file_ofs = file_stat.m_local_header_ofs;
    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 
    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
    if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    /* Decompress the file either directly from memory or from a file input buffer. */
    if (pZip->m_pState->m_pMem)
    {
        pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
        read_buf_size = read_buf_avail = file_stat.m_comp_size;
        comp_remaining = 0;
    }
    else
    {
        read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
        if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
        read_buf_avail = 0;
        comp_remaining = file_stat.m_comp_size;
    }
 
    if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
    {
        /* The file is stored or the caller has requested the compressed data. */
        if (pZip->m_pState->m_pMem)
        {
            if (((sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > MZ_UINT32_MAX))
                return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 
            if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
            {
                mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
                status = TINFL_STATUS_FAILED;
            }
            else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
            {
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
                file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)file_stat.m_comp_size);
#endif
            }
 
            cur_file_ofs += file_stat.m_comp_size;
            out_buf_ofs += file_stat.m_comp_size;
            comp_remaining = 0;
        }
        else
        {
            while (comp_remaining)
            {
                read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
                if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
                {
                    mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
                    status = TINFL_STATUS_FAILED;
                    break;
                }
 
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
                if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
                {
                    file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail);
                }
#endif
 
                if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
                {
                    mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
                    status = TINFL_STATUS_FAILED;
                    break;
                }
 
                cur_file_ofs += read_buf_avail;
                out_buf_ofs += read_buf_avail;
                comp_remaining -= read_buf_avail;
            }
        }
    }
    else
    {
        tinfl_decompressor inflator;
        tinfl_init(&inflator);
 
        if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
        {
            mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
            status = TINFL_STATUS_FAILED;
        }
        else
        {
            do
            {
                mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
                size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
                if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
                {
                    read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
                    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
                    {
                        mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
                        status = TINFL_STATUS_FAILED;
                        break;
                    }
                    cur_file_ofs += read_buf_avail;
                    comp_remaining -= read_buf_avail;
                    read_buf_ofs = 0;
                }
 
                in_buf_size = (size_t)read_buf_avail;
                status = tinfl_decompress(&inflator, (const mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pWrite_buf, pWrite_buf_cur, &out_buf_size, comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
                read_buf_avail -= in_buf_size;
                read_buf_ofs += in_buf_size;
 
                if (out_buf_size)
                {
                    if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)
                    {
                        mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
                        status = TINFL_STATUS_FAILED;
                        break;
                    }
 
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
                    file_crc32 = (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size);
#endif
                    if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size)
                    {
                        mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
                        status = TINFL_STATUS_FAILED;
                        break;
                    }
                }
            } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT));
        }
    }
 
    if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
    {
        /* Make sure the entire file was decompressed, and check its CRC. */
        if (out_buf_ofs != file_stat.m_uncomp_size)
        {
            mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
            status = TINFL_STATUS_FAILED;
        }
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
        else if (file_crc32 != file_stat.m_crc32)
        {
            mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
            status = TINFL_STATUS_FAILED;
        }
#endif
    }
 
    if (!pZip->m_pState->m_pMem)
        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
 
    if (pWrite_buf)
        pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf);
 
    return status == TINFL_STATUS_DONE;
}

References mz_zip_archive::m_archive_size, mz_zip_archive_file_stat::m_bit_flag, mz_zip_archive_file_stat::m_comp_size, mz_zip_archive_file_stat::m_crc32, mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_local_header_ofs, mz_zip_archive_file_stat::m_method, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive_file_stat::m_uncomp_size, mz_crc32(), MZ_CRC32_INIT, MZ_DEFLATED, MZ_FALSE, MZ_MIN, MZ_READ_LE16, MZ_READ_LE32, MZ_TRUE, MZ_UINT32_MAX, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_DECOMPRESSION_FAILED, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FLAG_COMPRESSED_DATA, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_EXTRA_LEN_OFS, MZ_ZIP_LDH_FILENAME_LEN_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MAX_IO_BUF_SIZE, mz_zip_reader_file_stat(), mz_zip_set_error(), MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_METHOD, MZ_ZIP_WRITE_CALLBACK_FAILED, tinfl_decompress(), TINFL_FLAG_HAS_MORE_INPUT, tinfl_init, TINFL_LZ_DICT_SIZE, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, TINFL_STATUS_HAS_MORE_OUTPUT, and TINFL_STATUS_NEEDS_MORE_INPUT.

Referenced by Slic3r::_3MF_Importer::_extract_model_from_archive(), Slic3r::extract_model_from_archive(), mz_zip_reader_extract_file_to_callback(), mz_zip_reader_extract_to_cfile(), mz_zip_reader_extract_to_file(), and mz_zip_validate_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_reader_extract_to_cfile()

mz_bool mz_zip_reader_extract_to_cfile	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		MZ_FILE *	File,
		mz_uint	flags
	)

{
    mz_zip_archive_file_stat file_stat;
 
    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
        return MZ_FALSE;
 
    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
 
    return mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
}

References mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_is_supported, MZ_FALSE, mz_zip_file_write_callback(), mz_zip_reader_extract_to_callback(), mz_zip_reader_file_stat(), mz_zip_set_error(), and MZ_ZIP_UNSUPPORTED_FEATURE.

Referenced by mz_zip_reader_extract_file_to_cfile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_bool status;
    mz_zip_archive_file_stat file_stat;
    MZ_FILE *pFile;
 
    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
        return MZ_FALSE;
 
    if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
 
    pFile = MZ_FOPEN(pDst_filename, "wb");
    if (!pFile)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
 
    status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
 
    if (MZ_FCLOSE(pFile) == EOF)
    {
        if (status)
            mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
 
        status = MZ_FALSE;
    }
 
#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
    if (status)
        mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time);
#endif
 
    return status;
}

References mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_is_supported, mz_zip_archive_file_stat::m_time, MZ_FALSE, MZ_FCLOSE, MZ_FILE, MZ_FOPEN, MZ_ZIP_FILE_CLOSE_FAILED, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_write_callback(), mz_zip_reader_extract_to_callback(), mz_zip_reader_file_stat(), mz_zip_set_error(), mz_zip_set_file_times(), and MZ_ZIP_UNSUPPORTED_FEATURE.

Referenced by mz_zip_reader_extract_file_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_uint64 comp_size, uncomp_size, alloc_size;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    void *pBuf;
 
    if (pSize)
        *pSize = 0;
 
    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return NULL;
    }
 
    comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
    uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
 
    alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? comp_size : uncomp_size;
    if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
    {
        mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
        return NULL;
    }
 
    if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
    {
        mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        return NULL;
    }
 
    if (!mz_zip_reader_extract_to_mem(pZip, file_index, pBuf, (size_t)alloc_size, flags))
    {
        pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
        return NULL;
    }
 
    if (pSize)
        *pSize = (size_t)alloc_size;
    return pBuf;
}

References mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, MZ_READ_LE32, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_ZIP_FLAG_COMPRESSED_DATA, mz_zip_get_cdh(), MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_PARAMETER, mz_zip_reader_extract_to_mem(), and mz_zip_set_error().

Referenced by mz_zip_extract_archive_file_to_heap_v2(), and mz_zip_reader_extract_file_to_heap().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, flags, NULL, 0);
}

References mz_zip_reader_extract_to_mem_no_alloc().

Referenced by Slic3r::_3MF_Importer::_extract_custom_gcode_per_print_z_from_archive(), Slic3r::_3MF_Importer::_extract_cut_information_from_archive(), Slic3r::_3MF_Importer::_extract_layer_config_ranges_from_archive(), Slic3r::_3MF_Importer::_extract_layer_heights_profile_config_from_archive(), Slic3r::_3MF_Importer::_extract_model_config_from_archive(), Slic3r::_3MF_Importer::_extract_print_config_from_archive(), Slic3r::_3MF_Importer::_extract_sla_drain_holes_from_archive(), Slic3r::_3MF_Importer::_extract_sla_support_points_from_archive(), mz_zip_reader_extract_to_heap(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::anonymous_namespace{ZipperArchiveImport.cpp}::read_entry(), Slic3r::anonymous_namespace{ZipperArchiveImport.cpp}::read_ini(), and Slic3r::PresetUpdater::priv::sync_config().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    int status = TINFL_STATUS_DONE;
    mz_uint64 needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;
    mz_zip_archive_file_stat file_stat;
    void *pRead_buf;
    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
    tinfl_decompressor inflator;
 
    if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
        return MZ_FALSE;
 
    /* A directory or zero length file */
    if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
        return MZ_TRUE;
 
    /* Encryption and patch files are not supported. */
    if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
 
    /* This function only supports decompressing stored and deflate. */
    if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
 
    /* Ensure supplied output buffer is large enough. */
    needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size;
    if (buf_size < needed_size)
        return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL);
 
    /* Read and parse the local directory entry. */
    cur_file_ofs = file_stat.m_local_header_ofs;
    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 
    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
    if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
    {
        /* The file is stored or the caller has requested the compressed data. */
        if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, (size_t)needed_size) != needed_size)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
        if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0)
        {
            if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
                return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
        }
#endif
 
        return MZ_TRUE;
    }
 
    /* Decompress the file either directly from memory or from a file input buffer. */
    tinfl_init(&inflator);
 
    if (pZip->m_pState->m_pMem)
    {
        /* Read directly from the archive in memory. */
        pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
        read_buf_size = read_buf_avail = file_stat.m_comp_size;
        comp_remaining = 0;
    }
    else if (pUser_read_buf)
    {
        /* Use a user provided read buffer. */
        if (!user_read_buf_size)
            return MZ_FALSE;
        pRead_buf = (mz_uint8 *)pUser_read_buf;
        read_buf_size = user_read_buf_size;
        read_buf_avail = 0;
        comp_remaining = file_stat.m_comp_size;
    }
    else
    {
        /* Temporarily allocate a read buffer. */
        read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
        if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 
        if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
        read_buf_avail = 0;
        comp_remaining = file_stat.m_comp_size;
    }
 
    do
    {
        /* The size_t cast here should be OK because we've verified that the output buffer is >= file_stat.m_uncomp_size above */
        size_t in_buf_size, out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs);
        if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
        {
            read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
            if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
            {
                status = TINFL_STATUS_FAILED;
                mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
                break;
            }
            cur_file_ofs += read_buf_avail;
            comp_remaining -= read_buf_avail;
            read_buf_ofs = 0;
        }
        in_buf_size = (size_t)read_buf_avail;
        status = tinfl_decompress(&inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0));
        read_buf_avail -= in_buf_size;
        read_buf_ofs += in_buf_size;
        out_buf_ofs += out_buf_size;
    } while (status == TINFL_STATUS_NEEDS_MORE_INPUT);
 
    if (status == TINFL_STATUS_DONE)
    {
        /* Make sure the entire file was decompressed, and check its CRC. */
        if (out_buf_ofs != file_stat.m_uncomp_size)
        {
            mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
            status = TINFL_STATUS_FAILED;
        }
#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
        else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
        {
            mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
            status = TINFL_STATUS_FAILED;
        }
#endif
    }
 
    if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf))
        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
 
    return status == TINFL_STATUS_DONE;
}

References mz_zip_archive::m_archive_size, mz_zip_archive_file_stat::m_bit_flag, mz_zip_archive_file_stat::m_comp_size, mz_zip_archive_file_stat::m_crc32, mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_local_header_ofs, mz_zip_archive_file_stat::m_method, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive_file_stat::m_uncomp_size, mz_crc32(), MZ_CRC32_INIT, MZ_DEFLATED, MZ_FALSE, MZ_MIN, MZ_READ_LE16, MZ_READ_LE32, MZ_TRUE, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_BUF_TOO_SMALL, MZ_ZIP_CRC_CHECK_FAILED, MZ_ZIP_DECOMPRESSION_FAILED, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FLAG_COMPRESSED_DATA, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_EXTRA_LEN_OFS, MZ_ZIP_LDH_FILENAME_LEN_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MAX_IO_BUF_SIZE, mz_zip_reader_file_stat(), mz_zip_set_error(), MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_METHOD, tinfl_decompress(), TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_init, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, and TINFL_STATUS_NEEDS_MORE_INPUT.

Referenced by mz_zip_reader_extract_file_to_mem_no_alloc(), and mz_zip_reader_extract_to_mem().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    return mz_zip_file_stat_internal(pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL);
}

References mz_zip_file_stat_internal(), and mz_zip_get_cdh().

Referenced by Slic3r::GUI::FileArchiveDialog::FileArchiveDialog(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::is_project_3mf(), Slic3r::load_amf_archive(), mz_zip_reader_extract_iter_new(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_cfile(), mz_zip_reader_extract_to_file(), mz_zip_reader_extract_to_mem_no_alloc(), mz_zip_validate_archive(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::read_zipper_archive(), and Slic3r::PresetUpdater::priv::sync_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_uint n;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        if (filename_buf_size)
            pFilename[0] = '\0';
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return 0;
    }
    n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
    if (filename_buf_size)
    {
        n = MZ_MIN(n, filename_buf_size - 1);
        memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
        pFilename[n] = '\0';
    }
    return n + 1;
}

References MZ_MIN, MZ_READ_LE16, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

Here is the call graph for this function:

◆ mz_zip_reader_get_filename_from_extra()

mz_uint mz_zip_reader_get_filename_from_extra	(	mz_zip_archive *	pZip,
		mz_uint	file_index,
		char *	buffer,
		mz_uint	extra_buf_size
	)

{
    if (extra_buf_size == 0)
        return 0;
    mz_uint nf;
    mz_uint ne;
    const mz_uint8* p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        if (extra_buf_size)
            buffer[0] = '\0';
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return 0;
    }
    nf = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
    ne = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
 
    int copy = 0;
    char const* p_nf = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + nf;
    char const* e = p_nf + ne + 1;
    while (p_nf + 4 < e) {
        mz_uint16 len = ((mz_uint16)p_nf[2]) | ((mz_uint16)p_nf[3] << 8);
        if (p_nf[0] == '\x75' && p_nf[1] == '\x70' && len >= 5 && p_nf + 4 + len < e && p_nf[4] == '\x01') {
            mz_uint length = MZ_MIN(len - 5, extra_buf_size - 1);
            memcpy(buffer, p_nf + 9, length);
            return length;
        }
        else {
            p_nf += 4 + len;
        }
    }
    return 0;
}

References MZ_MIN, MZ_READ_LE16, MZ_ZIP_CDH_EXTRA_LEN_OFS, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

Referenced by Slic3r::GUI::FileArchiveDialog::FileArchiveDialog(), and Slic3r::GUI::Plater::preview_zip_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_reader_get_num_files()

mz_uint mz_zip_reader_get_num_files ( mz_zip_archive * pZip )

{
    return pZip ? pZip->m_total_files : 0;
}

References mz_zip_archive::m_total_files.

Referenced by Slic3r::GUI::FileArchiveDialog::FileArchiveDialog(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::is_project_3mf(), Slic3r::load_amf_archive(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::read_zipper_archive(), and Slic3r::PresetUpdater::priv::sync_config().

Here is the caller graph for this function:

◆ mz_zip_reader_init()

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

{
    if ((!pZip) || (!pZip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (!mz_zip_reader_init_internal(pZip, flags))
        return MZ_FALSE;
 
    pZip->m_zip_type = MZ_ZIP_TYPE_USER;
    pZip->m_archive_size = size;
 
    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }
 
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_archive::m_pRead, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_TRUE, MZ_ZIP_INVALID_PARAMETER, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_USER.

Here is the call graph for this function:

◆ 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_uint64 cur_file_ofs;
 
    if ((!pZip) || (!pFile))
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
 
    cur_file_ofs = MZ_FTELL64(pFile);
 
    if (!archive_size)
    {
        if (MZ_FSEEK64(pFile, 0, SEEK_END))
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
 
        archive_size = MZ_FTELL64(pFile) - cur_file_ofs;
 
        if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
            return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
    }
 
    if (!mz_zip_reader_init_internal(pZip, flags))
        return MZ_FALSE;
 
    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
    pZip->m_pRead = mz_zip_file_read_func;
 
    pZip->m_pIO_opaque = pZip;
    pZip->m_pState->m_pFile = pFile;
    pZip->m_archive_size = archive_size;
    pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs;
 
    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }
 
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_file_archive_start_ofs, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_FSEEK64, MZ_FTELL64, MZ_TRUE, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_read_func(), MZ_ZIP_FILE_SEEK_FAILED, MZ_ZIP_NOT_AN_ARCHIVE, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_CFILE.

Referenced by Slic3r::anonymous_namespace{miniz_extension.cpp}::open_zip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_reader_init_file()

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

{
    return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0);
}

References mz_zip_reader_init_file_v2().

Here is the call graph for this function:

◆ 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_uint64 file_size;
    MZ_FILE *pFile;
 
    if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pFile = MZ_FOPEN(pFilename, "rb");
    if (!pFile)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
 
    file_size = archive_size;
    if (!file_size)
    {
        if (MZ_FSEEK64(pFile, 0, SEEK_END))
        {
            MZ_FCLOSE(pFile);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
        }
 
        file_size = MZ_FTELL64(pFile);
    }
 
    /* TODO: Better sanity check archive_size and the # of actual remaining bytes */
 
    if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
    {
  MZ_FCLOSE(pFile);
        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
    }
 
    if (!mz_zip_reader_init_internal(pZip, flags))
    {
        MZ_FCLOSE(pFile);
        return MZ_FALSE;
    }
 
    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
    pZip->m_pRead = mz_zip_file_read_func;
    pZip->m_pIO_opaque = pZip;
    pZip->m_pState->m_pFile = pFile;
    pZip->m_archive_size = file_size;
    pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;
 
    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }
 
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_file_archive_start_ofs, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_FCLOSE, MZ_FILE, MZ_FOPEN, MZ_FSEEK64, MZ_FTELL64, MZ_TRUE, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_read_func(), MZ_ZIP_FILE_SEEK_FAILED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NOT_AN_ARCHIVE, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_FILE.

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_extract_archive_file_to_heap_v2(), mz_zip_reader_init_file(), and mz_zip_validate_file_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    if (!pMem)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
 
    if (!mz_zip_reader_init_internal(pZip, flags))
        return MZ_FALSE;
 
    pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY;
    pZip->m_archive_size = size;
    pZip->m_pRead = mz_zip_mem_read_func;
    pZip->m_pIO_opaque = pZip;
    pZip->m_pNeeds_keepalive = NULL;
 
#ifdef __cplusplus
    pZip->m_pState->m_pMem = const_cast<void *>(pMem);
#else
    pZip->m_pState->m_pMem = (void *)pMem;
#endif
 
    pZip->m_pState->m_mem_size = size;
 
    if (!mz_zip_reader_read_central_dir(pZip, flags))
    {
        mz_zip_reader_end_internal(pZip, MZ_FALSE);
        return MZ_FALSE;
    }
 
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_mem_size, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_TRUE, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_INVALID_PARAMETER, mz_zip_mem_read_func(), MZ_ZIP_NOT_AN_ARCHIVE, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_MEMORY.

Referenced by mz_zip_validate_mem_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_uint filename_len, attribute_mapping_id, external_attr;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return MZ_FALSE;
    }
 
    filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
    if (filename_len)
    {
        if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
            return MZ_TRUE;
    }
 
    /* Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct. */
    /* Most/all zip writers (hopefully) set DOS file/directory attributes in the low 16-bits, so check for the DOS directory flag and ignore the source OS ID in the created by field. */
    /* FIXME: Remove this check? Is it necessary - we already check the filename. */
    attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8;
    (void)attribute_mapping_id;
 
    external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
    if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0)
    {
        return MZ_TRUE;
    }
 
    return MZ_FALSE;
}

References MZ_FALSE, MZ_READ_LE16, MZ_READ_LE32, MZ_TRUE, MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CDH_VERSION_MADE_BY_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, mz_zip_set_error(), and void().

Referenced by mz_zip_file_stat_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_reader_is_file_encrypted()

mz_bool mz_zip_reader_is_file_encrypted	(	mz_zip_archive *	pZip,
		mz_uint	file_index
	)

{
    mz_uint m_bit_flag;
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return MZ_FALSE;
    }
 
    m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
    return (m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0;
}

References MZ_FALSE, MZ_READ_LE16, MZ_ZIP_CDH_BIT_FLAG_OFS, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

Referenced by mz_zip_file_stat_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_reader_is_file_supported()

mz_bool mz_zip_reader_is_file_supported	(	mz_zip_archive *	pZip,
		mz_uint	file_index
	)

{
    mz_uint bit_flag;
    mz_uint method;
 
    const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
    if (!p)
    {
        mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
        return MZ_FALSE;
    }
 
    method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
    bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
 
    if ((method != 0) && (method != MZ_DEFLATED))
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
        return MZ_FALSE;
    }
 
    if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION))
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
        return MZ_FALSE;
    }
 
    if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)
    {
        mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
        return MZ_FALSE;
    }
 
    return MZ_TRUE;
}

References MZ_DEFLATED, MZ_FALSE, MZ_READ_LE16, MZ_TRUE, MZ_ZIP_CDH_BIT_FLAG_OFS, MZ_ZIP_CDH_METHOD_OFS, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, mz_zip_set_error(), MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_FEATURE, and MZ_ZIP_UNSUPPORTED_METHOD.

Referenced by mz_zip_file_stat_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_uint32 index;
    if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index))
        return -1;
    else
        return (int)index;
}

References mz_zip_reader_locate_file_v2().

Here is the call graph for this function:

◆ mz_zip_reader_locate_file_v2()

int mz_zip_reader_locate_file_v2	(	mz_zip_archive *	pZip,
		const char *	pName,
		const char *	pComment,
		mz_uint	flags,
		mz_uint32 *	file_index
	)

{
    mz_uint file_index;
    size_t name_len, comment_len;
 
    if (pIndex)
        *pIndex = 0;
 
    if ((!pZip) || (!pZip->m_pState) || (!pName))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    /* See if we can use a binary search */
    if (((pZip->m_pState->m_init_flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) &&
        (pZip->m_zip_mode == MZ_ZIP_MODE_READING) &&
        ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size))
    {
        return mz_zip_locate_file_binary_search(pZip, pName, pIndex);
    }
 
    /* Locate the entry by scanning the entire central directory */
    name_len = strlen(pName);
    if (name_len > MZ_UINT16_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    comment_len = pComment ? strlen(pComment) : 0;
    if (comment_len > MZ_UINT16_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    for (file_index = 0; file_index < pZip->m_total_files; file_index++)
    {
        const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
        mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
        const char *pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
        if (filename_len < name_len)
            continue;
        if (comment_len)
        {
            mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS), file_comment_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS);
            const char *pFile_comment = pFilename + filename_len + file_extra_len;
            if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags)))
                continue;
        }
        if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len))
        {
            int ofs = filename_len - 1;
            do
            {
                if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':'))
                    break;
            } while (--ofs >= 0);
            ofs++;
            pFilename += ofs;
            filename_len -= ofs;
        }
        if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags)))
        {
            if (pIndex)
                *pIndex = file_index;
            return MZ_TRUE;
        }
    }
 
    return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
}

References mz_zip_internal_state_tag::m_central_dir, mz_zip_internal_state_tag::m_central_dir_offsets, mz_zip_internal_state_tag::m_init_flags, mz_zip_archive::m_pState, mz_zip_array::m_size, mz_zip_internal_state_tag::m_sorted_central_dir_offsets, mz_zip_archive::m_total_files, mz_zip_archive::m_zip_mode, MZ_READ_LE16, MZ_TRUE, MZ_UINT16_MAX, MZ_ZIP_ARRAY_ELEMENT, MZ_ZIP_CDH_COMMENT_LEN_OFS, MZ_ZIP_CDH_EXTRA_LEN_OFS, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_NOT_FOUND, MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, MZ_ZIP_FLAG_IGNORE_PATH, MZ_ZIP_INVALID_PARAMETER, mz_zip_locate_file_binary_search(), MZ_ZIP_MODE_READING, mz_zip_set_error(), and mz_zip_string_equal().

Referenced by mz_zip_extract_archive_file_to_heap_v2(), mz_zip_reader_extract_file_iter_new(), mz_zip_reader_extract_file_to_callback(), mz_zip_reader_extract_file_to_cfile(), mz_zip_reader_extract_file_to_file(), mz_zip_reader_extract_file_to_heap(), mz_zip_reader_extract_file_to_mem_no_alloc(), mz_zip_reader_locate_file(), and mz_zip_validate_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_set_last_error()

mz_zip_error mz_zip_set_last_error	(	mz_zip_archive *	pZip,
		mz_zip_error	err_num
	)

{
    mz_zip_error prev_err;
 
    if (!pZip)
        return MZ_ZIP_INVALID_PARAMETER;
 
    prev_err = pZip->m_last_error;
 
    pZip->m_last_error = err_num;
    return prev_err;
}

References mz_zip_archive::m_last_error, and MZ_ZIP_INVALID_PARAMETER.

Referenced by mz_zip_clear_last_error().

Here is the caller graph for this function:

◆ mz_zip_validate_archive()

mz_bool mz_zip_validate_archive	(	mz_zip_archive *	pZip,
		mz_uint	flags
	)

{
    mz_zip_internal_state *pState;
    uint32_t i;
 
    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pState = pZip->m_pState;
 
    /* Basic sanity checks */
    if (!pState->m_zip64)
    {
        if (pZip->m_total_files > MZ_UINT16_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
 
        if (pZip->m_archive_size > MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
    }
    else
    {
        if (pZip->m_total_files >= MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
 
        if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
    }
 
    for (i = 0; i < pZip->m_total_files; i++)
    {
        if (MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG & flags)
        {
            mz_uint32 found_index;
            mz_zip_archive_file_stat stat;
 
            if (!mz_zip_reader_file_stat(pZip, i, &stat))
                return MZ_FALSE;
 
            if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, &found_index))
                return MZ_FALSE;
 
            /* This check can fail if there are duplicate filenames in the archive (which we don't check for when writing - that's up to the user) */
            if (found_index != i)
                return mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
        }
 
        if (!mz_zip_validate_file(pZip, i, flags))
            return MZ_FALSE;
    }
 
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pFree, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, MZ_FALSE, MZ_TRUE, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_ZIP_ARCHIVE_TOO_LARGE, MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG, MZ_ZIP_INVALID_PARAMETER, mz_zip_reader_file_stat(), mz_zip_reader_locate_file_v2(), mz_zip_set_error(), mz_zip_validate_file(), MZ_ZIP_VALIDATION_FAILED, and stat.

Referenced by mz_zip_validate_file_archive(), and mz_zip_validate_mem_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_validate_file()

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

{
    mz_zip_archive_file_stat file_stat;
    mz_zip_internal_state *pState;
    const mz_uint8 *pCentral_dir_header;
    mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE;
    mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
    mz_uint64 local_header_ofs = 0;
    mz_uint32 local_header_filename_len, local_header_extra_len, local_header_crc32;
    mz_uint64 local_header_comp_size, local_header_uncomp_size;
    mz_uint32 uncomp_crc32 = MZ_CRC32_INIT;
    mz_bool has_data_descriptor;
    mz_uint32 local_header_bit_flags;
 
    mz_zip_array file_data_array;
    mz_zip_array_init(&file_data_array, 1);
 
    if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (file_index > pZip->m_total_files)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pState = pZip->m_pState;
 
    pCentral_dir_header = mz_zip_get_cdh(pZip, file_index);
 
    if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, &file_stat, &found_zip64_ext_data_in_cdir))
        return MZ_FALSE;
 
    /* A directory or zero length file */
    if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size))
        return MZ_TRUE;
 
    /* Encryption and patch files are not supported. */
    if (file_stat.m_is_encrypted)
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
 
    /* This function only supports stored and deflate. */
    if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
 
    if (!file_stat.m_is_supported)
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
 
    /* Read and parse the local directory entry. */
    local_header_ofs = file_stat.m_local_header_ofs;
    if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 
    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    local_header_filename_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
    local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
    local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
    local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
    local_header_crc32 = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_CRC32_OFS);
    local_header_bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
    has_data_descriptor = (local_header_bit_flags & 8) != 0;
 
    if (local_header_filename_len != strlen(file_stat.m_filename))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    if ((local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size) > pZip->m_archive_size)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE))
        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
    if (local_header_filename_len)
    {
        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE, file_data_array.m_p, local_header_filename_len) != local_header_filename_len)
        {
            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
            goto handle_failure;
        }
 
        /* I've seen 1 archive that had the same pathname, but used backslashes in the local dir and forward slashes in the central dir. Do we care about this? For now, this case will fail validation. */
        if (memcmp(file_stat.m_filename, file_data_array.m_p, local_header_filename_len) != 0)
        {
            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
            goto handle_failure;
        }
    }
 
    if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
    {
        mz_uint32 extra_size_remaining = local_header_extra_len;
        const mz_uint8 *pExtra_data = (const mz_uint8 *)file_data_array.m_p;
 
        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
        {
            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
            goto handle_failure;
        }
 
        do
        {
            mz_uint32 field_id, field_data_size, field_total_size;
 
            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
            field_id = MZ_READ_LE16(pExtra_data);
            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
 
            if (field_total_size > extra_size_remaining)
                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
            {
                const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
 
                if (field_data_size < sizeof(mz_uint64) * 2)
                {
                    mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
                    goto handle_failure;
                }
 
                local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
                local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64));
 
                found_zip64_ext_data_in_ldir = MZ_TRUE;
                break;
            }
 
            pExtra_data += field_total_size;
            extra_size_remaining -= field_total_size;
        } while (extra_size_remaining);
    }
 
    /* TODO: parse local header extra data when local_header_comp_size is 0xFFFFFFFF! (big_descriptor.zip) */
    /* I've seen zips in the wild with the data descriptor bit set, but proper local header values and bogus data descriptors */
    if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32))
    {
        mz_uint8 descriptor_buf[32];
        mz_bool has_id;
        const mz_uint8 *pSrc;
        mz_uint32 file_crc32;
        mz_uint64 comp_size = 0, uncomp_size = 0;
 
        mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4;
 
        if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size, descriptor_buf, sizeof(mz_uint32) * num_descriptor_uint32s) != (sizeof(mz_uint32) * num_descriptor_uint32s))
        {
            mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
            goto handle_failure;
        }
 
        has_id = (MZ_READ_LE32(descriptor_buf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
        pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf;
 
        file_crc32 = MZ_READ_LE32(pSrc);
 
        if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir))
        {
            comp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32));
            uncomp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32) + sizeof(mz_uint64));
        }
        else
        {
            comp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32));
            uncomp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32) + sizeof(mz_uint32));
        }
 
        if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size))
        {
            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
            goto handle_failure;
        }
    }
    else
    {
        if ((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size))
        {
            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
            goto handle_failure;
        }
    }
 
    mz_zip_array_clear(pZip, &file_data_array);
 
    if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0)
    {
        if (!mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0))
            return MZ_FALSE;
 
        /* 1 more check to be sure, although the extract checks too. */
        if (uncomp_crc32 != file_stat.m_crc32)
        {
            mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
            return MZ_FALSE;
        }
    }
 
    return MZ_TRUE;
 
handle_failure:
    mz_zip_array_clear(pZip, &file_data_array);
    return MZ_FALSE;
}

Referenced by mz_zip_validate_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_validate_file_archive()

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

{
    mz_bool success = MZ_TRUE;
    mz_zip_archive zip;
    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
 
    if (!pFilename)
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_PARAMETER;
        return MZ_FALSE;
    }
 
    mz_zip_zero_struct(&zip);
 
    if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0))
    {
        if (pErr)
            *pErr = zip.m_last_error;
        return MZ_FALSE;
    }
 
    if (!mz_zip_validate_archive(&zip, flags))
    {
        actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }
 
    if (!mz_zip_reader_end_internal(&zip, success))
    {
        if (!actual_err)
            actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }
 
    if (pErr)
        *pErr = actual_err;
 
    return success;
}

References mz_zip_archive::m_last_error, MZ_FALSE, MZ_TRUE, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, mz_zip_reader_end_internal(), mz_zip_reader_init_file_v2(), mz_zip_validate_archive(), and mz_zip_zero_struct().

Here is the call graph for this function:

◆ 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_bool success = MZ_TRUE;
    mz_zip_archive zip;
    mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
 
    if ((!pMem) || (!size))
    {
        if (pErr)
            *pErr = MZ_ZIP_INVALID_PARAMETER;
        return MZ_FALSE;
    }
 
    mz_zip_zero_struct(&zip);
 
    if (!mz_zip_reader_init_mem(&zip, pMem, size, flags))
    {
        if (pErr)
            *pErr = zip.m_last_error;
        return MZ_FALSE;
    }
 
    if (!mz_zip_validate_archive(&zip, flags))
    {
        actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }
 
    if (!mz_zip_reader_end_internal(&zip, success))
    {
        if (!actual_err)
            actual_err = zip.m_last_error;
        success = MZ_FALSE;
    }
 
    if (pErr)
        *pErr = actual_err;
 
    return success;
}

References mz_zip_archive::m_last_error, MZ_FALSE, MZ_TRUE, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, mz_zip_reader_end_internal(), mz_zip_reader_init_mem(), mz_zip_validate_archive(), and mz_zip_zero_struct().

Here is the call graph for this function:

◆ 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	size_to_add,
		const MZ_TIME_T *	pFile_time,
		const void *	pComment,
		mz_uint16	comment_size,
		mz_uint	level_and_flags,
		const char *	user_extra_data_local,
		mz_uint	user_extra_data_local_len,
		const char *	user_extra_data_central,
		mz_uint	user_extra_data_central_len
	)

{
  return mz_zip_writer_add_read_buf_callback(pZip, pArchive_name, mz_file_read_func_stdio, pSrc_file, size_to_add, pFile_time, pComment, comment_size, level_and_flags,
    user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len);
}

References mz_file_read_func_stdio(), and mz_zip_writer_add_read_buf_callback().

Referenced by mz_zip_writer_add_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_FILE *pSrc_file = NULL;
    mz_uint64 uncomp_size = 0;
    MZ_TIME_T file_modified_time;
    MZ_TIME_T *pFile_time = NULL;
    mz_bool status;
 
    memset(&file_modified_time, 0, sizeof(file_modified_time));
 
#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
    pFile_time = &file_modified_time;
    if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time))
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_STAT_FAILED);
#endif
 
    pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
    if (!pSrc_file)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
 
    MZ_FSEEK64(pSrc_file, 0, SEEK_END);
    uncomp_size = MZ_FTELL64(pSrc_file);
    MZ_FSEEK64(pSrc_file, 0, SEEK_SET);
 
    status = mz_zip_writer_add_cfile(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags, NULL, 0, NULL, 0);
 
    MZ_FCLOSE(pSrc_file);
 
    return status;
}

References MZ_FCLOSE, MZ_FILE, MZ_FOPEN, MZ_FSEEK64, MZ_FTELL64, MZ_TIME_T, MZ_ZIP_FILE_OPEN_FAILED, MZ_ZIP_FILE_STAT_FAILED, mz_zip_get_file_modified_time(), mz_zip_set_error(), mz_zip_writer_add_cfile(), and SEEK_SET.

Here is the call graph for this function:

◆ 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_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;
    mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs;
    mz_uint64 cur_src_file_ofs, cur_dst_file_ofs;
    mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
    mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
    mz_uint8 new_central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
    size_t orig_central_dir_size;
    mz_zip_internal_state *pState;
    void *pBuf;
    const mz_uint8 *pSrc_central_header;
    mz_zip_archive_file_stat src_file_stat;
    mz_uint32 src_filename_len, src_comment_len, src_ext_len;
    mz_uint32 local_header_filename_size, local_header_extra_len;
    mz_uint64 local_header_comp_size, local_header_uncomp_size;
    mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
 
    /* Sanity checks */
    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pState = pZip->m_pState;
 
    /* Don't support copying files from zip64 archives to non-zip64, even though in some cases this is possible */
    if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    /* Get pointer to the source central dir header and crack it */
    if (NULL == (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index)))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_SIG_OFS) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    src_filename_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS);
    src_comment_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS);
    src_ext_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS);
    src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len;
 
    /* TODO: We don't support central dir's >= MZ_UINT32_MAX bytes right now (+32 fudge factor in case we need to add more extra data) */
    if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
 
    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
 
    if (!pState->m_zip64)
    {
        if (pZip->m_total_files == MZ_UINT16_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
    else
    {
        /* TODO: Our zip64 support still has some 32-bit limits that may not be worth fixing. */
        if (pZip->m_total_files == MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
 
    if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, pSrc_central_header, &src_file_stat, NULL))
        return MZ_FALSE;
 
    cur_src_file_ofs = src_file_stat.m_local_header_ofs;
    cur_dst_file_ofs = pZip->m_archive_size;
 
    /* Read the source archive's local dir header */
    if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 
    if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 
    cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
 
    /* Compute the total size we need to copy (filename+extra data+compressed data) */
    local_header_filename_size = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
    local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
    local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
    local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
    src_archive_bytes_remaining = local_header_filename_size + local_header_extra_len + src_file_stat.m_comp_size;
 
    /* Try to find a zip64 extended information field */
    if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
    {
        mz_zip_array file_data_array;
        const mz_uint8 *pExtra_data;
        mz_uint32 extra_size_remaining = local_header_extra_len;
 
        mz_zip_array_init(&file_data_array, 1);
        if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE))
        {
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
 
        if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, src_file_stat.m_local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_size, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
        {
            mz_zip_array_clear(pZip, &file_data_array);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
        }
 
        pExtra_data = (const mz_uint8 *)file_data_array.m_p;
 
        do
        {
            mz_uint32 field_id, field_data_size, field_total_size;
 
            if (extra_size_remaining < (sizeof(mz_uint16) * 2))
            {
                mz_zip_array_clear(pZip, &file_data_array);
                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
            }
 
            field_id = MZ_READ_LE16(pExtra_data);
            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
            field_total_size = field_data_size + sizeof(mz_uint16) * 2;
 
            if (field_total_size > extra_size_remaining)
            {
                mz_zip_array_clear(pZip, &file_data_array);
                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
            }
 
            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
            {
                const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
 
                if (field_data_size < sizeof(mz_uint64) * 2)
                {
                    mz_zip_array_clear(pZip, &file_data_array);
                    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
                }
 
                local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
                local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); /* may be 0 if there's a descriptor */
 
                found_zip64_ext_data_in_ldir = MZ_TRUE;
                break;
            }
 
            pExtra_data += field_total_size;
            extra_size_remaining -= field_total_size;
        } while (extra_size_remaining);
 
        mz_zip_array_clear(pZip, &file_data_array);
    }
 
    if (!pState->m_zip64)
    {
        /* Try to detect if the new archive will most likely wind up too big and bail early (+(sizeof(mz_uint32) * 4) is for the optional descriptor which could be present, +64 is a fudge factor). */
        /* We also check when the archive is finalized so this doesn't need to be perfect. */
        mz_uint64 approx_new_archive_size = cur_dst_file_ofs + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + src_archive_bytes_remaining + (sizeof(mz_uint32) * 4) +
                                            pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 64;
 
        if (approx_new_archive_size >= MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
    }
 
    /* Write dest archive padding */
    if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes))
        return MZ_FALSE;
 
    cur_dst_file_ofs += num_alignment_padding_bytes;
 
    local_dir_header_ofs = cur_dst_file_ofs;
    if (pZip->m_file_offset_alignment)
    {
        MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
    }
 
    /* The original zip's local header+ext block doesn't change, even with zip64, so we can just copy it over to the dest zip */
    if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
    cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
 
    /* Copy over the source archive bytes to the dest archive, also ensure we have enough buf space to handle optional data descriptor */
    if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)MZ_MAX(32U, MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining)))))
        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
    while (src_archive_bytes_remaining)
    {
        n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining);
        if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n)
        {
            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
        }
        cur_src_file_ofs += n;
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
        {
            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
        }
        cur_dst_file_ofs += n;
 
        src_archive_bytes_remaining -= n;
    }
 
    /* Now deal with the optional data descriptor */
    bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
    if (bit_flags & 8)
    {
        /* Copy data descriptor */
        if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir))
        {
            /* src is zip64, dest must be zip64 */
 
            /* name     uint32_t's */
            /* id       1 (optional in zip64?) */
            /* crc      1 */
            /* comp_size  2 */
            /* uncomp_size 2 */
            if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6))
            {
                pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
                return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
            }
 
            n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5);
        }
        else
        {
            /* src is NOT zip64 */
            mz_bool has_id;
 
            if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4)
            {
                pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
                return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
            }
 
            has_id = (MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
 
            if (pZip->m_pState->m_zip64)
            {
                /* dest is zip64, so upgrade the data descriptor */
                const mz_uint32 *pSrc_descriptor = (const mz_uint32 *)((const mz_uint8 *)pBuf + (has_id ? sizeof(mz_uint32) : 0));
                const mz_uint32 src_crc32 = pSrc_descriptor[0];
                const mz_uint64 src_comp_size = pSrc_descriptor[1];
                const mz_uint64 src_uncomp_size = pSrc_descriptor[2];
 
                mz_write_le32((mz_uint8 *)pBuf, MZ_ZIP_DATA_DESCRIPTOR_ID);
                mz_write_le32((mz_uint8 *)pBuf + sizeof(mz_uint32) * 1, src_crc32);
                mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 2, src_comp_size);
                mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 4, src_uncomp_size);
 
                n = sizeof(mz_uint32) * 6;
            }
            else
            {
                /* dest is NOT zip64, just copy it as-is */
                n = sizeof(mz_uint32) * (has_id ? 4 : 3);
            }
        }
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
        {
            pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
        }
 
        cur_src_file_ofs += n;
        cur_dst_file_ofs += n;
    }
    pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
 
    /* Finally, add the new central dir header */
    orig_central_dir_size = pState->m_central_dir.m_size;
 
    memcpy(new_central_header, pSrc_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
 
    if (pState->m_zip64)
    {
        /* This is the painful part: We need to write a new central dir header + ext block with updated zip64 fields, and ensure the old fields (if any) are not included. */
        const mz_uint8 *pSrc_ext = pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len;
        mz_zip_array new_ext_block;
 
        mz_zip_array_init(&new_ext_block, sizeof(mz_uint8));
 
        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_UINT32_MAX);
 
        if (!mz_zip_writer_update_zip64_extension_block(&new_ext_block, pZip, pSrc_ext, src_ext_len, &src_file_stat.m_comp_size, &src_file_stat.m_uncomp_size, &local_dir_header_ofs, NULL))
        {
            mz_zip_array_clear(pZip, &new_ext_block);
            return MZ_FALSE;
        }
 
        MZ_WRITE_LE16(new_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS, new_ext_block.m_size);
 
        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
        {
            mz_zip_array_clear(pZip, &new_ext_block);
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
 
        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len))
        {
            mz_zip_array_clear(pZip, &new_ext_block);
            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
 
        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size))
        {
            mz_zip_array_clear(pZip, &new_ext_block);
            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
 
        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len + src_ext_len, src_comment_len))
        {
            mz_zip_array_clear(pZip, &new_ext_block);
            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
 
        mz_zip_array_clear(pZip, &new_ext_block);
    }
    else
    {
        /* sanity checks */
        if (cur_dst_file_ofs > MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
 
        if (local_dir_header_ofs >= MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
 
        MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_dir_header_ofs);
 
        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
        if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_central_dir_following_data_size))
        {
            mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
    }
 
    /* This shouldn't trigger unless we screwed up during the initial sanity checks */
    if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
    {
        /* TODO: Support central dirs >= 32-bits in size */
        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
    }
 
    n = (mz_uint32)orig_central_dir_size;
    if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1))
    {
        mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
    }
 
    pZip->m_total_files++;
    pZip->m_archive_size = cur_dst_file_ofs;
 
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_internal_state_tag::m_central_dir_offsets, mz_zip_archive_file_stat::m_comp_size, mz_zip_archive::m_file_offset_alignment, mz_zip_archive_file_stat::m_local_header_ofs, mz_zip_array::m_p, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_archive_file_stat::m_uncomp_size, mz_zip_internal_state_tag::m_zip64, mz_zip_archive::m_zip_mode, MZ_ASSERT, MZ_FALSE, MZ_MAX, MZ_MIN, MZ_READ_LE16, MZ_READ_LE32, MZ_READ_LE64, MZ_TRUE, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_WRITE_LE16, mz_write_le32(), MZ_WRITE_LE32, mz_write_le64(), MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARCHIVE_TOO_LARGE, mz_zip_array_clear(), mz_zip_array_init(), mz_zip_array_push_back(), mz_zip_array_resize(), MZ_ZIP_CDH_COMMENT_LEN_OFS, MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_ZIP_CDH_EXTRA_LEN_OFS, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_DATA_DESCRIPTOR_ID, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_READ_FAILED, mz_zip_file_stat_internal(), MZ_ZIP_FILE_WRITE_FAILED, mz_zip_get_cdh(), MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_BIT_FLAG_OFS, MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_ZIP_LDH_EXTRA_LEN_OFS, MZ_ZIP_LDH_FILENAME_LEN_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MAX_IO_BUF_SIZE, MZ_ZIP_MODE_WRITING, mz_zip_set_error(), MZ_ZIP_TOO_MANY_FILES, MZ_ZIP_UNSUPPORTED_CDIR_SIZE, mz_zip_writer_compute_padding_needed_for_file_alignment(), mz_zip_writer_update_zip64_extension_block(), and mz_zip_writer_write_zeros().

Here is the call graph for this function:

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

{
    return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, level_and_flags, 0, 0);
}

References mz_zip_writer_add_mem_ex().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    return mz_zip_writer_add_mem_ex_v2(pZip, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, uncomp_size, uncomp_crc32, NULL, NULL, 0, NULL, 0);
}

References mz_zip_writer_add_mem_ex_v2().

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), and mz_zip_writer_add_mem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_local,
		mz_uint	user_extra_data_local_len,
		const char *	user_extra_data_central,
		mz_uint	user_extra_data_central_len
	)

{
    mz_uint16 method = 0, dos_time = 0, dos_date = 0;
    mz_uint level, ext_attributes = 0, num_alignment_padding_bytes;
    mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0;
    size_t archive_name_size;
    mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
    tdefl_compressor *pComp = NULL;
    mz_bool store_data_uncompressed;
    mz_zip_internal_state *pState;
    mz_uint8 *pExtra_data = NULL;
    mz_uint32 extra_size = 0;
    mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
    mz_uint16 bit_flags = 0;
 
    if ((int)level_and_flags < 0)
        level_and_flags = MZ_DEFAULT_LEVEL;
 
    if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
        bit_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
 
    if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
        bit_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
 
    level = level_and_flags & 0xF;
    store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA));
 
    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pState = pZip->m_pState;
 
    if (pState->m_zip64)
    {
        if (pZip->m_total_files == MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
    else
    {
        if (pZip->m_total_files == MZ_UINT16_MAX)
        {
            pState->m_zip64 = MZ_TRUE;
            /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
        }
        if ((buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))
        {
            pState->m_zip64 = MZ_TRUE;
            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
        }
    }
 
    if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (!mz_zip_writer_validate_archive_name(pArchive_name))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
 
#ifndef MINIZ_NO_TIME
    if (last_modified != NULL)
    {
        mz_zip_time_t_to_dos_time(*last_modified, &dos_time, &dos_date);
    }
    else
    {
        MZ_TIME_T cur_time;
        time(&cur_time);
        mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date);
    }
#endif /* #ifndef MINIZ_NO_TIME */
 
  if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
  {
    uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
    uncomp_size = buf_size;
    if (uncomp_size <= 3)
    {
      level = 0;
      store_data_uncompressed = MZ_TRUE;
    }
  }
 
    archive_name_size = strlen(pArchive_name);
    if (archive_name_size > MZ_UINT16_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
 
    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
 
    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
 
    if (!pState->m_zip64)
    {
        /* Bail early if the archive would obviously become too large */
        if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size 
      + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len + 
      pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len
      + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
        {
            pState->m_zip64 = MZ_TRUE;
            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
        }
    }
 
    if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/'))
    {
        /* Set DOS Subdirectory attribute bit. */
        ext_attributes |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG;
 
        /* Subdirectories cannot contain data. */
        if ((buf_size) || (uncomp_size))
            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
    }
 
    /* Try to do any allocations before writing to the archive, so if an allocation fails the file remains unmodified. (A good idea if we're doing an in-place modification.) */
    if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1)))
        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
    if ((!store_data_uncompressed) && (buf_size))
    {
        if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor))))
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
    }
 
    if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
    {
        pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
        return MZ_FALSE;
    }
 
    local_dir_header_ofs += num_alignment_padding_bytes;
    if (pZip->m_file_offset_alignment)
    {
        MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
    }
    cur_archive_file_ofs += num_alignment_padding_bytes;
 
    MZ_CLEAR_OBJ(local_dir_header);
 
    if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
    {
        method = MZ_DEFLATED;
    }
 
    if (pState->m_zip64)
    {
        if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
        {
            pExtra_data = extra_data;
            extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
                                                               (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
        }
 
        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, bit_flags, dos_time, dos_date))
            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        cur_archive_file_ofs += sizeof(local_dir_header);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
        {
            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
        }
        cur_archive_file_ofs += archive_name_size;
 
        if (pExtra_data != NULL)
        {
            if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
                return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
            cur_archive_file_ofs += extra_size;
        }
    }
    else
    {
        if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        cur_archive_file_ofs += sizeof(local_dir_header);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
        {
            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
        }
        cur_archive_file_ofs += archive_name_size;
    }
 
  if (user_extra_data_len > 0)
  {
    if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
      return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
    cur_archive_file_ofs += user_extra_data_len;
  }
 
    if (store_data_uncompressed)
    {
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size)
        {
            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
        }
 
        cur_archive_file_ofs += buf_size;
        comp_size = buf_size;
    }
    else if (buf_size)
    {
        mz_zip_writer_add_state state;
 
        state.m_pZip = pZip;
        state.m_cur_archive_file_ofs = cur_archive_file_ofs;
        state.m_comp_size = 0;
 
        if ((tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY) ||
            (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != TDEFL_STATUS_DONE))
        {
            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
            return mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
        }
 
        comp_size = state.m_comp_size;
        cur_archive_file_ofs = state.m_cur_archive_file_ofs;
    }
 
    pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
    pComp = NULL;
 
    if (uncomp_size)
    {
        mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
        mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
 
        MZ_ASSERT(bit_flags & MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR);
 
        MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
        MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
        if (pExtra_data == NULL)
        {
            if (comp_size > MZ_UINT32_MAX)
                return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
 
            MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
            MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
        }
        else
        {
            MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
            MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
            local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
        }
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
            return MZ_FALSE;
 
        cur_archive_file_ofs += local_dir_footer_size;
    }
 
    if (pExtra_data != NULL)
    {
        extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
                                                           (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
    }
 
    if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, (mz_uint16)extra_size, pComment,
                                          comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
                                          user_extra_data_central, user_extra_data_central_len))
        return MZ_FALSE;
 
    pZip->m_total_files++;
    pZip->m_archive_size = cur_archive_file_ofs;
 
    return MZ_TRUE;
}

Referenced by mz_zip_writer_add_mem_ex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_local,
		mz_uint	user_extra_data_local_len,
		const char *	user_extra_data_central,
		mz_uint	user_extra_data_central_len
	)

{
    mz_uint16 gen_flags = MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
    mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes;
    mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;
    mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->m_archive_size, uncomp_size = 0, comp_size = 0;
    size_t archive_name_size;
    mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
    mz_uint8 *pExtra_data = NULL;
    mz_uint32 extra_size = 0;
    mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
    mz_zip_internal_state *pState;
  mz_uint64 file_ofs = 0;
 
    if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
        gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
 
    if ((int)level_and_flags < 0)
        level_and_flags = MZ_DEFAULT_LEVEL;
    level = level_and_flags & 0xF;
 
    /* Sanity checks */
    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pState = pZip->m_pState;
 
    if ((!pState->m_zip64) && (max_size > MZ_UINT32_MAX))
    {
        /* Source file is too large for non-zip64 */
        /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
        pState->m_zip64 = MZ_TRUE;
    }
 
    /* We could support this, but why? */
    if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (!mz_zip_writer_validate_archive_name(pArchive_name))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
 
    if (pState->m_zip64)
    {
        if (pZip->m_total_files == MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
    else
    {
        if (pZip->m_total_files == MZ_UINT16_MAX)
        {
            pState->m_zip64 = MZ_TRUE;
            /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
        }
    }
 
    archive_name_size = strlen(pArchive_name);
    if (archive_name_size > MZ_UINT16_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
 
    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
 
    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
 
    if (!pState->m_zip64)
    {
        /* Bail early if the archive would obviously become too large */
        if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
      + archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
      + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
        {
            pState->m_zip64 = MZ_TRUE;
            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
        }
    }
 
#ifndef MINIZ_NO_TIME
    if (pFile_time)
    {
        mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date);
    }
#endif
 
    if (max_size <= 3)
        level = 0;
 
    if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
    {
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
    }
 
    cur_archive_file_ofs += num_alignment_padding_bytes;
    local_dir_header_ofs = cur_archive_file_ofs;
 
    if (pZip->m_file_offset_alignment)
    {
        MZ_ASSERT((cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
    }
 
    if (max_size && level)
    {
        method = MZ_DEFLATED;
    }
 
    MZ_CLEAR_OBJ(local_dir_header);
    if (pState->m_zip64)
    {
        if (max_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
        {
            pExtra_data = extra_data;
            extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
                                                               (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
        }
 
        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, gen_flags, dos_time, dos_date))
            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        cur_archive_file_ofs += sizeof(local_dir_header);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
        {
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
        }
 
        cur_archive_file_ofs += archive_name_size;
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        cur_archive_file_ofs += extra_size;
    }
    else
    {
        if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
            return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
        if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
            return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        cur_archive_file_ofs += sizeof(local_dir_header);
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
        {
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
        }
 
        cur_archive_file_ofs += archive_name_size;
    }
 
    if (user_extra_data_len > 0)
    {
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        cur_archive_file_ofs += user_extra_data_len;
    }
 
    if (max_size)
    {
        void *pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE);
        if (!pRead_buf)
        {
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
 
        if (!level)
        {
            while (1)
            {
                size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE);
                if (n == 0)
                    break;
 
                if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size))
                {
                    pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
                    return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
                }
                if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n)
                {
                    pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
                    return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
                }
                file_ofs += n;
                uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
                cur_archive_file_ofs += n;
            }
            uncomp_size = file_ofs;
            comp_size = uncomp_size;
        }
        else
        {
            mz_bool result = MZ_FALSE;
            mz_zip_writer_add_state state;
            tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor));
            if (!pComp)
            {
                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
                return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
            }
 
            state.m_pZip = pZip;
            state.m_cur_archive_file_ofs = cur_archive_file_ofs;
            state.m_comp_size = 0;
 
            if (tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY)
            {
                pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
                return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
            }
 
            for (;;)
            {
                tdefl_status status;
                tdefl_flush flush = TDEFL_NO_FLUSH;
 
                size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE);
                if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size))
                {
                    mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
                    break;
                }
 
                file_ofs += n;
                uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
 
                if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque))
                    flush = TDEFL_FULL_FLUSH;
 
                if (n == 0)
                    flush = TDEFL_FINISH;
 
                status = tdefl_compress_buffer(pComp, pRead_buf, n, flush);
                if (status == TDEFL_STATUS_DONE)
                {
                    result = MZ_TRUE;
                    break;
                }
                else if (status != TDEFL_STATUS_OKAY)
                {
                    mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
                    break;
                }
            }
 
            pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
 
            if (!result)
            {
                pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
                return MZ_FALSE;
            }
 
            uncomp_size = file_ofs;
            comp_size = state.m_comp_size;
            cur_archive_file_ofs = state.m_cur_archive_file_ofs;
        }
 
        pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
    }
 
    {
        mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
        mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
 
        MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
        MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
        if (pExtra_data == NULL)
        {
            if (comp_size > MZ_UINT32_MAX)
                return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
 
            MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
            MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
        }
        else
        {
            MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
            MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
            local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
        }
 
        if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
            return MZ_FALSE;
 
        cur_archive_file_ofs += local_dir_footer_size;
    }
 
    if (pExtra_data != NULL)
    {
        extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
                                                           (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
    }
 
    if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, (mz_uint16)extra_size, pComment, comment_size,
                                          uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
                                          user_extra_data_central, user_extra_data_central_len))
        return MZ_FALSE;
 
    pZip->m_total_files++;
    pZip->m_archive_size = cur_archive_file_ofs;
 
    return MZ_TRUE;
}

Referenced by mz_zip_writer_add_cfile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_add_staged_data()

mz_bool mz_zip_writer_add_staged_data	(	mz_zip_writer_staged_context *	pContext,
		const char *	pRead_buf,
		size_t	n
	)

{
    tdefl_flush  flush = TDEFL_NO_FLUSH;
 
    if (pContext->file_ofs + n > pContext->max_size)
    {
        mz_zip_set_error(pContext->pZip, MZ_ZIP_FILE_READ_FAILED);
        pContext->pZip->m_pFree(pContext->pZip->m_pAlloc_opaque, pContext->pCompressor);
        pContext->pCompressor = NULL;
        return MZ_FALSE;
    }
 
    pContext->file_ofs += n;
    pContext->uncomp_crc32 = (mz_uint32)mz_crc32(pContext->uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
 
    if (pContext->pZip->m_pNeeds_keepalive != NULL && pContext->pZip->m_pNeeds_keepalive(pContext->pZip->m_pIO_opaque))
        flush = TDEFL_FULL_FLUSH;
 
    {
        tdefl_status status = tdefl_compress_buffer(pContext->pCompressor, pRead_buf, n, (n == 0) ? TDEFL_FINISH : flush);
        if (status == TDEFL_STATUS_DONE || status == TDEFL_STATUS_OKAY)
            return MZ_TRUE;
    }
 
    mz_zip_set_error(pContext->pZip, MZ_ZIP_COMPRESSION_FAILED);
    pContext->pZip->m_pFree(pContext->pZip->m_pAlloc_opaque, pContext->pCompressor);
    pContext->pCompressor = NULL;
    return MZ_FALSE;
}

References mz_zip_writer_staged_context::file_ofs, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pNeeds_keepalive, mz_zip_writer_staged_context::max_size, mz_crc32(), MZ_FALSE, MZ_TRUE, MZ_ZIP_COMPRESSION_FAILED, MZ_ZIP_FILE_READ_FAILED, mz_zip_set_error(), mz_zip_writer_staged_context::pCompressor, mz_zip_writer_staged_context::pZip, tdefl_compress_buffer(), TDEFL_FINISH, TDEFL_FULL_FLUSH, TDEFL_NO_FLUSH, TDEFL_STATUS_DONE, TDEFL_STATUS_OKAY, and mz_zip_writer_staged_context::uncomp_crc32.

Referenced by Slic3r::_3MF_Exporter::_add_mesh_to_object_stream(), Slic3r::_3MF_Exporter::_add_model_file_to_archive(), Slic3r::_3MF_Exporter::_add_object_to_model_stream(), and mz_zip_writer_add_staged_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_add_staged_finish()

mz_bool mz_zip_writer_add_staged_finish ( mz_zip_writer_staged_context * pContext )

{
    if (! mz_zip_writer_add_staged_data(pContext, NULL, 0) ||
        // Either never opened, or already finished.
        ! pContext->pCompressor)
        return MZ_FALSE;
 
    pContext->pZip->m_pFree(pContext->pZip->m_pAlloc_opaque, pContext->pCompressor);
    pContext->pCompressor = NULL;
 
    // Rewrite preallocated phony custom block in local dir header by ZIP64 extension. Also, other values are adjusted in the header.
    if (pContext->file_ofs >= MZ_UINT32_MAX || pContext->add_state.m_comp_size >= MZ_UINT32_MAX) {
        mz_uint64 local_dir_header_ofs = pContext->local_dir_header_ofs;
        pContext->pExtra_data = pContext->extra_data;
        pContext->extra_size = mz_zip_writer_create_zip64_extra_data(pContext->extra_data, &pContext->uncomp_size, &pContext->comp_size, (pContext->local_dir_header_ofs >= MZ_UINT32_MAX) ? &pContext->local_dir_header_ofs : NULL);
 
        mz_uint8 min_version[2]      = {0x2D, 0x00};
        mz_uint8 comp_uncomp_size[4] = {0xFF, 0xFF, 0xFF, 0xFF};
        if (pContext->pZip->m_pWrite(pContext->pZip->m_pIO_opaque, local_dir_header_ofs + MZ_ZIP_LDH_VERSION_NEEDED_OFS, min_version, sizeof(min_version)) != sizeof(min_version))
            return mz_zip_set_error(pContext->pZip, MZ_ZIP_FILE_WRITE_FAILED);
        if (pContext->pZip->m_pWrite(pContext->pZip->m_pIO_opaque, local_dir_header_ofs + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, comp_uncomp_size, sizeof(comp_uncomp_size)) != sizeof(comp_uncomp_size))
            return mz_zip_set_error(pContext->pZip, MZ_ZIP_FILE_WRITE_FAILED);
        if (pContext->pZip->m_pWrite(pContext->pZip->m_pIO_opaque, local_dir_header_ofs + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, comp_uncomp_size, sizeof(comp_uncomp_size)) != sizeof(comp_uncomp_size))
            return mz_zip_set_error(pContext->pZip, MZ_ZIP_FILE_WRITE_FAILED);
        if (pContext->pZip->m_pWrite(pContext->pZip->m_pIO_opaque, local_dir_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + pContext->archive_name_size, pContext->extra_data, pContext->extra_size) != pContext->extra_size)
            return mz_zip_set_error(pContext->pZip, MZ_ZIP_FILE_WRITE_FAILED);
    }
 
    pContext->uncomp_size = pContext->file_ofs;
    pContext->comp_size = pContext->add_state.m_comp_size;
    pContext->cur_archive_file_ofs = pContext->add_state.m_cur_archive_file_ofs;
 
    // Clean pContext->pExtra_data, pContext->extra_data and pContext->extra_size after calling mz_zip_writer_add_staged_open
    pContext->pExtra_data = NULL;
    pContext->extra_size = 0;
    memset(pContext->extra_data, 0, sizeof(mz_uint8) * MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE);
 
    {
        mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
        mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
 
        MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
        MZ_WRITE_LE32(local_dir_footer + 4, pContext->uncomp_crc32);
        if (pContext->uncomp_size < MZ_UINT32_MAX && pContext->comp_size < MZ_UINT32_MAX)
        {
            if (pContext->comp_size > MZ_UINT32_MAX)
                return mz_zip_set_error(pContext->pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
 
            MZ_WRITE_LE32(local_dir_footer + 8, pContext->comp_size);
            MZ_WRITE_LE32(local_dir_footer + 12, pContext->uncomp_size);
        }
        else
        {
            MZ_WRITE_LE64(local_dir_footer + 8, pContext->comp_size);
            MZ_WRITE_LE64(local_dir_footer + 16, pContext->uncomp_size);
            local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
        }
 
        if (pContext->pZip->m_pWrite(pContext->pZip->m_pIO_opaque, pContext->cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
            return MZ_FALSE;
 
        pContext->cur_archive_file_ofs += local_dir_footer_size;
    }
 
    if (pContext->file_ofs >= MZ_UINT32_MAX || pContext->add_state.m_comp_size >= MZ_UINT32_MAX)
    {
        pContext->pExtra_data = pContext->extra_data;
        pContext->extra_size = mz_zip_writer_create_zip64_extra_data(pContext->extra_data, (pContext->uncomp_size >= MZ_UINT32_MAX) ? &pContext->uncomp_size : NULL,
                                                           (pContext->comp_size >= MZ_UINT32_MAX) ? &pContext->comp_size : NULL, (pContext->local_dir_header_ofs >= MZ_UINT32_MAX) ? &pContext->local_dir_header_ofs : NULL);
    }
 
    if (!mz_zip_writer_add_to_central_dir(pContext->pZip, pContext->pArchive_name, (mz_uint16)pContext->archive_name_size, pContext->pExtra_data, (mz_uint16)pContext->extra_size, pContext->pComment, pContext->comment_size,
                                          pContext->uncomp_size, pContext->comp_size, pContext->uncomp_crc32, pContext->method, pContext->gen_flags, pContext->dos_time, pContext->dos_date, pContext->local_dir_header_ofs, pContext->ext_attributes,
                                          pContext->user_extra_data_central, pContext->user_extra_data_central_len))
        return MZ_FALSE;
 
    pContext->pZip->m_total_files++;
    pContext->pZip->m_archive_size = pContext->cur_archive_file_ofs;
 
    return MZ_TRUE;
}

Referenced by Slic3r::_3MF_Exporter::_add_model_file_to_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_add_staged_open()

mz_bool mz_zip_writer_add_staged_open	(	mz_zip_archive *	pZip,
		mz_zip_writer_staged_context *	pContext,
		const char *	pArchive_name,
		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_uint level, num_alignment_padding_bytes;
    mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
    mz_zip_internal_state* pState;
 
    memset(pContext, 0, sizeof(mz_zip_writer_staged_context));
    pContext->pZip = pZip;
    pContext->gen_flags = MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
    pContext->uncomp_crc32 = MZ_CRC32_INIT;
    pContext->method = MZ_DEFLATED;
    pContext->cur_archive_file_ofs = pZip->m_archive_size;
    pContext->max_size = max_size;
    pContext->pArchive_name = pArchive_name;
    pContext->pComment = pComment;
    pContext->comment_size = comment_size;
    pContext->user_extra_data_central = user_extra_data_central;
    pContext->user_extra_data_central_len = user_extra_data_central_len;
 
    if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
        pContext->gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
 
    if ((int)level_and_flags < 0)
        level_and_flags = MZ_DEFAULT_LEVEL;
    level = level_and_flags & 0xF;
 
    /* Sanity checks */
    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level == 0) || (level > MZ_UBER_COMPRESSION) || (max_size < 4))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pState = pZip->m_pState;
 
    /* We could support this, but why? */
    if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (!mz_zip_writer_validate_archive_name(pArchive_name))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
 
    if (pState->m_zip64)
    {
        if (pZip->m_total_files == MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
    else
    {
        if (pZip->m_total_files == MZ_UINT16_MAX)
        {
            pState->m_zip64 = MZ_TRUE;
            /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
        }
    }
 
    pContext->archive_name_size = strlen(pArchive_name);
    if (pContext->archive_name_size > MZ_UINT16_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
 
    num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
 
    /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
    if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + pContext->archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
 
    if (!pState->m_zip64)
    {
        /* Bail early if the archive would obviously become too large */
        if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + pContext->archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
            + pContext->archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
            + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
        {
            pState->m_zip64 = MZ_TRUE;
            /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
        }
    }
 
#ifndef MINIZ_NO_TIME
    if (pFile_time)
    {
        mz_zip_time_t_to_dos_time(*pFile_time, &pContext->dos_time, &pContext->dos_date);
    }
    else
    {
        MZ_TIME_T cur_time;
        time(&cur_time);
        mz_zip_time_t_to_dos_time(cur_time, &pContext->dos_time, &pContext->dos_date);
    }
#endif
 
    if (!mz_zip_writer_write_zeros(pZip, pContext->cur_archive_file_ofs, num_alignment_padding_bytes))
    {
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
    }
 
    pContext->cur_archive_file_ofs += num_alignment_padding_bytes;
    pContext->local_dir_header_ofs = pContext->cur_archive_file_ofs;
 
    if (pZip->m_file_offset_alignment)
    {
        MZ_ASSERT((pContext->cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
    }
 
    if (!pState->m_zip64 && (pContext->local_dir_header_ofs >= MZ_UINT32_MAX)) {
        pState->m_zip64 = MZ_TRUE;
        /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
    }
 
    MZ_CLEAR_OBJ(local_dir_header);
    if (max_size > MZ_UINT32_MAX)
    {
        pContext->pExtra_data = pContext->extra_data;
        pContext->extra_size  = mz_zip_writer_preallocate_extra_data(pContext->extra_data, 2 * sizeof(mz_uint64));
    }
 
    if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)pContext->archive_name_size, (mz_uint16)(pContext->extra_size + user_extra_data_len), 0, 0, 0, pContext->method, pContext->gen_flags, pContext->dos_time, pContext->dos_date))
        return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 
    if (pZip->m_pWrite(pZip->m_pIO_opaque, pContext->cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
    pContext->cur_archive_file_ofs += sizeof(local_dir_header);
 
    if (pZip->m_pWrite(pZip->m_pIO_opaque, pContext->cur_archive_file_ofs, pArchive_name, pContext->archive_name_size) != pContext->archive_name_size)
    {
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
    }
 
    pContext->cur_archive_file_ofs += pContext->archive_name_size;
 
    if (pState->m_zip64 || max_size >= MZ_UINT32_MAX) {
        if (pZip->m_pWrite(pZip->m_pIO_opaque, pContext->cur_archive_file_ofs, pContext->extra_data, pContext->extra_size) != pContext->extra_size)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        pContext->cur_archive_file_ofs += pContext->extra_size;
    }
 
    if (user_extra_data_len > 0)
    {
        if (pZip->m_pWrite(pZip->m_pIO_opaque, pContext->cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        pContext->cur_archive_file_ofs += user_extra_data_len;
    }
 
    assert(max_size);
    assert(level);
 
    pContext->pCompressor = (tdefl_compressor*)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor));
    if (!pContext->pCompressor)
    {
        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
    }
 
    pContext->add_state.m_pZip = pZip;
    pContext->add_state.m_cur_archive_file_ofs = pContext->cur_archive_file_ofs;
    pContext->add_state.m_comp_size = 0;
 
    if (tdefl_init(pContext->pCompressor, mz_zip_writer_add_put_buf_callback, &pContext->add_state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY)
    {
        pZip->m_pFree(pZip->m_pAlloc_opaque, pContext->pCompressor);
        return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
    }
 
    return MZ_TRUE;
}

Referenced by Slic3r::_3MF_Exporter::_add_model_file_to_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_end()

mz_bool mz_zip_writer_end ( mz_zip_archive * pZip )

{
    return mz_zip_writer_end_internal(pZip, MZ_TRUE);
}

References MZ_TRUE, and mz_zip_writer_end_internal().

Referenced by Slic3r::anonymous_namespace{miniz_extension.cpp}::close_zip(), mz_zip_end(), and mz_zip_writer_init_file_v2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_finalize_archive()

mz_bool mz_zip_writer_finalize_archive ( mz_zip_archive * pZip )

{
    mz_zip_internal_state *pState;
    mz_uint64 central_dir_ofs, central_dir_size;
    mz_uint8 hdr[256];
 
    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    pState = pZip->m_pState;
 
    if (pState->m_zip64)
    {
        if ((pZip->m_total_files > MZ_UINT32_MAX) || (pState->m_central_dir.m_size >= MZ_UINT32_MAX))
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
    else
    {
        if ((pZip->m_total_files > MZ_UINT16_MAX) || ((pZip->m_archive_size + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX))
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
 
    central_dir_ofs = 0;
    central_dir_size = 0;
    if (pZip->m_total_files)
    {
        /* Write central directory */
        central_dir_ofs = pZip->m_archive_size;
        central_dir_size = pState->m_central_dir.m_size;
        pZip->m_central_directory_file_ofs = central_dir_ofs;
        if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, pState->m_central_dir.m_p, (size_t)central_dir_size) != central_dir_size)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        pZip->m_archive_size += central_dir_size;
    }
 
    if (pState->m_zip64)
    {
        /* Write zip64 end of central directory header */
        mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size;
 
        MZ_CLEAR_OBJ(hdr);
        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDH_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG);
        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - sizeof(mz_uint32) - sizeof(mz_uint64));
        MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, 0x031E); /* TODO: always Unix */
        MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, 0x002D);
        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, pZip->m_total_files);
        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, pZip->m_total_files);
        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size);
        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs);
        if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE;
 
        /* Write zip64 end of central directory locator */
        MZ_CLEAR_OBJ(hdr);
        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG);
        MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, rel_ofs_to_zip64_ecdr);
        MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, 1);
        if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
        pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE;
    }
 
    /* Write end of central directory record */
    MZ_CLEAR_OBJ(hdr);
    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG);
    MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
    MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_size));
    MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_ofs));
 
    if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
 
#ifndef MINIZ_NO_STDIO
    if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF))
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
#endif /* #ifndef MINIZ_NO_STDIO */
 
    pZip->m_archive_size += MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE;
 
    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED;
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_archive::m_central_directory_file_ofs, mz_zip_array::m_p, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, mz_zip_archive::m_zip_mode, MZ_CLEAR_OBJ, MZ_FFLUSH, MZ_MIN, MZ_TRUE, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_WRITE_LE16, MZ_WRITE_LE32, MZ_WRITE_LE64, MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_ZIP64_ECDH_CDIR_OFS_OFS, MZ_ZIP64_ECDH_CDIR_SIZE_OFS, MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_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_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, MZ_ZIP64_ECDL_SIG_OFS, MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_CLOSE_FAILED, MZ_ZIP_FILE_WRITE_FAILED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_MODE_WRITING, MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED, mz_zip_set_error(), and MZ_ZIP_TOO_MANY_FILES.

Referenced by Slic3r::Zipper::~Zipper(), Slic3r::_3MF_Exporter::_save_model_to_file(), Slic3r::Zipper::finalize(), mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_writer_finalize_heap_archive(), and Slic3r::store_amf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_finalize_heap_archive()

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

{
    if ((!ppBuf) || (!pSize))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    *ppBuf = NULL;
    *pSize = 0;
 
    if ((!pZip) || (!pZip->m_pState))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (pZip->m_pWrite != mz_zip_heap_write_func)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (!mz_zip_writer_finalize_archive(pZip))
        return MZ_FALSE;
 
    *ppBuf = pZip->m_pState->m_pMem;
    *pSize = pZip->m_pState->m_mem_size;
    pZip->m_pState->m_pMem = NULL;
    pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0;
 
    return MZ_TRUE;
}

References mz_zip_internal_state_tag::m_mem_capacity, mz_zip_internal_state_tag::m_mem_size, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, MZ_FALSE, MZ_TRUE, mz_zip_heap_write_func(), MZ_ZIP_INVALID_PARAMETER, mz_zip_set_error(), and mz_zip_writer_finalize_archive().

Here is the call graph for this function:

◆ mz_zip_writer_init()

mz_bool mz_zip_writer_init	(	mz_zip_archive *	pZip,
		mz_uint64	existing_size
	)

{
    return mz_zip_writer_init_v2(pZip, existing_size, 0);
}

References mz_zip_writer_init_v2().

Here is the call graph for this function:

◆ mz_zip_writer_init_cfile()

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

{
    pZip->m_pWrite = mz_zip_file_write_func;
    pZip->m_pNeeds_keepalive = NULL;
 
    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
        pZip->m_pRead = mz_zip_file_read_func;
 
    pZip->m_pIO_opaque = pZip;
 
    if (!mz_zip_writer_init_v2(pZip, 0, flags))
        return MZ_FALSE;
 
    pZip->m_pState->m_pFile = pFile;
    pZip->m_pState->m_file_archive_start_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
    pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
 
    return MZ_TRUE;
}

References mz_zip_internal_state_tag::m_file_archive_start_ofs, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_FTELL64, MZ_TRUE, mz_zip_file_read_func(), mz_zip_file_write_func(), MZ_ZIP_FLAG_WRITE_ALLOW_READING, MZ_ZIP_TYPE_CFILE, and mz_zip_writer_init_v2().

Referenced by Slic3r::anonymous_namespace{miniz_extension.cpp}::open_zip().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    return mz_zip_writer_init_file_v2(pZip, pFilename, size_to_reserve_at_beginning, 0);
}

References mz_zip_writer_init_file_v2().

Here is the call graph for this function:

◆ 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_FILE *pFile;
 
    pZip->m_pWrite = mz_zip_file_write_func;
    pZip->m_pNeeds_keepalive = NULL;
 
    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
        pZip->m_pRead = mz_zip_file_read_func;
 
    pZip->m_pIO_opaque = pZip;
 
    if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
        return MZ_FALSE;
 
    if (NULL == (pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb")))
    {
        mz_zip_writer_end(pZip);
        return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
    }
 
    pZip->m_pState->m_pFile = pFile;
    pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
 
    if (size_to_reserve_at_beginning)
    {
        mz_uint64 cur_ofs = 0;
        char buf[4096];
 
        MZ_CLEAR_OBJ(buf);
 
        do
        {
            size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
            if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n)
            {
                mz_zip_writer_end(pZip);
                return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
            }
            cur_ofs += n;
            size_to_reserve_at_beginning -= n;
        } while (size_to_reserve_at_beginning);
    }
 
    return MZ_TRUE;
}

References mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_archive::m_zip_type, MZ_CLEAR_OBJ, MZ_FALSE, MZ_FILE, MZ_FOPEN, MZ_MIN, MZ_TRUE, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_read_func(), MZ_ZIP_FILE_WRITE_FAILED, mz_zip_file_write_func(), MZ_ZIP_FLAG_WRITE_ALLOW_READING, mz_zip_set_error(), MZ_ZIP_TYPE_FILE, mz_zip_writer_end(), and mz_zip_writer_init_v2().

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), and mz_zip_writer_init_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_init_from_reader()

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

{
    return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0);
}

References mz_zip_writer_init_from_reader_v2().

Here is the call graph for this function:

◆ 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_internal_state *pState;
 
    if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (flags & MZ_ZIP_FLAG_WRITE_ZIP64)
    {
        /* We don't support converting a non-zip64 file to zip64 - this seems like more trouble than it's worth. (What about the existing 32-bit data descriptors that could follow the compressed data?) */
        if (!pZip->m_pState->m_zip64)
            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
    }
 
    /* No sense in trying to write to an archive that's already at the support max size */
    if (pZip->m_pState->m_zip64)
    {
        if (pZip->m_total_files == MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
    }
    else
    {
        if (pZip->m_total_files == MZ_UINT16_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
 
        if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)
            return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
    }
 
    pState = pZip->m_pState;
 
    if (pState->m_pFile)
    {
#ifdef MINIZ_NO_STDIO
        (void)pFilename;
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
#else
        if (pZip->m_pIO_opaque != pZip)
            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
        if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
        {
            if (!pFilename)
                return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
            /* Archive is being read from stdio and was originally opened only for reading. Try to reopen as writable. */
            if (NULL == (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile)))
            {
                /* The mz_zip_archive is now in a bogus state because pState->m_pFile is NULL, so just close it. */
                mz_zip_reader_end_internal(pZip, MZ_FALSE);
                return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
            }
        }
 
        pZip->m_pWrite = mz_zip_file_write_func;
        pZip->m_pNeeds_keepalive = NULL;
#endif /* #ifdef MINIZ_NO_STDIO */
    }
    else if (pState->m_pMem)
    {
        /* Archive lives in a memory block. Assume it's from the heap that we can resize using the realloc callback. */
        if (pZip->m_pIO_opaque != pZip)
            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
        pState->m_mem_capacity = pState->m_mem_size;
        pZip->m_pWrite = mz_zip_heap_write_func;
        pZip->m_pNeeds_keepalive = NULL;
    }
    /* Archive is being read via a user provided read function - make sure the user has specified a write function too. */
    else if (!pZip->m_pWrite)
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    /* Start writing new files at the archive's current central directory location. */
    /* TODO: We could add a flag that lets the user start writing immediately AFTER the existing central dir - this would be safer. */
    pZip->m_archive_size = pZip->m_central_directory_file_ofs;
    pZip->m_central_directory_file_ofs = 0;
 
    /* Clear the sorted central dir offsets, they aren't useful or maintained now. */
    /* Even though we're now in write mode, files can still be extracted and verified, but file locates will be slow. */
    /* TODO: We could easily maintain the sorted central directory offsets. */
    mz_zip_array_clear(pZip, &pZip->m_pState->m_sorted_central_dir_offsets);
 
    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
 
    return MZ_TRUE;
}

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), and mz_zip_writer_init_from_reader().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    return mz_zip_writer_init_heap_v2(pZip, size_to_reserve_at_beginning, initial_allocation_size, 0);
}

References mz_zip_writer_init_heap_v2().

Here is the call graph for this function:

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

{
    pZip->m_pWrite = mz_zip_heap_write_func;
    pZip->m_pNeeds_keepalive = NULL;
 
    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
        pZip->m_pRead = mz_zip_mem_read_func;
 
    pZip->m_pIO_opaque = pZip;
 
    if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
        return MZ_FALSE;
 
    pZip->m_zip_type = MZ_ZIP_TYPE_HEAP;
 
    if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
    {
        if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size)))
        {
            mz_zip_writer_end_internal(pZip, MZ_FALSE);
            return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
        }
        pZip->m_pState->m_mem_capacity = initial_allocation_size;
    }
 
    return MZ_TRUE;
}

References mz_zip_internal_state_tag::m_mem_capacity, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_MAX, MZ_TRUE, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_FLAG_WRITE_ALLOW_READING, mz_zip_heap_write_func(), mz_zip_mem_read_func(), mz_zip_set_error(), MZ_ZIP_TYPE_HEAP, mz_zip_writer_end_internal(), and mz_zip_writer_init_v2().

Referenced by mz_zip_writer_init_heap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_writer_init_v2()

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

{
    mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0;
 
    if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 
    if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
    {
        if (!pZip->m_pRead)
            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
    }
 
    if (pZip->m_file_offset_alignment)
    {
        /* Ensure user specified file offset alignment is a power of 2. */
        if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1))
            return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
    }
 
    if (!pZip->m_pAlloc)
        pZip->m_pAlloc = miniz_def_alloc_func;
    if (!pZip->m_pFree)
        pZip->m_pFree = miniz_def_free_func;
    if (!pZip->m_pRealloc)
        pZip->m_pRealloc = miniz_def_realloc_func;
 
    pZip->m_archive_size = existing_size;
    pZip->m_central_directory_file_ofs = 0;
    pZip->m_total_files = 0;
 
    if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 
    memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
 
    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
    MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
 
    pZip->m_pState->m_zip64 = zip64;
    pZip->m_pState->m_zip64_has_extended_info_fields = zip64;
 
    pZip->m_zip_type = MZ_ZIP_TYPE_USER;
    pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
 
    return MZ_TRUE;
}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_internal_state_tag::m_central_dir_offsets, mz_zip_archive::m_central_directory_file_ofs, mz_zip_archive::m_file_offset_alignment, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pRead, mz_zip_archive::m_pRealloc, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_internal_state_tag::m_sorted_central_dir_offsets, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, mz_zip_internal_state_tag::m_zip64_has_extended_info_fields, mz_zip_archive::m_zip_mode, mz_zip_archive::m_zip_type, miniz_def_alloc_func(), miniz_def_free_func(), miniz_def_realloc_func(), MZ_TRUE, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARRAY_SET_ELEMENT_SIZE, MZ_ZIP_FLAG_WRITE_ALLOW_READING, MZ_ZIP_FLAG_WRITE_ZIP64, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_MODE_INVALID, MZ_ZIP_MODE_WRITING, mz_zip_set_error(), and MZ_ZIP_TYPE_USER.

Referenced by mz_zip_writer_init(), mz_zip_writer_init_cfile(), mz_zip_writer_init_file_v2(), and mz_zip_writer_init_heap_v2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mz_zip_zero_struct()

void mz_zip_zero_struct ( mz_zip_archive * pZip )

{
    if (pZip)
        MZ_CLEAR_OBJ(*pZip);
}

References MZ_CLEAR_OBJ.

Referenced by Slic3r::MZ_Archive::MZ_Archive(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::_3MF_Exporter::_save_model_to_file(), Slic3r::is_project_3mf(), Slic3r::load_amf_archive(), mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_extract_archive_file_to_heap_v2(), mz_zip_validate_file_archive(), mz_zip_validate_mem_archive(), Slic3r::GUI::Plater::preview_zip_archive(), Slic3r::store_amf(), and Slic3r::PresetUpdater::priv::sync_config().

Here is the caller graph for this function:

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

{
    if (!d)
    {
        if (pIn_buf_size)
            *pIn_buf_size = 0;
        if (pOut_buf_size)
            *pOut_buf_size = 0;
        return TDEFL_STATUS_BAD_PARAM;
    }
 
    d->m_pIn_buf = pIn_buf;
    d->m_pIn_buf_size = pIn_buf_size;
    d->m_pOut_buf = pOut_buf;
    d->m_pOut_buf_size = pOut_buf_size;
    d->m_pSrc = (const mz_uint8 *)(pIn_buf);
    d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0;
    d->m_out_buf_ofs = 0;
    d->m_flush = flush;
 
    if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) ||
        (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf))
    {
        if (pIn_buf_size)
            *pIn_buf_size = 0;
        if (pOut_buf_size)
            *pOut_buf_size = 0;
        return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM);
    }
    d->m_wants_to_finish |= (flush == TDEFL_FINISH);
 
    if ((d->m_output_flush_remaining) || (d->m_finished))
        return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
 
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
    if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) &&
        ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) &&
        ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0))
    {
        if (!tdefl_compress_fast(d))
            return d->m_prev_return_status;
    }
    else
#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
    {
        if (!tdefl_compress_normal(d))
            return d->m_prev_return_status;
    }
 
    if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf))
        d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf);
 
    if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining))
    {
        if (tdefl_flush_block(d, flush) < 0)
            return d->m_prev_return_status;
        d->m_finished = (flush == TDEFL_FINISH);
        if (flush == TDEFL_FULL_FLUSH)
        {
            MZ_CLEAR_OBJ(d->m_hash);
            MZ_CLEAR_OBJ(d->m_next);
            d->m_dict_size = 0;
        }
    }
 
    return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
}

References mz_adler32(), MZ_CLEAR_OBJ, tdefl_compress_normal(), TDEFL_COMPUTE_ADLER32, TDEFL_FILTER_MATCHES, TDEFL_FINISH, tdefl_flush_block(), tdefl_flush_output_buffer(), TDEFL_FORCE_ALL_RAW_BLOCKS, TDEFL_FULL_FLUSH, TDEFL_GREEDY_PARSING_FLAG, TDEFL_MAX_PROBES_MASK, TDEFL_RLE_MATCHES, TDEFL_STATUS_BAD_PARAM, TDEFL_STATUS_OKAY, and TDEFL_WRITE_ZLIB_HEADER.

Referenced by mz_deflate(), and tdefl_compress_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tdefl_compress_buffer()

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

{
    MZ_ASSERT(d->m_pPut_buf_func);
    return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
}

References MZ_ASSERT, and tdefl_compress().

Referenced by mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_read_buf_callback(), mz_zip_writer_add_staged_data(), tdefl_compress_mem_to_output(), and tdefl_write_image_to_png_file_in_memory_ex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_len)
        return MZ_FALSE;
    else
        *pOut_len = 0;
    out_buf.m_expandable = MZ_TRUE;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return NULL;
    *pOut_len = out_buf.m_size;
    return out_buf.m_pBuf;
}

References tdefl_output_buffer::m_expandable, tdefl_output_buffer::m_pBuf, tdefl_output_buffer::m_size, MZ_CLEAR_OBJ, MZ_FALSE, MZ_TRUE, tdefl_compress_mem_to_output(), and tdefl_output_buffer_putter().

Here is the call graph for this function:

◆ 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_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_buf)
        return 0;
    out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
    out_buf.m_capacity = out_buf_len;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return 0;
    return out_buf.m_size;
}

References tdefl_output_buffer::m_capacity, tdefl_output_buffer::m_pBuf, tdefl_output_buffer::m_size, MZ_CLEAR_OBJ, tdefl_compress_mem_to_output(), and tdefl_output_buffer_putter().

Here is the call graph for this function:

◆ 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 *pComp;
    mz_bool succeeded;
    if (((buf_len) && (!pBuf)) || (!pPut_buf_func))
        return MZ_FALSE;
    pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
    if (!pComp)
        return MZ_FALSE;
    succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
    succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
    MZ_FREE(pComp);
    return succeeded;
}

References MZ_FALSE, MZ_FREE, MZ_MALLOC, tdefl_compress_buffer(), TDEFL_FINISH, tdefl_init(), TDEFL_STATUS_DONE, and TDEFL_STATUS_OKAY.

Referenced by tdefl_compress_mem_to_heap(), and tdefl_compress_mem_to_mem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tdefl_compressor_alloc()

tdefl_compressor * tdefl_compressor_alloc ( void )

{
    return (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
}

References MZ_MALLOC.

◆ tdefl_compressor_free()

void tdefl_compressor_free ( tdefl_compressor * pComp )

{
    MZ_FREE(pComp);
}

References MZ_FREE.

◆ tdefl_create_comp_flags_from_zip_params()

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

{
    mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
    if (window_bits > 0)
        comp_flags |= TDEFL_WRITE_ZLIB_HEADER;
 
    if (!level)
        comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
    else if (strategy == MZ_FILTERED)
        comp_flags |= TDEFL_FILTER_MATCHES;
    else if (strategy == MZ_HUFFMAN_ONLY)
        comp_flags &= ~TDEFL_MAX_PROBES_MASK;
    else if (strategy == MZ_FIXED)
        comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
    else if (strategy == MZ_RLE)
        comp_flags |= TDEFL_RLE_MATCHES;
 
    return comp_flags;
}

References MZ_DEFAULT_LEVEL, MZ_FILTERED, MZ_FIXED, MZ_HUFFMAN_ONLY, MZ_MIN, MZ_RLE, s_tdefl_num_probes, TDEFL_FILTER_MATCHES, TDEFL_FORCE_ALL_RAW_BLOCKS, TDEFL_FORCE_ALL_STATIC_BLOCKS, TDEFL_GREEDY_PARSING_FLAG, TDEFL_RLE_MATCHES, and TDEFL_WRITE_ZLIB_HEADER.

Referenced by mz_deflateInit2(), mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_read_buf_callback(), and mz_zip_writer_add_staged_open().

Here is the caller graph for this function:

◆ tdefl_get_adler32()

mz_uint32 tdefl_get_adler32 ( tdefl_compressor * d )

{
    return d->m_adler32;
}

Referenced by mz_deflate().

Here is the caller graph for this function:

◆ tdefl_get_prev_return_status()

tdefl_status tdefl_get_prev_return_status ( tdefl_compressor * d )

{
    return d->m_prev_return_status;
}

◆ tdefl_init()

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

{
    d->m_pPut_buf_func = pPut_buf_func;
    d->m_pPut_buf_user = pPut_buf_user;
    d->m_flags = (mz_uint)(flags);
    d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3;
    d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
    d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
    if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
        MZ_CLEAR_OBJ(d->m_hash);
    d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0;
    d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0;
    d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
    d->m_pLZ_flags = d->m_lz_code_buf;
    d->m_num_flags_left = 8;
    d->m_pOutput_buf = d->m_output_buf;
    d->m_pOutput_buf_end = d->m_output_buf;
    d->m_prev_return_status = TDEFL_STATUS_OKAY;
    d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0;
    d->m_adler32 = 1;
    d->m_pIn_buf = NULL;
    d->m_pOut_buf = NULL;
    d->m_pIn_buf_size = NULL;
    d->m_pOut_buf_size = NULL;
    d->m_flush = TDEFL_NO_FLUSH;
    d->m_pSrc = NULL;
    d->m_src_buf_left = 0;
    d->m_out_buf_ofs = 0;
    if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
        MZ_CLEAR_OBJ(d->m_dict);
    memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
    memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
    return TDEFL_STATUS_OKAY;
}

References MZ_CLEAR_OBJ, TDEFL_GREEDY_PARSING_FLAG, TDEFL_MAX_HUFF_SYMBOLS_0, TDEFL_MAX_HUFF_SYMBOLS_1, TDEFL_NO_FLUSH, TDEFL_NONDETERMINISTIC_PARSING_FLAG, and TDEFL_STATUS_OKAY.

Referenced by mz_deflateInit2(), mz_deflateReset(), mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_read_buf_callback(), mz_zip_writer_add_staged_open(), tdefl_compress_mem_to_output(), and tdefl_write_image_to_png_file_in_memory_ex().

Here is the caller graph for this function:

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

{
    /* Level 6 corresponds to TDEFL_DEFAULT_MAX_PROBES or MZ_DEFAULT_LEVEL (but we can't depend on MZ_DEFAULT_LEVEL being available in case the zlib API's where #defined out) */
    return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, pLen_out, 6, MZ_FALSE);
}

References MZ_FALSE, and tdefl_write_image_to_png_file_in_memory_ex().

Referenced by Slic3r::sla::PNGRasterEncoder::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    /* Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was defined. */
    static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
    tdefl_compressor *pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
    tdefl_output_buffer out_buf;
    int i, bpl = w * num_chans, y, z;
    mz_uint32 c;
    *pLen_out = 0;
    if (!pComp)
        return NULL;
    MZ_CLEAR_OBJ(out_buf);
    out_buf.m_expandable = MZ_TRUE;
    out_buf.m_capacity = 57 + MZ_MAX(64, (1 + bpl) * h);
    if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity)))
    {
        MZ_FREE(pComp);
        return NULL;
    }
    /* write dummy header */
    for (z = 41; z; --z)
        tdefl_output_buffer_putter(&z, 1, &out_buf);
    /* compress image data */
    tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, s_tdefl_png_num_probes[MZ_MIN(10, level)] | TDEFL_WRITE_ZLIB_HEADER);
    for (y = 0; y < h; ++y)
    {
        tdefl_compress_buffer(pComp, &z, 1, TDEFL_NO_FLUSH);
        tdefl_compress_buffer(pComp, (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH);
    }
    if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != TDEFL_STATUS_DONE)
    {
        MZ_FREE(pComp);
        MZ_FREE(out_buf.m_pBuf);
        return NULL;
    }
    /* write real header */
    *pLen_out = out_buf.m_size - 41;
    {
        static const mz_uint8 chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 };
        mz_uint8 pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d,
                                0x0a, 0x1a, 0x0a, 0x00, 0x00,
                                0x00, 0x0d, 0x49, 0x48, 0x44,
                                0x52, 0x00, 0x00, 0x00, 0x00,
                                0x00, 0x00, 0x00, 0x00, 0x08,
                                0x00, 0x00, 0x00, 0x00, 0x00,
                                0x00, 0x00, 0x00, 0x00, 0x00,
                                0x00, 0x00, 0x49, 0x44, 0x41,
                                0x54 };
        pnghdr[18] = (mz_uint8)(w >> 8);
        pnghdr[19] = (mz_uint8)w;
        pnghdr[22] = (mz_uint8)(h >> 8);
        pnghdr[23] = (mz_uint8)h;
        pnghdr[25] = chans[num_chans];
        pnghdr[33] = (mz_uint8)(*pLen_out >> 24);
        pnghdr[34] = (mz_uint8)(*pLen_out >> 16);
        pnghdr[35] = (mz_uint8)(*pLen_out >> 8);
        pnghdr[36] = (mz_uint8)*pLen_out;
        c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17);
        for (i = 0; i < 4; ++i, c <<= 8)
            ((mz_uint8 *)(pnghdr + 29))[i] = (mz_uint8)(c >> 24);
        memcpy(out_buf.m_pBuf, pnghdr, 41);
    }
    /* write footer (IDAT CRC-32, followed by IEND chunk) */
    if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf))
    {
        *pLen_out = 0;
        MZ_FREE(pComp);
        MZ_FREE(out_buf.m_pBuf);
        return NULL;
    }
    c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, out_buf.m_pBuf + 41 - 4, *pLen_out + 4);
    for (i = 0; i < 4; ++i, c <<= 8)
        (out_buf.m_pBuf + out_buf.m_size - 16)[i] = (mz_uint8)(c >> 24);
    /* compute final size of file, grab compressed data buffer and return */
    *pLen_out += 57;
    MZ_FREE(pComp);
    return out_buf.m_pBuf;
}

References tdefl_output_buffer::m_capacity, tdefl_output_buffer::m_expandable, tdefl_output_buffer::m_pBuf, tdefl_output_buffer::m_size, MZ_CLEAR_OBJ, mz_crc32(), MZ_CRC32_INIT, MZ_FREE, MZ_MALLOC, MZ_MAX, MZ_MIN, MZ_TRUE, tdefl_compress_buffer(), TDEFL_FINISH, tdefl_init(), TDEFL_NO_FLUSH, tdefl_output_buffer_putter(), TDEFL_STATUS_DONE, and TDEFL_WRITE_ZLIB_HEADER.

Referenced by Slic3r::_3MF_Exporter::_add_thumbnail_file_to_archive(), Slic3r::GCodeThumbnails::compress_thumbnail_png(), tdefl_write_image_to_png_file_in_memory(), and Slic3r::write_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    static const int s_length_base[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 };
    static const int s_length_extra[31] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0 };
    static const int s_dist_base[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0 };
    static const int s_dist_extra[32] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
    static const mz_uint8 s_length_dezigzag[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
    static const int s_min_table_sizes[3] = { 257, 1, 4 };
 
    tinfl_status status = TINFL_STATUS_FAILED;
    mz_uint32 num_bits, dist, counter, num_extra;
    tinfl_bit_buf_t bit_buf;
    const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
    mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next + *pOut_buf_size;
    size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start;
 
    /* Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter). */
    if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start))
    {
        *pIn_buf_size = *pOut_buf_size = 0;
        return TINFL_STATUS_BAD_PARAM;
    }
 
    num_bits = r->m_num_bits;
    bit_buf = r->m_bit_buf;
    dist = r->m_dist;
    counter = r->m_counter;
    num_extra = r->m_num_extra;
    dist_from_out_buf_start = r->m_dist_from_out_buf_start;
    TINFL_CR_BEGIN
 
    bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0;
    r->m_z_adler32 = r->m_check_adler32 = 1;
    if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
    {
        TINFL_GET_BYTE(1, r->m_zhdr0);
        TINFL_GET_BYTE(2, r->m_zhdr1);
        counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
        if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
            counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (r->m_zhdr0 >> 4)))));
        if (counter)
        {
            TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED);
        }
    }
 
    do
    {
        TINFL_GET_BITS(3, r->m_final, 3);
        r->m_type = r->m_final >> 1;
        if (r->m_type == 0)
        {
            TINFL_SKIP_BITS(5, num_bits & 7);
            for (counter = 0; counter < 4; ++counter)
            {
                if (num_bits)
                    TINFL_GET_BITS(6, r->m_raw_header[counter], 8);
                else
                    TINFL_GET_BYTE(7, r->m_raw_header[counter]);
            }
            if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8))))
            {
                TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED);
            }
            while ((counter) && (num_bits))
            {
                TINFL_GET_BITS(51, dist, 8);
                while (pOut_buf_cur >= pOut_buf_end)
                {
                    TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT);
                }
                *pOut_buf_cur++ = (mz_uint8)dist;
                counter--;
            }
            while (counter)
            {
                size_t n;
                while (pOut_buf_cur >= pOut_buf_end)
                {
                    TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT);
                }
                while (pIn_buf_cur >= pIn_buf_end)
                {
                    TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);
                }
                n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter);
                TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n);
                pIn_buf_cur += n;
                pOut_buf_cur += n;
                counter -= (mz_uint)n;
            }
        }
        else if (r->m_type == 3)
        {
            TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
        }
        else
        {
            if (r->m_type == 1)
            {
                mz_uint8 *p = r->m_tables[0].m_code_size;
                mz_uint i;
                r->m_table_sizes[0] = 288;
                r->m_table_sizes[1] = 32;
                TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32);
                for (i = 0; i <= 143; ++i)
                    *p++ = 8;
                for (; i <= 255; ++i)
                    *p++ = 9;
                for (; i <= 279; ++i)
                    *p++ = 7;
                for (; i <= 287; ++i)
                    *p++ = 8;
            }
            else
            {
                for (counter = 0; counter < 3; counter++)
                {
                    TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]);
                    r->m_table_sizes[counter] += s_min_table_sizes[counter];
                }
                MZ_CLEAR_OBJ(r->m_tables[2].m_code_size);
                for (counter = 0; counter < r->m_table_sizes[2]; counter++)
                {
                    mz_uint s;
                    TINFL_GET_BITS(14, s, 3);
                    r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s;
                }
                r->m_table_sizes[2] = 19;
            }
            for (; (int)r->m_type >= 0; r->m_type--)
            {
                int tree_next, tree_cur;
                tinfl_huff_table *pTable;
                mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16];
                pTable = &r->m_tables[r->m_type];
                MZ_CLEAR_OBJ(total_syms);
                MZ_CLEAR_OBJ(pTable->m_look_up);
                MZ_CLEAR_OBJ(pTable->m_tree);
                for (i = 0; i < r->m_table_sizes[r->m_type]; ++i)
                    total_syms[pTable->m_code_size[i]]++;
                used_syms = 0, total = 0;
                next_code[0] = next_code[1] = 0;
                for (i = 1; i <= 15; ++i)
                {
                    used_syms += total_syms[i];
                    next_code[i + 1] = (total = ((total + total_syms[i]) << 1));
                }
                if ((65536 != total) && (used_syms > 1))
                {
                    TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
                }
                for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
                {
                    mz_uint rev_code = 0, l, cur_code, code_size = pTable->m_code_size[sym_index];
                    if (!code_size)
                        continue;
                    cur_code = next_code[code_size]++;
                    for (l = code_size; l > 0; l--, cur_code >>= 1)
                        rev_code = (rev_code << 1) | (cur_code & 1);
                    if (code_size <= TINFL_FAST_LOOKUP_BITS)
                    {
                        mz_int16 k = (mz_int16)((code_size << 9) | sym_index);
                        while (rev_code < TINFL_FAST_LOOKUP_SIZE)
                        {
                            pTable->m_look_up[rev_code] = k;
                            rev_code += (1 << code_size);
                        }
                        continue;
                    }
                    if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)]))
                    {
                        pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next;
                        tree_cur = tree_next;
                        tree_next -= 2;
                    }
                    rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
                    for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
                    {
                        tree_cur -= ((rev_code >>= 1) & 1);
                        if (!pTable->m_tree[-tree_cur - 1])
                        {
                            pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next;
                            tree_cur = tree_next;
                            tree_next -= 2;
                        }
                        else
                            tree_cur = pTable->m_tree[-tree_cur - 1];
                    }
                    tree_cur -= ((rev_code >>= 1) & 1);
                    pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index;
                }
                if (r->m_type == 2)
                {
                    for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);)
                    {
                        mz_uint s;
                        TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]);
                        if (dist < 16)
                        {
                            r->m_len_codes[counter++] = (mz_uint8)dist;
                            continue;
                        }
                        if ((dist == 16) && (!counter))
                        {
                            TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
                        }
                        num_extra = "\02\03\07"[dist - 16];
                        TINFL_GET_BITS(18, s, num_extra);
                        s += "\03\03\013"[dist - 16];
                        TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s);
                        counter += s;
                    }
                    if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
                    {
                        TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
                    }
                    TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, r->m_table_sizes[0]);
                    TINFL_MEMCPY(r->m_tables[1].m_code_size, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]);
                }
            }
            for (;;)
            {
                mz_uint8 *pSrc;
                for (;;)
                {
                    if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
                    {
                        TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]);
                        if (counter >= 256)
                            break;
                        while (pOut_buf_cur >= pOut_buf_end)
                        {
                            TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT);
                        }
                        *pOut_buf_cur++ = (mz_uint8)counter;
                    }
                    else
                    {
                        int sym2;
                        mz_uint code_len;
#if TINFL_USE_64BIT_BITBUF
                        if (num_bits < 30)
                        {
                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits);
                            pIn_buf_cur += 4;
                            num_bits += 32;
                        }
#else
                        if (num_bits < 15)
                        {
                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
                            pIn_buf_cur += 2;
                            num_bits += 16;
                        }
#endif
                        if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
                            code_len = sym2 >> 9;
                        else
                        {
                            code_len = TINFL_FAST_LOOKUP_BITS;
                            do
                            {
                                sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
                            } while (sym2 < 0);
                        }
                        counter = sym2;
                        bit_buf >>= code_len;
                        num_bits -= code_len;
                        if (counter & 256)
                            break;
 
#if !TINFL_USE_64BIT_BITBUF
                        if (num_bits < 15)
                        {
                            bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
                            pIn_buf_cur += 2;
                            num_bits += 16;
                        }
#endif
                        if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
                            code_len = sym2 >> 9;
                        else
                        {
                            code_len = TINFL_FAST_LOOKUP_BITS;
                            do
                            {
                                sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];
                            } while (sym2 < 0);
                        }
                        bit_buf >>= code_len;
                        num_bits -= code_len;
 
                        pOut_buf_cur[0] = (mz_uint8)counter;
                        if (sym2 & 256)
                        {
                            pOut_buf_cur++;
                            counter = sym2;
                            break;
                        }
                        pOut_buf_cur[1] = (mz_uint8)sym2;
                        pOut_buf_cur += 2;
                    }
                }
                if ((counter &= 511) == 256)
                    break;
 
                num_extra = s_length_extra[counter - 257];
                counter = s_length_base[counter - 257];
                if (num_extra)
                {
                    mz_uint extra_bits;
                    TINFL_GET_BITS(25, extra_bits, num_extra);
                    counter += extra_bits;
                }
 
                TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]);
                num_extra = s_dist_extra[dist];
                dist = s_dist_base[dist];
                if (num_extra)
                {
                    mz_uint extra_bits;
                    TINFL_GET_BITS(27, extra_bits, num_extra);
                    dist += extra_bits;
                }
 
                dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
                if ((dist > dist_from_out_buf_start) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
                {
                    TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
                }
 
                pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
 
                if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
                {
                    while (counter--)
                    {
                        while (pOut_buf_cur >= pOut_buf_end)
                        {
                            TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT);
                        }
                        *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
                    }
                    continue;
                }
#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
                else if ((counter >= 9) && (counter <= dist))
                {
                    const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
                    do
                    {
#ifdef MINIZ_UNALIGNED_USE_MEMCPY
            memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2);
#else
                        ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
                        ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
#endif
                        pOut_buf_cur += 8;
                    } while ((pSrc += 8) < pSrc_end);
                    if ((counter &= 7) < 3)
                    {
                        if (counter)
                        {
                            pOut_buf_cur[0] = pSrc[0];
                            if (counter > 1)
                                pOut_buf_cur[1] = pSrc[1];
                            pOut_buf_cur += counter;
                        }
                        continue;
                    }
                }
#endif
                while(counter>2)
                {
                    pOut_buf_cur[0] = pSrc[0];
                    pOut_buf_cur[1] = pSrc[1];
                    pOut_buf_cur[2] = pSrc[2];
                    pOut_buf_cur += 3;
                    pSrc += 3;
          counter -= 3;
                }
                if (counter > 0)
                {
                    pOut_buf_cur[0] = pSrc[0];
                    if (counter > 1)
                        pOut_buf_cur[1] = pSrc[1];
                    pOut_buf_cur += counter;
                }
            }
        }
    } while (!(r->m_final & 1));
 
    /* Ensure byte alignment and put back any bytes from the bitbuf if we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
    /* I'm being super conservative here. A number of simplifications can be made to the byte alignment part, and the Adler32 check shouldn't ever need to worry about reading from the bitbuf now. */
    TINFL_SKIP_BITS(32, num_bits & 7);
    while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
    {
        --pIn_buf_cur;
        num_bits -= 8;
    }
    bit_buf &= (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1);
    MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end of non-deflate/zlib streams with following data (such as gzip streams). */
 
    if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
    {
        for (counter = 0; counter < 4; ++counter)
        {
            mz_uint s;
            if (num_bits)
                TINFL_GET_BITS(41, s, 8);
            else
                TINFL_GET_BYTE(42, s);
            r->m_z_adler32 = (r->m_z_adler32 << 8) | s;
        }
    }
    TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
 
    TINFL_CR_FINISH
 
common_exit:
    /* As long as we aren't telling the caller that we NEED more input to make forward progress: */
    /* Put back any bytes from the bitbuf in case we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
    /* We need to be very careful here to NOT push back any bytes we definitely know we need to make forward progress, though, or we'll lock the caller up into an inf loop. */
    if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS))
    {
        while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
        {
            --pIn_buf_cur;
            num_bits -= 8;
        }
    }
    r->m_num_bits = num_bits;
    r->m_bit_buf = bit_buf & (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1);
    r->m_dist = dist;
    r->m_counter = counter;
    r->m_num_extra = num_extra;
    r->m_dist_from_out_buf_start = dist_from_out_buf_start;
    *pIn_buf_size = pIn_buf_cur - pIn_buf_next;
    *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
    if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
    {
        const mz_uint8 *ptr = pOut_buf_next;
        size_t buf_len = *pOut_buf_size;
        mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16;
        size_t block_len = buf_len % 5552;
        while (buf_len)
        {
            for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
            {
                s1 += ptr[0], s2 += s1;
                s1 += ptr[1], s2 += s1;
                s1 += ptr[2], s2 += s1;
                s1 += ptr[3], s2 += s1;
                s1 += ptr[4], s2 += s1;
                s1 += ptr[5], s2 += s1;
                s1 += ptr[6], s2 += s1;
                s1 += ptr[7], s2 += s1;
            }
            for (; i < block_len; ++i)
                s1 += *ptr++, s2 += s1;
            s1 %= 65521U, s2 %= 65521U;
            buf_len -= block_len;
            block_len = 5552;
        }
        r->m_check_adler32 = (s2 << 16) + s1;
        if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32))
            status = TINFL_STATUS_ADLER32_MISMATCH;
    }
    return status;
}

Referenced by mz_inflate(), mz_zip_reader_extract_iter_read(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_mem_no_alloc(), tinfl_decompress_mem_to_callback(), tinfl_decompress_mem_to_heap(), and tinfl_decompress_mem_to_mem().

Here is the caller graph for this function:

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

{
    int result = 0;
    tinfl_decompressor decomp;
    mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
    size_t in_buf_ofs = 0, dict_ofs = 0;
    if (!pDict)
        return TINFL_STATUS_FAILED;
    tinfl_init(&decomp);
    for (;;)
    {
        size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
                                               (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
        in_buf_ofs += in_buf_size;
        if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
            break;
        if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
        {
            result = (status == TINFL_STATUS_DONE);
            break;
        }
        dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
    }
    MZ_FREE(pDict);
    *pIn_buf_size = in_buf_ofs;
    return result;
}

References MZ_FREE, MZ_MALLOC, tinfl_decompress(), TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_init, TINFL_LZ_DICT_SIZE, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, and TINFL_STATUS_HAS_MORE_OUTPUT.

Here is the call graph for this function:

◆ 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_decompressor decomp;
    void *pBuf = NULL, *pNew_buf;
    size_t src_buf_ofs = 0, out_buf_capacity = 0;
    *pOut_len = 0;
    tinfl_init(&decomp);
    for (;;)
    {
        size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, &dst_buf_size,
                                               (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
        if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        src_buf_ofs += src_buf_size;
        *pOut_len += dst_buf_size;
        if (status == TINFL_STATUS_DONE)
            break;
        new_out_buf_capacity = out_buf_capacity * 2;
        if (new_out_buf_capacity < 128)
            new_out_buf_capacity = 128;
        pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
        if (!pNew_buf)
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        pBuf = pNew_buf;
        out_buf_capacity = new_out_buf_capacity;
    }
    return pBuf;
}

References MZ_FREE, MZ_REALLOC, tinfl_decompress(), TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_init, TINFL_STATUS_DONE, and TINFL_STATUS_NEEDS_MORE_INPUT.

Here is the call graph for this function:

◆ 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 decomp;
    tinfl_status status;
    tinfl_init(&decomp);
    status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf, &src_buf_len, (mz_uint8 *)pOut_buf, (mz_uint8 *)pOut_buf, &out_buf_len, (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
    return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
}

References tinfl_decompress(), TINFL_DECOMPRESS_MEM_TO_MEM_FAILED, TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_init, and TINFL_STATUS_DONE.

Here is the call graph for this function:

◆ tinfl_decompressor_alloc()

tinfl_decompressor * tinfl_decompressor_alloc ( void )

{
    tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor));
    if (pDecomp)
        tinfl_init(pDecomp);
    return pDecomp;
}

References MZ_MALLOC, and tinfl_init.

◆ tinfl_decompressor_free()

void tinfl_decompressor_free ( tinfl_decompressor * pDecomp )

{
    MZ_FREE(pDecomp);
}

References MZ_FREE.

Classes

Macros

Typedefs

Enumerations

Functions

Class Documentation

◆ mz_stream_s

◆ tdefl_compressor

◆ tinfl_huff_table

◆ tinfl_decompressor_tag

◆ mz_zip_archive_file_stat

◆ mz_zip_archive

◆ mz_zip_reader_extract_iter_state

◆ mz_zip_writer_add_state

◆ mz_zip_writer_staged_context

Macro Definition Documentation

◆ adler32

◆ alloc_func

◆ compress

◆ compress2

◆ compressBound

◆ crc32

◆ deflate

◆ deflateBound

◆ deflateEnd

◆ deflateInit

◆ deflateInit2

◆ deflateReset

◆ free_func

◆ inflate

◆ inflateEnd

◆ inflateInit

◆ inflateInit2

◆ inflateReset

◆ internal_state

◆ MAX_MEM_LEVEL

◆ MAX_WBITS

◆ MINIZ_HAS_64BIT_REGISTERS

◆ MINIZ_LITTLE_ENDIAN

◆ MINIZ_USE_UNALIGNED_LOADS_AND_STORES

◆ MINIZ_X86_OR_X64_CPU

◆ MZ_ADLER32_INIT

◆ MZ_ASSERT

◆ MZ_CLEAR_OBJ

◆ MZ_CRC32_INIT

◆ MZ_DEFAULT_WINDOW_BITS

◆ MZ_DEFLATED

◆ MZ_FALSE

◆ MZ_FILE

◆ MZ_FORCEINLINE

◆ MZ_FREE

◆ MZ_MACRO_END

◆ MZ_MALLOC

◆ MZ_MAX

◆ MZ_MIN

◆ MZ_READ_LE16

◆ MZ_READ_LE32

◆ MZ_READ_LE64

◆ MZ_REALLOC

◆ MZ_TIME_T

◆ MZ_TRUE

◆ MZ_UINT16_MAX

◆ MZ_UINT32_MAX

◆ MZ_VER_MAJOR

◆ MZ_VER_MINOR

◆ MZ_VER_REVISION

◆ MZ_VER_SUBREVISION

◆ MZ_VERNUM

◆ MZ_VERSION

◆ MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE

◆ TDEFL_LESS_MEMORY

◆ TINFL_BITBUF_SIZE

◆ TINFL_DECOMPRESS_MEM_TO_MEM_FAILED

◆ tinfl_get_adler32

◆ tinfl_init

◆ TINFL_LZ_DICT_SIZE

◆ TINFL_USE_64BIT_BITBUF

◆ uncompress

◆ Z_BEST_COMPRESSION

◆ Z_BEST_SPEED