fix(miniz_oxide_c_api): Add missing funcs, tweak types/functions to make cbindgen work-ish

Author: oyvindln

benches/bench.rs

@@ -83,8 +83,8 @@ macro_rules! compress_bench {
 }
 
 mod oxide {
-    use miniz_oxide_c_api::{tdefl_compress_mem_to_heap, tinfl_decompress_mem_to_heap};
     use super::*;
+    use miniz_oxide_c_api::{tdefl_compress_mem_to_heap, tinfl_decompress_mem_to_heap};
 
     compress_bench!(
         compress_short_lvl_1,
@@ -221,8 +221,8 @@ mod oxide {
 }
 
 mod miniz {
-    use libc::{c_int, c_void};
     use super::*;
+    use libc::{c_int, c_void};
 
     /// Functions from miniz
     /// We add the link attribute to make sure

cbindgen.toml

@@ -1,4 +1,4 @@
-header = """/* This library (excluding the miniz C code used for tests) is licensed under the MIT license. The library is based on the miniz C library, of which the parts used are dual-licensed under the MIT license and also the unlicense. The parts of miniz that are not covered by the unlicense is some Zip64 code which is only MIT licensed. This and other Zip functionality in miniz is not part of the miniz_oxidde and miniz_oxide_c_api rust libraries."""
+header = """/* This library (excluding the miniz C code used for tests) is licensed under the MIT license. The library is based on the miniz C library, of which the parts used are dual-licensed under the MIT license and also the unlicense. The parts of miniz that are not covered by the unlicense is some Zip64 code which is only MIT licensed. This and other Zip functionality in miniz is not part of the miniz_oxidde and miniz_oxide_c_api rust libraries.*/"""
 autogen_warning = """/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
  * To generate this file:
  *   1. Get the latest cbindgen using `cargo install --force cbindgen`
@@ -7,13 +7,22 @@ autogen_warning = """/* DO NOT MODIFY THIS MANUALLY! This file was generated usi
  */"""
 include_version = true
 language = "C"
+includes = ["miniz_extra_defs.h"]
+# An optional name to use as an include guard
+# default: doesn't emit an include guard
+# include_guard = "MINIZ_OXIDE_INCLUDED"
+
+# Whether to add a `#pragma once` guard
+# default: doesn't emit a `#pragma once`
+pragma_once = true
+cpp_compat = true
 
 [export]
-include = ["CAPIReturnStatus", "CAPIFlush", "CAPICompressionStrategy"]
+include = ["CAPIReturnStatus", "CAPIFlush", "CAPICompressionStrategy", "CAPICompressionLevel", "mz_alloc_func", "mz_free_func", "mz_realloc_func", "tinfl_status", "tdefl_flush"]
 
 [export.rename]
-"DecompressorOxide" = "tinfl_decompressor"
-"Compressor" = "tinfl_compressor"
+# "DecompressorOxide" = "tinfl_decompressor"
+"Compressor" = "tdefl_compressor"
 
 [parse]
 # Whether to parse dependent crates and include their types in the output

clippy.toml

@@ -0,0 +1 @@
+msrv = "1.40.0"

examples/example1.c

@@ -1,7 +1,7 @@
 // example1.c - Demonstrates miniz.c's compress() and uncompress() functions (same as zlib's).
 // Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
 #include <stdio.h>
-#include "miniz.h"
+#include "miniz_test.h"
 typedef unsigned char uint8;
 typedef unsigned short uint16;
 typedef unsigned int uint;

examples/example5.c

@@ -39,7 +39,8 @@ static uint8 s_outbuf[OUT_BUF_SIZE];
 
 // tdefl_compressor contains all the state needed by the low-level compressor so it's a pretty big struct (~300k).
 // This example makes it a global vs. putting it on the stack, of course in real-world usage you'll probably malloc() or new it.
-tdefl_compressor g_deflator;
+// NOTE: miniz_oxide: changed to dynamic alloc for now, TODO: See whether we will support alloc on stack or not.
+// tdefl_compressor g_deflator;
 
 int main(int argc, char *argv[])
 {
@@ -165,7 +166,8 @@ int main(int argc, char *argv[])
          comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
 
       // Initialize the low-level compressor.
-      status = tdefl_init(&g_deflator, NULL, NULL, comp_flags);
+      tdefl_compressor* g_deflator = tdefl_allocate();
+      status = tdefl_init(g_deflator, NULL, NULL, comp_flags);
       if (status != TDEFL_STATUS_OKAY)
       {
          printf("tdefl_init() failed!\n");
@@ -200,7 +202,7 @@ int main(int argc, char *argv[])
          in_bytes = avail_in;
          out_bytes = avail_out;
          // Compress as much of the input as possible (or all of it) to the output buffer.
-         status = tdefl_compress(&g_deflator, next_in, &in_bytes, next_out, &out_bytes, infile_remaining ? TDEFL_NO_FLUSH : TDEFL_FINISH);
+         status = tdefl_compress(g_deflator, next_in, &in_bytes, next_out, &out_bytes, infile_remaining ? TDEFL_NO_FLUSH : TDEFL_FINISH);
 
          next_in = (const char *)next_in + in_bytes;
          avail_in -= in_bytes;
@@ -235,6 +237,7 @@ int main(int argc, char *argv[])
             return EXIT_FAILURE;
          }
       }
+      tdefl_deallocate(g_deflator);
    }
    else if ((pMode[0] == 'd') || (pMode[0] == 'D'))
    {

miniz.h

@@ -0,0 +1,22 @@
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

miniz/ChangeLog.md

@@ -0,0 +1,34 @@
+## Miniz
+
+Miniz is a lossless, high performance data compression library in a single source file that implements the zlib (RFC 1950) and Deflate (RFC 1951) compressed data format specification standards. It supports the most commonly used functions exported by the zlib library, but is a completely independent implementation so zlib's licensing requirements do not apply. Miniz also contains simple to use functions for writing .PNG format image files and reading/writing/appending .ZIP format archives. Miniz's compression speed has been tuned to be comparable to zlib's, and it also has a specialized real-time compressor function designed to compare well against fastlz/minilzo.
+
+## Usage
+
+Please use the files from the [releases page](https://github.com/richgel999/miniz/releases) in your projects. Do not use the git checkout directly! The different source and header files are [amalgamated](https://www.sqlite.org/amalgamation.html) into one `miniz.c`/`miniz.h` pair in a build step (`amalgamate.sh`). Include `miniz.c` and `miniz.h` in your project to use Miniz.
+
+## Features
+
+* MIT licensed
+* A portable, single source and header file library written in plain C. Tested with GCC, clang and Visual Studio.
+* Easily tuned and trimmed down by defines
+* A drop-in replacement for zlib's most used API's (tested in several open source projects that use zlib, such as libpng and libzip).
+* Fills a single threaded performance vs. compression ratio gap between several popular real-time compressors and zlib. For example, at level 1, miniz.c compresses around 5-9% better than minilzo, but is approx. 35% slower. At levels 2-9, miniz.c is designed to compare favorably against zlib's ratio and speed. See the miniz performance comparison page for example timings.
+* Not a block based compressor: miniz.c fully supports stream based processing using a coroutine-style implementation. The zlib-style API functions can be called a single byte at a time if that's all you've got.
+* Easy to use. The low-level compressor (tdefl) and decompressor (tinfl) have simple state structs which can be saved/restored as needed with simple memcpy's. The low-level codec API's don't use the heap in any way.
+* Entire inflater (including optional zlib header parsing and Adler-32 checking) is implemented in a single function as a coroutine, which is separately available in a small (~550 line) source file: miniz_tinfl.c
+* A fairly complete (but totally optional) set of .ZIP archive manipulation and extraction API's. The archive functionality is intended to solve common problems encountered in embedded, mobile, or game development situations. (The archive API's are purposely just powerful enough to write an entire archiver given a bit of additional higher-level logic.)
+
+## Known Problems
+
+* No support for encrypted archives. Not sure how useful this stuff is in practice.
+* Minimal documentation. The assumption is that the user is already familiar with the basic zlib API. I need to write an API wiki - for now I've tried to place key comments before each enum/API, and I've included 6 examples that demonstrate how to use the module's major features.
+
+## Special Thanks
+
+Thanks to Alex Evans for the PNG writer function. Also, thanks to Paul Holden and Thorsten Scheuermann for feedback and testing, Matt Pritchard for all his encouragement, and Sean Barrett's various public domain libraries for inspiration (and encouraging me to write miniz.c in C, which was much more enjoyable and less painful than I thought it would be considering I've been programming in C++ for so long).
+
+Thanks to Bruce Dawson for reporting a problem with the level_and_flags archive API parameter (which is fixed in v1.12) and general feedback, and Janez Zemva for indirectly encouraging me into writing more examples.
+
+## Patents
+
+I was recently asked if miniz avoids patent issues. miniz purposely uses the same core algorithms as the ones used by zlib. The compressor uses vanilla hash chaining as described [here](https://datatracker.ietf.org/doc/html/rfc1951#section-4). Also see the [gzip FAQ](https://web.archive.org/web/20160308045258/http://www.gzip.org/#faq11). In my opinion, if miniz falls prey to a patent attack then zlib/gzip are likely to be at serious risk too.

miniz/LICENSE

@@ -0,0 +1,188 @@
+#pragma once
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------- Types and macros */
+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;
+
+#define MZ_VERSION "0.0"
+
+#define MZ_FALSE (0)
+#define MZ_TRUE (1)
+
+/* Works around MSVC's spammy "warning C4127: conditional expression is constant" message. */
+#ifdef _MSC_VER
+#define MZ_MACRO_END while (0, 0)
+#else
+#define MZ_MACRO_END while (0)
+#endif
+
+#ifdef MINIZ_NO_STDIO
+#define MZ_FILE void *
+#else
+#include <stdio.h>
+#define MZ_FILE FILE
+#endif /* #ifdef MINIZ_NO_STDIO */
+
+#ifdef MINIZ_NO_TIME
+typedef struct mz_dummy_time_t_tag
+{
+    int m_dummy;
+} mz_dummy_time_t;
+#define MZ_TIME_T mz_dummy_time_t
+#else
+#define MZ_TIME_T time_t
+#endif
+
+#define MZ_ASSERT(x) assert(x)
+
+#ifdef MINIZ_NO_MALLOC
+#define MZ_MALLOC(x) NULL
+#define MZ_FREE(x) (void)x, ((void)0)
+#define MZ_REALLOC(p, x) NULL
+#else
+#define MZ_MALLOC(x) malloc(x)
+#define MZ_FREE(x) free(x)
+#define MZ_REALLOC(p, x) realloc(p, x)
+#endif
+
+#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))
+
+#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
+#define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
+#define MZ_READ_LE32(p) *((const mz_uint32 *)(p))
+#else
+#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))
+#endif
+
+#define MZ_READ_LE64(p) (((mz_uint64)MZ_READ_LE32(p)) | (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) << 32U))
+
+#ifdef _MSC_VER
+#define MZ_FORCEINLINE __forceinline
+#elif defined(__GNUC__)
+#define MZ_FORCEINLINE __inline__ __attribute__((__always_inline__))
+#else
+#define MZ_FORCEINLINE inline
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MZ_UINT16_MAX (0xFFFFU)
+#define MZ_UINT32_MAX (0xFFFFFFFFU)
+
+/* For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits! */
+typedef unsigned long mz_ulong;
+
+/* Redefine zlib-compatible names to miniz equivalents, so miniz.c can be used as a drop-in replacement for the subset of zlib that miniz.c supports. */
+/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility if you use zlib in the same project. */
+#ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES
+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;
+#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 uncompress2 mz_uncompress2
+#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()
+#endif /* #ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES */
+
+void mz_free(void *p);
+
+typedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
+/* Not implemented yet.*/
+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);
+
+/* Compresses an image to a compressed PNG file in memory. */
+/* On entry: */
+/*  pImage, w, h, and num_chans describe the image to compress. num_chans may be 1, 2, 3, or 4. */
+/*  The image pitch in bytes per scanline will be w*num_chans. The leftmost pixel on the top scanline is stored first in memory. */
+/*  level may range from [0,10], use MZ_NO_COMPRESSION, MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc. or a decent default is MZ_DEFAULT_LEVEL */
+/*  If flip is true, the image will be flipped on the Y axis (useful for OpenGL apps). */
+/* On return: */
+/*  Function returns a pointer to the compressed data, or NULL on failure. */
+/*  *pLen_out will be set to the size of the PNG image file. */
+/*  The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed. */
+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);
+
+#ifdef __cplusplus
+}
+#endif

miniz/miniz.c

@@ -24,7 +24,7 @@
  *
  **************************************************************************/
 
-#include "../miniz_tdef.h"
+/* #include "../miniz_tdef.h" */
 #include "../miniz.h"
 
 #ifdef __cplusplus
@@ -1481,8 +1481,8 @@ size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void
 #pragma warning(disable : 4204) /* nonstandard extension used : non-constant aggregate initializer (also supported by GNU C and C99, so no big deal) */
 #endif
 
-tdefl_compressor* tdefl_allocate();
-void tdefl_deallocate(tdefl_compressor* c);
+/* tdefl_compressor* tdefl_allocate(); */
+/* void tdefl_deallocate(tdefl_compressor* c); */
 
 /* Simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299, more context at
  http://altdevblogaday.org/2011/04/06/a-smaller-jpg-encoder/.

miniz/miniz.h

@@ -24,7 +24,8 @@
  *
  **************************************************************************/
 
-#include "../miniz_tinfl.h"
+/* #include "../miniz_tinfl.h" */
+#include "../miniz.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -724,18 +725,18 @@ int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size,
     return result;
 }
 
-tinfl_decompressor *tinfl_decompressor_alloc()
-{
-    tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor));
-    if (pDecomp)
-        tinfl_init(pDecomp);
-    return pDecomp;
-}
+/* tinfl_decompressor *tinfl_decompressor_alloc() */
+/* { */
+/*     tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor)); */
+/*     if (pDecomp) */
+/*         tinfl_init(pDecomp); */
+/*     return pDecomp; */
+/* } */
 
-void tinfl_decompressor_free(tinfl_decompressor *pDecomp)
-{
-    MZ_FREE(pDecomp);
-}
+/* void tinfl_decompressor_free(tinfl_decompressor *pDecomp) */
+/* { */
+/*     MZ_FREE(pDecomp); */
+/* } */
 
 #ifdef __cplusplus
 }

miniz/miniz_tdef.c

@@ -24,6 +24,7 @@
  * THE SOFTWARE.
  *
  **************************************************************************/
+#define MINIZ_OXIDE_UNIMPLEMENTED
 #include "../miniz_zip.h"
 
 #ifndef MINIZ_NO_ARCHIVE_APIS

miniz/miniz_tinfl.c

@@ -1,5 +1,5 @@
-
 #pragma once
+#include <time.h>
 #include "miniz.h"
 
 /* ------------------- ZIP archive reading/writing */

miniz/miniz_zip.c

@@ -21,9 +21,6 @@ fn main() {
     cc::Build::new()
         .files(&[
             "miniz/miniz.c",
-            "miniz/miniz_zip.c",
-            "miniz/miniz_tinfl.c",
-            "miniz/miniz_tdef.c",
         ])
         .compile("miniz");
 }

miniz/readme.md

@@ -3,21 +3,32 @@ use std::marker::PhantomData;
 use std::{ptr, slice};
 
 pub use crate::tinfl::{
-    tinfl_decompress, tinfl_decompress_mem_to_heap, tinfl_decompress_mem_to_mem, tinfl_decompressor,
+    tinfl_decompress, tinfl_decompress_mem_to_heap, tinfl_decompress_mem_to_mem,
+    tinfl_decompressor, tinfl_status,
 };
 
-use libc::*;
 pub use crate::tdef::{
     tdefl_allocate, tdefl_compress, tdefl_compress_buffer, tdefl_compress_mem_to_heap,
     tdefl_compress_mem_to_mem, tdefl_compress_mem_to_output,
     tdefl_create_comp_flags_from_zip_params, tdefl_deallocate, tdefl_get_adler32,
-    tdefl_get_prev_return_status, tdefl_init,
+    tdefl_get_prev_return_status, tdefl_init, tdefl_flush,
 };
+use libc::*;
 
 use crate::lib_oxide::{InternalState, StateType, StateTypeEnum, StreamOxide, MZ_ADLER32_INIT};
 
 use miniz_oxide::{mz_adler32_oxide, MZError};
 
+#[allow(bad_style)]
+mod mz_typedefs {
+    use libc::*;
+
+    pub type mz_uint32 = c_uint;
+    pub type mz_uint = c_uint;
+    pub type mz_bool = c_int;
+}
+pub use mz_typedefs::*;
+
 #[allow(bad_style)]
 #[repr(C)]
 #[derive(PartialEq, Eq)]
@@ -58,6 +69,19 @@ pub enum CAPICompressionStrategy {
     MZ_FIXED = 4,
 }
 
+/* Compression levels: 0-9 are the standard zlib-style levels, 10 is best possible compression (not zlib compatible, and may be very slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL. */
+#[allow(bad_style)]
+#[repr(C)]
+#[derive(PartialEq, Eq)]
+pub enum CAPICompressionLevel {
+    MZ_NO_COMPRESSION = 0,
+    MZ_BEST_SPEED = 1,
+    MZ_BEST_COMPRESSION = 9,
+    MZ_UBER_COMPRESSION = 10,
+    MZ_DEFAULT_LEVEL = 6,
+    MZ_DEFAULT_COMPRESSION = -1
+}
+
 pub const MZ_CRC32_INIT: c_ulong = 0;
 
 pub fn mz_crc32_oxide(crc32: c_uint, data: &[u8]) -> c_uint {
@@ -73,6 +97,17 @@ pub type mz_alloc_func = unsafe extern "C" fn(*mut c_void, size_t, size_t) -> *m
 #[allow(bad_style)]
 pub type mz_free_func = unsafe extern "C" fn(*mut c_void, *mut c_void);
 
+#[allow(bad_style)]
+pub type mz_realloc_func =
+    unsafe extern "C" fn(*mut c_void, *mut c_void, size_t, size_t) -> *mut c_void;
+
+#[allow(bad_style)]
+pub type mz_alloc_callback =
+    Option<unsafe extern "C" fn(*mut c_void, size_t, size_t) -> *mut c_void>;
+
+#[allow(bad_style)]
+pub type mz_free_callback = Option<unsafe extern "C" fn(*mut c_void, *mut c_void)>;
+
 /// Inner stream state containing pointers to the used buffers and internal state.
 #[repr(C)]
 #[allow(bad_style)]
@@ -99,10 +134,10 @@ pub struct mz_stream {
 
     /// Allocation function to use for allocating the internal compressor/decompressor.
     /// Uses `mz_default_alloc_func` if set to `None`.
-    pub zalloc: Option<mz_alloc_func>,
+    pub zalloc: mz_alloc_callback,
     /// Free function to use for allocating the internal compressor/decompressor.
     /// Uses `mz_default_free_func` if `None`.
-    pub zfree: Option<mz_free_func>,
+    pub zfree: mz_free_callback,
     /// Extra data to provide the allocation/deallocation functions.
     /// (Not used for the default ones)
     pub opaque: *mut c_void,

miniz_common.h

@@ -82,7 +82,7 @@ pub use crate::c_export::*;
 pub use crate::tdef::Compressor as tdefl_compressor;
 
 pub const MZ_DEFLATED: c_int = 8;
-pub const MZ_DEFAULT_WINDOW_BITS: c_int = 15;
+pub use miniz_oxide::MZ_DEFAULT_WINDOW_BITS;
 
 fn as_c_return_code(r: MZResult) -> c_int {
     match r {
@@ -156,7 +156,7 @@ unmangle!(
         match stream.as_mut() {
             None => MZError::Stream as c_int,
             Some(stream) => {
-                stream.data_type = StateTypeEnum::Deflate;
+                stream.data_type = StateTypeEnum::DeflateType;
                 // Make sure we catch a potential panic, as
                 // this is called from C.
                 match catch_unwind(AssertUnwindSafe(|| match StreamOxide::try_new(stream) {
@@ -188,7 +188,7 @@ unmangle!(
         match stream.as_mut() {
             None => MZError::Stream as c_int,
             Some(stream) => {
-                stream.data_type = StateTypeEnum::Inflate;
+                stream.data_type = StateTypeEnum::InflateType;
                 // Make sure we catch a potential panic, as
                 // this is called from C.
                 match catch_unwind(AssertUnwindSafe(|| match StreamOxide::try_new(stream) {
@@ -243,7 +243,7 @@ unmangle!(
                     avail_in: source_len as c_uint,
                     next_out: dest,
                     avail_out: (*dest_len) as c_uint,
-                    data_type: StateTypeEnum::Deflate,
+                    data_type: StateTypeEnum::DeflateType,
                     ..Default::default()
                 };
 
@@ -281,7 +281,7 @@ unmangle!(
                     avail_in: source_len as c_uint,
                     next_out: dest,
                     avail_out: (*dest_len) as c_uint,
-                    data_type: StateTypeEnum::Inflate,
+                    data_type: StateTypeEnum::InflateType,
                     ..Default::default()
                 };
 

miniz_extra_defs.h

@@ -5,20 +5,19 @@ use std::{fmt, mem};
 
 use libc::c_ulong;
 
+use crate::tdef::Compressor;
 use miniz_oxide::deflate::core::{
     create_comp_flags_from_zip_params, deflate_flags, CompressionStrategy, CompressorOxide,
 };
 use miniz_oxide::deflate::stream::deflate;
 use miniz_oxide::inflate::stream::{inflate, InflateState};
-use crate::tdef::Compressor;
 
 use miniz_oxide::*;
 
 const MZ_DEFLATED: i32 = 8;
 
-pub const MZ_ADLER32_INIT: u32 = 1;
+pub use miniz_oxide::MZ_ADLER32_INIT;
 
-#[repr(C)]
 pub enum InternalState {
     Inflate(Box<InflateState>),
     Deflate(Box<Compressor>),
@@ -41,8 +40,8 @@ pub type MZResult = Result<MZStatus, MZError>;
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum StateTypeEnum {
     None = 0,
-    Inflate,
-    Deflate,
+    InflateType,
+    DeflateType,
 }
 
 /// Trait used for states that can be carried by BoxedState.
@@ -52,7 +51,7 @@ pub trait StateType {
 }
 
 impl StateType for InflateState {
-    const STATE_TYPE: StateTypeEnum = StateTypeEnum::Inflate;
+    const STATE_TYPE: StateTypeEnum = StateTypeEnum::InflateType;
     fn from_enum(value: &mut InternalState) -> Option<&mut Self> {
         if let InternalState::Inflate(state) = value {
             Some(state.as_mut())
@@ -63,7 +62,7 @@ impl StateType for InflateState {
 }
 
 impl StateType for Compressor {
-    const STATE_TYPE: StateTypeEnum = StateTypeEnum::Deflate;
+    const STATE_TYPE: StateTypeEnum = StateTypeEnum::DeflateType;
     fn from_enum(value: &mut InternalState) -> Option<&mut Self> {
         if let InternalState::Deflate(state) = value {
             Some(state.as_mut())

miniz_stub/miniz_tdef.c

@@ -8,17 +8,20 @@ use miniz_oxide::deflate::core::{
 };
 
 /// Compression callback function type.
-pub type PutBufFuncPtrNotNull = unsafe extern "C" fn(*const c_void, c_int, *mut c_void) -> bool;
+pub type PutBufFuncPtrNotNull = unsafe extern "C" fn(*const c_void, c_int, *mut c_void) -> i32;
+#[allow(bad_style)]
+pub type tdefl_put_buf_func_ptr = Option<unsafe extern "C" fn(*const c_void, c_int, *mut c_void) -> i32>;
 /// `Option` alias for compression callback function type.
-pub type PutBufFuncPtr = Option<PutBufFuncPtrNotNull>;
+/// cbindgen.rename = "SnakeCase""
+// typedef mz_bool (*tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
 
 pub struct CallbackFunc {
     pub put_buf_func: PutBufFuncPtrNotNull,
     pub put_buf_user: *mut c_void,
 }
 
 /// Main compression struct. Not the same as `CompressorOxide`
-#[repr(C)]
+/// #[repr(C)]
 pub struct Compressor {
     pub(crate) inner: Option<CompressorOxide>,
     pub(crate) callback: Option<CallbackFunc>,
@@ -55,18 +58,48 @@ impl From<TDEFLStatus> for tdefl_status {
     }
 }
 
+#[allow(bad_style)]
+#[repr(C)]
+#[derive(PartialEq, Eq)]
+pub enum tdefl_flush {
+    TDEFL_NO_FLUSH = 0,
+    TDEFL_SYNC_FLUSH = 2,
+    TDEFL_FULL_FLUSH = 3,
+    TDEFL_FINISH = 4,
+}
+
+impl From<tdefl_flush> for TDEFLFlush {
+    fn from(flush: tdefl_flush) -> TDEFLFlush {
+        use tdefl_flush::*;
+        match flush {
+            TDEFL_NO_FLUSH => TDEFLFlush::None,
+            TDEFL_SYNC_FLUSH => TDEFLFlush::Sync,
+            TDEFL_FULL_FLUSH => TDEFLFlush::Full,
+            TDEFL_FINISH => TDEFLFlush::Finish,
+        }
+    }
+}
+
+// pub type tdefl_flush = c_int;
+// pub mod tdefl_flush_e {
+//     pub const TDEFL_NO_FLUSH: tdefl_flush = 0;
+//     pub const TDEFL_SYNC_FLUSH: tdefl_flush = 2;
+//     pub const TDEFL_FULL_FLUSH: tdefl_flush = 3;
+//     pub const TDEFL_FINISH: tdefl_flush = 4;
+// }
+
 /// Convert an i32 to a TDEFLFlush
 ///
 /// Returns TDEFLFLush::None flush value is unknown.
 /// For use with c interface.
-pub fn i32_to_tdefl_flush(flush: i32) -> TDEFLFlush {
-    match flush {
-        2 => TDEFLFlush::Sync,
-        3 => TDEFLFlush::Full,
-        4 => TDEFLFlush::Finish,
-        _ => TDEFLFlush::None,
-    }
-}
+// pub fn i32_to_tdefl_flush(flush: i32) -> TDEFLFlush {
+//     match flush {
+//         2 => TDEFLFlush::Sync,
+//         3 => TDEFLFlush::Full,
+//         4 => TDEFLFlush::Finish,
+//         _ => TDEFLFlush::None,
+//     }
+// }
 
 impl Compressor {
     pub(crate) fn new_with_callback(flags: u32, func: CallbackFunc) -> Self {
@@ -114,9 +147,11 @@ unmangle!(
         in_size: Option<&mut usize>,
         out_buf: *mut c_void,
         out_size: Option<&mut usize>,
-        flush: i32,
+        // TODO: See if we should use an enum here or not as it could
+        // cause UB.
+        flush: tdefl_flush,
     ) -> tdefl_status {
-        let flush = i32_to_tdefl_flush(flush);
+        let flush = flush.into();
         match d {
             None => {
                 if let Some(size) = in_size {
@@ -180,7 +215,7 @@ unmangle!(
                                         &(out[0]) as *const u8 as *const c_void,
                                         out.len() as i32,
                                         func.put_buf_user,
-                                    )
+                                    ) != 0
                                 });
                             (res.0, res.1, 0)
                         }
@@ -204,7 +239,7 @@ unmangle!(
         d: Option<&mut Compressor>,
         in_buf: *const c_void,
         mut in_size: usize,
-        flush: i32,
+        flush: tdefl_flush,
     ) -> tdefl_status {
         tdefl_compress(d, in_buf, Some(&mut in_size), ptr::null_mut(), None, flush)
     }
@@ -238,7 +273,7 @@ unmangle!(
     /// tdefl_allocate and tdefl_deallocate
     pub unsafe extern "C" fn tdefl_init(
         d: Option<&mut Compressor>,
-        put_buf_func: PutBufFuncPtr,
+        put_buf_func: tdefl_put_buf_func_ptr,
         put_buf_user: *mut c_void,
         flags: c_int,
     ) -> tdefl_status {
@@ -280,10 +315,10 @@ unmangle!(
     pub unsafe extern "C" fn tdefl_compress_mem_to_output(
         buf: *const c_void,
         buf_len: usize,
-        put_buf_func: PutBufFuncPtr,
+        put_buf_func: tdefl_put_buf_func_ptr,
         put_buf_user: *mut c_void,
         flags: c_int,
-    ) -> bool {
+    ) -> c_int {
         if let Some(put_buf_func) = put_buf_func {
             let compressor =
                 crate::miniz_def_alloc_func(ptr::null_mut(), 1, mem::size_of::<Compressor>())
@@ -301,15 +336,15 @@ unmangle!(
             );
 
             let res =
-                tdefl_compress_buffer(compressor.as_mut(), buf, buf_len, TDEFLFlush::Finish as i32)
+                tdefl_compress_buffer(compressor.as_mut(), buf, buf_len, tdefl_flush::TDEFL_FINISH)
                     == tdefl_status::TDEFL_STATUS_DONE;
             if let Some(c) = compressor.as_mut() {
                 c.drop_inner();
             }
             crate::miniz_def_free_func(ptr::null_mut(), compressor as *mut c_void);
-            res
+            res.into()
         } else {
-            false
+            false.into()
         }
     }
 );
@@ -325,15 +360,15 @@ pub unsafe extern "C" fn output_buffer_putter(
     buf: *const c_void,
     len: c_int,
     user: *mut c_void,
-) -> bool {
+) -> i32 {
     let user = (user as *mut BufferUser).as_mut();
     match user {
-        None => false,
+        None => false.into(),
         Some(user) => {
             let new_size = user.size + len as usize;
             if new_size > user.capacity {
                 if !user.expandable {
-                    return false;
+                    return false.into();
                 }
                 let mut new_capacity = cmp::max(user.capacity, 128);
                 while new_size > new_capacity {
@@ -348,20 +383,16 @@ pub unsafe extern "C" fn output_buffer_putter(
                 );
 
                 if new_buf.is_null() {
-                    return false;
+                    return false.into();
                 }
 
                 user.buf = new_buf as *mut u8;
                 user.capacity = new_capacity;
             }
 
-            ptr::copy_nonoverlapping(
-                buf as *const u8,
-                user.buf.add(user.size),
-                len as usize,
-            );
+            ptr::copy_nonoverlapping(buf as *const u8, user.buf.add(user.size), len as usize);
             user.size = new_size;
-            true
+            true.into()
         }
     }
 }
@@ -385,13 +416,13 @@ unmangle!(
                     expandable: true,
                 };
 
-                if !tdefl_compress_mem_to_output(
+                if tdefl_compress_mem_to_output(
                     src_buf,
                     src_buf_len,
                     Some(output_buffer_putter),
                     &mut buffer_user as *mut BufferUser as *mut c_void,
                     flags,
-                ) {
+                ) == 0 {
                     ptr::null_mut()
                 } else {
                     *len = buffer_user.size;
@@ -424,7 +455,7 @@ unmangle!(
             Some(output_buffer_putter),
             &mut buffer_user as *mut BufferUser as *mut c_void,
             flags,
-        ) {
+        ) != 0 {
             buffer_user.size
         } else {
             0

miniz_stub/miniz_tinfl.c

@@ -2,16 +2,80 @@
 
 use libc::*;
 use miniz_oxide::inflate::core::DecompressorOxide;
-pub use miniz_oxide::inflate::core::DecompressorOxide as tinfl_decompressor;
+// pub use miniz_oxide::inflate::core::DecompressorOxide as tinfl_decompressor;
 pub use miniz_oxide::inflate::core::{decompress, inflate_flags};
 use miniz_oxide::inflate::TINFLStatus;
 use std::{ptr, slice, usize};
 
 pub const TINFL_DECOMPRESS_MEM_TO_MEM_FAILED: size_t = usize::MAX;
 
+#[allow(bad_style)]
+#[repr(C)]
+pub enum tinfl_status {
+    /* 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,
+}
+
+impl From<TINFLStatus> for tinfl_status {
+    fn from(status: TINFLStatus) -> tinfl_status {
+        use self::tinfl_status::*;
+        match status {
+            TINFLStatus::FailedCannotMakeProgress => TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS,
+            TINFLStatus::BadParam => TINFL_STATUS_BAD_PARAM,
+            TINFLStatus::Adler32Mismatch => TINFL_STATUS_ADLER32_MISMATCH,
+            TINFLStatus::Failed => TINFL_STATUS_FAILED,
+            TINFLStatus::Done => TINFL_STATUS_DONE,
+            TINFLStatus::NeedsMoreInput => TINFL_STATUS_NEEDS_MORE_INPUT,
+            TINFLStatus::HasMoreOutput => TINFL_STATUS_HAS_MORE_OUTPUT
+        }
+    }
+}
+
+#[allow(bad_style)]
+#[repr(C)]
+pub struct tinfl_decompressor {
+    inner: Option<Box<DecompressorOxide>>,
+}
+
+impl Default for tinfl_decompressor {
+    fn default() -> tinfl_decompressor {
+        tinfl_decompressor {
+            inner: Some(Box::<DecompressorOxide>::default()),
+        }
+    }
+}
+
 unmangle!(
     pub unsafe extern "C" fn tinfl_decompress(
-        r: *mut DecompressorOxide,
+        r: *mut tinfl_decompressor,
         in_buf: *const u8,
         in_buf_size: *mut usize,
         out_buf_start: *mut u8,
@@ -21,17 +85,22 @@ unmangle!(
     ) -> i32 {
         let next_pos = out_buf_next as usize - out_buf_start as usize;
         let out_size = *out_buf_size + next_pos;
-        let (status, in_consumed, out_consumed) = decompress(
-            r.as_mut().expect("bad decompressor pointer"),
-            slice::from_raw_parts(in_buf, *in_buf_size),
-            slice::from_raw_parts_mut(out_buf_start, out_size),
-            next_pos,
-            flags,
-        );
+        let r_ref = r.as_mut().expect("bad decompressor pointer");
+        if let Some(decompressor) = r_ref.inner.as_mut() {
+            let (status, in_consumed, out_consumed) = decompress(
+                decompressor.as_mut(),
+                slice::from_raw_parts(in_buf, *in_buf_size),
+                slice::from_raw_parts_mut(out_buf_start, out_size),
+                next_pos,
+                flags,
+            );
 
-        *in_buf_size = in_consumed;
-        *out_buf_size = out_consumed;
-        status as i32
+            *in_buf_size = in_consumed;
+            *out_buf_size = out_consumed;
+            status as i32
+        } else {
+            TINFLStatus::BadParam as i32
+        }
     }
 
     pub unsafe extern "C" fn tinfl_decompress_mem_to_mem(
@@ -139,6 +208,42 @@ unmangle!(
 
         p_buf
     }
+
+    /// Allocate a compressor.
+    ///
+    /// This does initialize the struct, but not the inner constructor,
+    /// tdefl_init has to be called before doing anything with it.
+    pub unsafe extern "C" fn tinfl_decompressor_alloc() -> *mut tinfl_decompressor {
+        Box::into_raw(Box::<tinfl_decompressor>::new(tinfl_decompressor::default()))
+    }
+    /// Deallocate the compressor. (Does nothing if the argument is null).
+    ///
+    /// This also calles the compressor's destructor, freeing the internal memory
+    /// allocated by it.
+    pub unsafe extern "C" fn tinfl_decompressor_free(c: *mut tinfl_decompressor) {
+        if !c.is_null() {
+            Box::from_raw(c);
+        }
+    }
+
+    pub unsafe extern "C" fn tinfl_init(c: *mut tinfl_decompressor) {
+        let wrapped = c.as_mut().unwrap();
+        if let Some(decomp) = wrapped.inner.as_mut() {
+            decomp.init();
+        } else {
+            wrapped.inner.replace(Box::default());
+        }
+    }
+
+    pub unsafe extern "C" fn tinfl_get_adler32(c: *mut tinfl_decompressor) -> c_int {
+        let wrapped = c.as_mut().unwrap();
+        if let Some(decomp) = wrapped.inner.as_mut() {
+            // TODO: Need to test if conversion is ok.
+            decomp.adler32().unwrap_or(0) as c_int
+        } else {
+            0
+        }
+    }
 );
 
 #[cfg(test)]