diff options
Diffstat (limited to 'source/kit/miniz/miniz_tinfl.h')
| -rw-r--r-- | source/kit/miniz/miniz_tinfl.h | 218 |
1 files changed, 218 insertions, 0 deletions
diff --git a/source/kit/miniz/miniz_tinfl.h b/source/kit/miniz/miniz_tinfl.h new file mode 100644 index 0000000..14da110 --- /dev/null +++ b/source/kit/miniz/miniz_tinfl.h @@ -0,0 +1,218 @@ +#ifndef KIT_MINIZ_MINIZ_TINFL_H +#define KIT_MINIZ_MINIZ_TINFL_H + +#include "miniz_common.h" +/* ------------------- Low-level Decompression API Definitions */ + +#ifndef MINIZ_NO_INFLATE_APIS + +# ifdef __cplusplus +extern "C" { +# endif +/* Decompression flags used by tinfl_decompress(). */ +/* TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib + * header and ends with an adler32 checksum (it's a valid zlib + * stream). Otherwise, the input is a raw deflate stream. */ +/* TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes + * available beyond the end of the supplied input buffer. If clear, + * the input buffer contains all remaining input. */ +/* TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer + * is large enough to hold the entire decompressed stream. If clear, + * the output buffer is at least the size of the dictionary (typically + * 32KB). */ +/* TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of + * the decompressed bytes. */ +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 +}; + +/* High level decompression functions: */ +/* tinfl_decompress_mem_to_heap() decompresses a block in memory to a + * heap block allocated via malloc(). */ +/* On entry: */ +/* pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib + * source data to decompress. */ +/* On return: */ +/* Function returns a pointer to the decompressed data, or NULL on + * failure. */ +/* *pOut_len will be set to the decompressed data's size, which could + * be larger than src_buf_len on uncompressible data. */ +/* The caller must call mz_free() on the returned block when it's no + * longer needed. */ +void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, + size_t src_buf_len, + size_t *pOut_len, int flags); + +/* tinfl_decompress_mem_to_mem() decompresses a block in memory to + * another block in memory. */ +/* Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the + * number of bytes written on success. */ +# define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t) (-1)) +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_decompress_mem_to_callback() decompresses a block in memory + * to an internal 32KB buffer, and a user provided callback function + * will be called to flush the buffer. */ +/* Returns 1 on success or 0 on failure. */ +typedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, + void *pUser); +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); + +struct tinfl_decompressor_tag; +typedef struct tinfl_decompressor_tag tinfl_decompressor; + +# ifndef MINIZ_NO_MALLOC +/* Allocate the tinfl_decompressor structure in C so that */ +/* non-C language bindings to tinfl_ API don't need to worry about */ +/* structure size and allocation mechanism. */ +tinfl_decompressor *tinfl_decompressor_alloc(void); +void tinfl_decompressor_free(tinfl_decompressor *pDecomp); +# endif + +/* Max size of LZ dictionary. */ +# define TINFL_LZ_DICT_SIZE 32768 + +/* Return status. */ +typedef enum { + /* 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; + +/* Initializes the decompressor to its initial state. */ +# define tinfl_init(r) \ + do { (r)->m_state = 0; } \ + MZ_MACRO_END +# define tinfl_get_adler32(r) (r)->m_check_adler32 + +/* Main low-level decompressor coroutine function. This is the only + * function actually needed for decompression. All the other functions + * are just high-level helpers for improved usability. */ +/* This is a universal API, i.e. it can be used as a building block to + * build any desired higher level decompression API. In the limit + * case, it can be called once per every byte input or output. */ +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); + +/* Internal/private bits follow. */ +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 +}; + +# if MINIZ_HAS_64BIT_REGISTERS +# define TINFL_USE_64BIT_BITBUF 1 +# else +# define TINFL_USE_64BIT_BITBUF 0 +# endif + +# if TINFL_USE_64BIT_BITBUF +typedef mz_uint64 tinfl_bit_buf_t; +# define TINFL_BITBUF_SIZE (64) +# else +typedef mz_uint32 tinfl_bit_buf_t; +# define TINFL_BITBUF_SIZE (32) +# endif + +struct tinfl_decompressor_tag { + mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, + m_final, m_type, m_check_adler32, m_dist, m_counter, + m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES]; + tinfl_bit_buf_t m_bit_buf; + size_t m_dist_from_out_buf_start; + mz_int16 m_look_up[TINFL_MAX_HUFF_TABLES][TINFL_FAST_LOOKUP_SIZE]; + mz_int16 m_tree_0[TINFL_MAX_HUFF_SYMBOLS_0 * 2]; + mz_int16 m_tree_1[TINFL_MAX_HUFF_SYMBOLS_1 * 2]; + mz_int16 m_tree_2[TINFL_MAX_HUFF_SYMBOLS_2 * 2]; + mz_uint8 m_code_size_0[TINFL_MAX_HUFF_SYMBOLS_0]; + mz_uint8 m_code_size_1[TINFL_MAX_HUFF_SYMBOLS_1]; + mz_uint8 m_code_size_2[TINFL_MAX_HUFF_SYMBOLS_2]; + mz_uint8 m_raw_header[4], + m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + + TINFL_MAX_HUFF_SYMBOLS_1 + 137]; +}; + +# ifdef __cplusplus +} +# endif + +#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/ + +#endif |