test/c/mimiclib/deflate-gzip-zlib.c - external/github.com/google/wuffs - Git at Google

 // Copyright 2017 The Wuffs Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // ----------------

 // Uncomment one of these #define lines to test and bench alternative mimic
 // libraries (libdeflate or miniz) instead of zlib-the-library.
 //
 // These are collectively referred to as
 // WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB.
 //
 // #define WUFFS_MIMICLIB_USE_LIBDEFLATE_INSTEAD_OF_ZLIB 1
 // #define WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB 1

 // -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
 #if defined(WUFFS_MIMICLIB_USE_LIBDEFLATE_INSTEAD_OF_ZLIB)
 #include "libdeflate.h"

 #define WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING 1

 #define WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES 1

 uint32_t global_mimiclib_deflate_unused_u32;

 typedef enum libdeflate_result (*libdeflate_decompress_func)(
     struct libdeflate_decompressor* decompressor,
     const void* in,
     size_t in_nbytes,
     void* out,
     size_t out_nbytes_avail,
     size_t* actual_in_nbytes_ret,
     size_t* actual_out_nbytes_ret);

 const char*  //
 libdeflate_result_as_const_char_star(enum libdeflate_result r) {
   switch (r) {
     case LIBDEFLATE_SUCCESS:
       return NULL;
     case LIBDEFLATE_BAD_DATA:
       return "libdeflate: bad data";
     case LIBDEFLATE_SHORT_OUTPUT:
       return "libdeflate: short output";
     case LIBDEFLATE_INSUFFICIENT_SPACE:
       return "libdeflate: insufficient space";
   }
   return "libdeflate: unknown error";
 }

 const char*  //
 mimic_bench_adler32(wuffs_base__io_buffer* dst,
                     wuffs_base__io_buffer* src,
                     uint32_t wuffs_initialize_flags,
                     uint64_t wlimit,
                     uint64_t rlimit) {
   global_mimiclib_deflate_unused_u32 = 1;
   while (src->meta.ri < src->meta.wi) {
     uint8_t* ptr = src->data.ptr + src->meta.ri;
     size_t len = src->meta.wi - src->meta.ri;
     if (len > 0x7FFFFFFF) {
       return "src length is too large";
     } else if (len > rlimit) {
       len = rlimit;
     }
     global_mimiclib_deflate_unused_u32 =
         libdeflate_adler32(global_mimiclib_deflate_unused_u32, ptr, len);
     src->meta.ri += len;
   }
   return NULL;
 }

 const char*  //
 mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
                        wuffs_base__io_buffer* src,
                        uint32_t wuffs_initialize_flags,
                        uint64_t wlimit,
                        uint64_t rlimit) {
   global_mimiclib_deflate_unused_u32 = 0;
   while (src->meta.ri < src->meta.wi) {
     uint8_t* ptr = src->data.ptr + src->meta.ri;
     size_t len = src->meta.wi - src->meta.ri;
     if (len > 0x7FFFFFFF) {
       return "src length is too large";
     } else if (len > rlimit) {
       len = rlimit;
     }
     global_mimiclib_deflate_unused_u32 =
         libdeflate_crc32(global_mimiclib_deflate_unused_u32, ptr, len);
     src->meta.ri += len;
   }
   return NULL;
 }

 const char*  //
 mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
                                wuffs_base__io_buffer* src,
                                uint32_t wuffs_initialize_flags,
                                uint64_t wlimit,
                                uint64_t rlimit,
                                libdeflate_decompress_func func) {
   struct libdeflate_decompressor* dec = libdeflate_alloc_decompressor();
   if (!dec) {
     return "libdeflate: alloc failed";
   }
   size_t n_dst = 0;
   size_t n_src = 0;
   enum libdeflate_result res =
       (*func)(dec, wuffs_base__io_buffer__reader_pointer(src),
               ((size_t)wuffs_base__u64__min(
                   rlimit, wuffs_base__io_buffer__reader_length(src))),
               wuffs_base__io_buffer__writer_pointer(dst),
               ((size_t)wuffs_base__u64__min(
                   wlimit, wuffs_base__io_buffer__writer_length(dst))),
               &n_src, &n_dst);
   if (res == LIBDEFLATE_SUCCESS) {
     dst->meta.wi += n_dst;
     src->meta.ri += n_src;
   }
   libdeflate_free_decompressor(dec);
   return libdeflate_result_as_const_char_star(res);
 }

 const char*  //
 mimic_deflate_decode(wuffs_base__io_buffer* dst,
                      wuffs_base__io_buffer* src,
                      uint32_t wuffs_initialize_flags,
                      uint64_t wlimit,
                      uint64_t rlimit) {
   return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
                                         wlimit, rlimit,
                                         &libdeflate_deflate_decompress_ex);
 }

 const char*  //
 mimic_gzip_decode(wuffs_base__io_buffer* dst,
                   wuffs_base__io_buffer* src,
                   uint32_t wuffs_initialize_flags,
                   uint64_t wlimit,
                   uint64_t rlimit) {
   return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
                                         wlimit, rlimit,
                                         &libdeflate_gzip_decompress_ex);
 }

 const char*  //
 mimic_zlib_decode(wuffs_base__io_buffer* dst,
                   wuffs_base__io_buffer* src,
                   uint32_t wuffs_initialize_flags,
                   uint64_t wlimit,
                   uint64_t rlimit) {
   return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
                                         wlimit, rlimit,
                                         &libdeflate_zlib_decompress_ex);
 }

 const char*  //
 mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
                                   wuffs_base__io_buffer* src,
                                   wuffs_base__slice_u8 dictionary) {
   return "libdeflate does not implement zlib dictionaries";
 }

 // -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
 #elif defined(WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB)
 #include "/path/to/your/copy/of/github.com/richgel999/miniz/miniz_tinfl.c"

 // We deliberately do not define the
 // WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING macro.

 #define WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES 1

 const char*  //
 mimic_bench_adler32(wuffs_base__io_buffer* dst,
                     wuffs_base__io_buffer* src,
                     uint32_t wuffs_initialize_flags,
                     uint64_t wlimit,
                     uint64_t rlimit) {
   return "miniz does not independently compute Adler32";
 }

 const char*  //
 mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
                        wuffs_base__io_buffer* src,
                        uint32_t wuffs_initialize_flags,
                        uint64_t wlimit,
                        uint64_t rlimit) {
   return "miniz does not implement CRC32/IEEE";
 }

 const char*  //
 mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst,
                           wuffs_base__io_buffer* src,
                           uint32_t wuffs_initialize_flags,
                           uint64_t wlimit,
                           uint64_t rlimit,
                           bool deflate_instead_of_zlib) {
   if ((wlimit < UINT64_MAX) || (rlimit < UINT64_MAX)) {
     // Supporting this would probably mean using tinfl_decompress instead of
     // the simpler tinfl_decompress_mem_to_mem function.
     return "unsupported I/O limit";
   }
   int flags = 0;
   if (!deflate_instead_of_zlib) {
     flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
   }
   size_t n = tinfl_decompress_mem_to_mem(
       dst->data.ptr + dst->meta.wi, dst->data.len - dst->meta.wi,
       src->data.ptr + src->meta.ri, src->meta.wi - src->meta.ri, flags);
   if (n == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED) {
     return "TINFL_DECOMPRESS_MEM_TO_MEM_FAILED";
   }
   dst->meta.wi += n;
   src->meta.ri = src->meta.wi;
   return NULL;
 }

 const char*  //
 mimic_deflate_decode(wuffs_base__io_buffer* dst,
                      wuffs_base__io_buffer* src,
                      uint32_t wuffs_initialize_flags,
                      uint64_t wlimit,
                      uint64_t rlimit) {
   return mimic_deflate_zlib_decode(dst, src, wuffs_initialize_flags, wlimit,
                                    rlimit, true);
 }

 const char*  //
 mimic_gzip_decode(wuffs_base__io_buffer* dst,
                   wuffs_base__io_buffer* src,
                   uint32_t wuffs_initialize_flags,
                   uint64_t wlimit,
                   uint64_t rlimit) {
   return "miniz does not implement gzip";
 }

 const char*  //
 mimic_zlib_decode(wuffs_base__io_buffer* dst,
                   wuffs_base__io_buffer* src,
                   uint32_t wuffs_initialize_flags,
                   uint64_t wlimit,
                   uint64_t rlimit) {
   return mimic_deflate_zlib_decode(dst, src, wuffs_initialize_flags, wlimit,
                                    rlimit, false);
 }

 const char*  //
 mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
                                   wuffs_base__io_buffer* src,
                                   wuffs_base__slice_u8 dictionary) {
   return "miniz does not implement zlib dictionaries";
 }

 // -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
 #else
 #include "zlib.h"

 // We deliberately do not define the
 // WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING macro.

 // We deliberately do not define the
 // WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES macro.

 uint32_t global_mimiclib_deflate_unused_u32;

 const char*  //
 mimic_bench_adler32(wuffs_base__io_buffer* dst,
                     wuffs_base__io_buffer* src,
                     uint32_t wuffs_initialize_flags,
                     uint64_t wlimit,
                     uint64_t rlimit) {
   global_mimiclib_deflate_unused_u32 = 0;
   while (src->meta.ri < src->meta.wi) {
     uint8_t* ptr = src->data.ptr + src->meta.ri;
     size_t len = src->meta.wi - src->meta.ri;
     if (len > 0x7FFFFFFF) {
       return "src length is too large";
     } else if (len > rlimit) {
       len = rlimit;
     }
     global_mimiclib_deflate_unused_u32 =
         adler32(global_mimiclib_deflate_unused_u32, ptr, len);
     src->meta.ri += len;
   }
   return NULL;
 }

 const char*  //
 mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
                        wuffs_base__io_buffer* src,
                        uint32_t wuffs_initialize_flags,
                        uint64_t wlimit,
                        uint64_t rlimit) {
   global_mimiclib_deflate_unused_u32 = 0;
   while (src->meta.ri < src->meta.wi) {
     uint8_t* ptr = src->data.ptr + src->meta.ri;
     size_t len = src->meta.wi - src->meta.ri;
     if (len > 0x7FFFFFFF) {
       return "src length is too large";
     } else if (len > rlimit) {
       len = rlimit;
     }
     global_mimiclib_deflate_unused_u32 =
         crc32(global_mimiclib_deflate_unused_u32, ptr, len);
     src->meta.ri += len;
   }
   return NULL;
 }

 typedef enum {
   zlib_flavor_raw,
   zlib_flavor_gzip,
   zlib_flavor_zlib,
 } zlib_flavor;

 const char*  //
 mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
                                wuffs_base__io_buffer* src,
                                wuffs_base__slice_u8* dictionary,
                                uint64_t wlimit,
                                uint64_t rlimit,
                                zlib_flavor flavor) {
   const char* ret = NULL;
   if (dst->data.len > UINT_MAX) {
     ret = "dst length is too large";
     goto cleanup0;
   }
   if (src->data.len > UINT_MAX) {
     ret = "src length is too large";
     goto cleanup0;
   }

   // See inflateInit2 in the zlib manual, or in zlib.h, for details about how
   // the window_bits int also encodes the wire format wrapper.
   int window_bits = 0;
   switch (flavor) {
     case zlib_flavor_raw:
       window_bits = -15;
       break;
     case zlib_flavor_gzip:
       window_bits = +15 | 16;
       break;
     case zlib_flavor_zlib:
       window_bits = +15;
       break;
     default:
       ret = "invalid zlib_flavor";
       goto cleanup0;
   }
   z_stream z = {0};
   int ii2_err = inflateInit2(&z, window_bits);
   if (ii2_err != Z_OK) {
     ret = "inflateInit2 failed";
     goto cleanup0;
   }

   while (true) {
     z.next_in = src->data.ptr + src->meta.ri;
     z.avail_in = src->meta.wi - src->meta.ri;
     if (z.avail_in > rlimit) {
       z.avail_in = rlimit;
     }
     uInt initial_avail_in = z.avail_in;

     z.next_out = dst->data.ptr + dst->meta.wi;
     z.avail_out = dst->data.len - dst->meta.wi;
     if (z.avail_out > wlimit) {
       z.avail_out = wlimit;
     }
     uInt initial_avail_out = z.avail_out;

     // TODO: s/Z_NO_FLUSH/Z_SYNC_FLUSH/ more closely matches Wuffs' behavior.
     int i_err = inflate(&z, Z_NO_FLUSH);

     if (initial_avail_in < z.avail_in) {
       ret = "inconsistent avail_in";
       goto cleanup1;
     }
     src->meta.ri += initial_avail_in - z.avail_in;

     if (initial_avail_out < z.avail_out) {
       ret = "inconsistent avail_out";
       goto cleanup1;
     }
     dst->meta.wi += initial_avail_out - z.avail_out;

     if (i_err == Z_STREAM_END) {
       break;
     } else if (i_err == Z_NEED_DICT) {
       if (dictionary) {
         int isd_err =
             inflateSetDictionary(&z, dictionary->ptr, dictionary->len);
         if (isd_err != Z_OK) {
           ret = "inflateSetDictionary failed";
           goto cleanup1;
         }
         dictionary = NULL;
         continue;
       }
       ret = "inflate failed (need dict)";
       goto cleanup1;
     } else if (i_err == Z_DATA_ERROR) {
       ret = "inflate failed (data error)";
       goto cleanup1;
     } else if (i_err != Z_OK) {
       ret = "inflate failed";
       goto cleanup1;
     }
   }

 cleanup1:;
   int ie_err = inflateEnd(&z);
   if ((ie_err != Z_OK) && !ret) {
     ret = "inflateEnd failed";
   }

 cleanup0:;
   return ret;
 }

 const char*  //
 mimic_deflate_decode(wuffs_base__io_buffer* dst,
                      wuffs_base__io_buffer* src,
                      uint32_t wuffs_initialize_flags,
                      uint64_t wlimit,
                      uint64_t rlimit) {
   return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
                                         zlib_flavor_raw);
 }

 const char*  //
 mimic_gzip_decode(wuffs_base__io_buffer* dst,
                   wuffs_base__io_buffer* src,
                   uint32_t wuffs_initialize_flags,
                   uint64_t wlimit,
                   uint64_t rlimit) {
   return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
                                         zlib_flavor_gzip);
 }

 const char*  //
 mimic_zlib_decode(wuffs_base__io_buffer* dst,
                   wuffs_base__io_buffer* src,
                   uint32_t wuffs_initialize_flags,
                   uint64_t wlimit,
                   uint64_t rlimit) {
   return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
                                         zlib_flavor_zlib);
 }

 const char*  //
 mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
                                   wuffs_base__io_buffer* src,
                                   wuffs_base__slice_u8 dictionary) {
   return mimic_deflate_gzip_zlib_decode(dst, src, &dictionary, UINT64_MAX,
                                         UINT64_MAX, zlib_flavor_zlib);
 }

 #endif
 // -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
	// Copyright 2017 The Wuffs Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// ----------------

	// Uncomment one of these #define lines to test and bench alternative mimic
	// libraries (libdeflate or miniz) instead of zlib-the-library.
	//
	// These are collectively referred to as
	// WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB.
	//
	// #define WUFFS_MIMICLIB_USE_LIBDEFLATE_INSTEAD_OF_ZLIB 1
	// #define WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB 1

	// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
	#if defined(WUFFS_MIMICLIB_USE_LIBDEFLATE_INSTEAD_OF_ZLIB)
	#include "libdeflate.h"

	#define WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING 1

	#define WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES 1

	uint32_t global_mimiclib_deflate_unused_u32;

	typedef enum libdeflate_result (*libdeflate_decompress_func)(
	struct libdeflate_decompressor* decompressor,
	const void* in,
	size_t in_nbytes,
	void* out,
	size_t out_nbytes_avail,
	size_t* actual_in_nbytes_ret,
	size_t* actual_out_nbytes_ret);

	const char* //
	libdeflate_result_as_const_char_star(enum libdeflate_result r) {
	switch (r) {
	case LIBDEFLATE_SUCCESS:
	return NULL;
	case LIBDEFLATE_BAD_DATA:
	return "libdeflate: bad data";
	case LIBDEFLATE_SHORT_OUTPUT:
	return "libdeflate: short output";
	case LIBDEFLATE_INSUFFICIENT_SPACE:
	return "libdeflate: insufficient space";
	}
	return "libdeflate: unknown error";
	}

	const char* //
	mimic_bench_adler32(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	global_mimiclib_deflate_unused_u32 = 1;
	while (src->meta.ri < src->meta.wi) {
	uint8_t* ptr = src->data.ptr + src->meta.ri;
	size_t len = src->meta.wi - src->meta.ri;
	if (len > 0x7FFFFFFF) {
	return "src length is too large";
	} else if (len > rlimit) {
	len = rlimit;
	}
	global_mimiclib_deflate_unused_u32 =
	libdeflate_adler32(global_mimiclib_deflate_unused_u32, ptr, len);
	src->meta.ri += len;
	}
	return NULL;
	}

	const char* //
	mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	global_mimiclib_deflate_unused_u32 = 0;
	while (src->meta.ri < src->meta.wi) {
	uint8_t* ptr = src->data.ptr + src->meta.ri;
	size_t len = src->meta.wi - src->meta.ri;
	if (len > 0x7FFFFFFF) {
	return "src length is too large";
	} else if (len > rlimit) {
	len = rlimit;
	}
	global_mimiclib_deflate_unused_u32 =
	libdeflate_crc32(global_mimiclib_deflate_unused_u32, ptr, len);
	src->meta.ri += len;
	}
	return NULL;
	}

	const char* //
	mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit,
	libdeflate_decompress_func func) {
	struct libdeflate_decompressor* dec = libdeflate_alloc_decompressor();
	if (!dec) {
	return "libdeflate: alloc failed";
	}
	size_t n_dst = 0;
	size_t n_src = 0;
	enum libdeflate_result res =
	(*func)(dec, wuffs_base__io_buffer__reader_pointer(src),
	((size_t)wuffs_base__u64__min(
	rlimit, wuffs_base__io_buffer__reader_length(src))),
	wuffs_base__io_buffer__writer_pointer(dst),
	((size_t)wuffs_base__u64__min(
	wlimit, wuffs_base__io_buffer__writer_length(dst))),
	&n_src, &n_dst);
	if (res == LIBDEFLATE_SUCCESS) {
	dst->meta.wi += n_dst;
	src->meta.ri += n_src;
	}
	libdeflate_free_decompressor(dec);
	return libdeflate_result_as_const_char_star(res);
	}

	const char* //
	mimic_deflate_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
	wlimit, rlimit,
	&libdeflate_deflate_decompress_ex);
	}

	const char* //
	mimic_gzip_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
	wlimit, rlimit,
	&libdeflate_gzip_decompress_ex);
	}

	const char* //
	mimic_zlib_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
	wlimit, rlimit,
	&libdeflate_zlib_decompress_ex);
	}

	const char* //
	mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	wuffs_base__slice_u8 dictionary) {
	return "libdeflate does not implement zlib dictionaries";
	}

	// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
	#elif defined(WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB)
	#include "/path/to/your/copy/of/github.com/richgel999/miniz/miniz_tinfl.c"

	// We deliberately do not define the
	// WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING macro.

	#define WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES 1

	const char* //
	mimic_bench_adler32(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return "miniz does not independently compute Adler32";
	}

	const char* //
	mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return "miniz does not implement CRC32/IEEE";
	}

	const char* //
	mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit,
	bool deflate_instead_of_zlib) {
	if ((wlimit < UINT64_MAX) \|\| (rlimit < UINT64_MAX)) {
	// Supporting this would probably mean using tinfl_decompress instead of
	// the simpler tinfl_decompress_mem_to_mem function.
	return "unsupported I/O limit";
	}
	int flags = 0;
	if (!deflate_instead_of_zlib) {
	flags \|= TINFL_FLAG_PARSE_ZLIB_HEADER;
	}
	size_t n = tinfl_decompress_mem_to_mem(
	dst->data.ptr + dst->meta.wi, dst->data.len - dst->meta.wi,
	src->data.ptr + src->meta.ri, src->meta.wi - src->meta.ri, flags);
	if (n == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED) {
	return "TINFL_DECOMPRESS_MEM_TO_MEM_FAILED";
	}
	dst->meta.wi += n;
	src->meta.ri = src->meta.wi;
	return NULL;
	}

	const char* //
	mimic_deflate_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_zlib_decode(dst, src, wuffs_initialize_flags, wlimit,
	rlimit, true);
	}

	const char* //
	mimic_gzip_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return "miniz does not implement gzip";
	}

	const char* //
	mimic_zlib_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_zlib_decode(dst, src, wuffs_initialize_flags, wlimit,
	rlimit, false);
	}

	const char* //
	mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	wuffs_base__slice_u8 dictionary) {
	return "miniz does not implement zlib dictionaries";
	}

	// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
	#else
	#include "zlib.h"

	// We deliberately do not define the
	// WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING macro.

	// We deliberately do not define the
	// WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES macro.

	uint32_t global_mimiclib_deflate_unused_u32;

	const char* //
	mimic_bench_adler32(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	global_mimiclib_deflate_unused_u32 = 0;
	while (src->meta.ri < src->meta.wi) {
	uint8_t* ptr = src->data.ptr + src->meta.ri;
	size_t len = src->meta.wi - src->meta.ri;
	if (len > 0x7FFFFFFF) {
	return "src length is too large";
	} else if (len > rlimit) {
	len = rlimit;
	}
	global_mimiclib_deflate_unused_u32 =
	adler32(global_mimiclib_deflate_unused_u32, ptr, len);
	src->meta.ri += len;
	}
	return NULL;
	}

	const char* //
	mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	global_mimiclib_deflate_unused_u32 = 0;
	while (src->meta.ri < src->meta.wi) {
	uint8_t* ptr = src->data.ptr + src->meta.ri;
	size_t len = src->meta.wi - src->meta.ri;
	if (len > 0x7FFFFFFF) {
	return "src length is too large";
	} else if (len > rlimit) {
	len = rlimit;
	}
	global_mimiclib_deflate_unused_u32 =
	crc32(global_mimiclib_deflate_unused_u32, ptr, len);
	src->meta.ri += len;
	}
	return NULL;
	}

	typedef enum {
	zlib_flavor_raw,
	zlib_flavor_gzip,
	zlib_flavor_zlib,
	} zlib_flavor;

	const char* //
	mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	wuffs_base__slice_u8* dictionary,
	uint64_t wlimit,
	uint64_t rlimit,
	zlib_flavor flavor) {
	const char* ret = NULL;
	if (dst->data.len > UINT_MAX) {
	ret = "dst length is too large";
	goto cleanup0;
	}
	if (src->data.len > UINT_MAX) {
	ret = "src length is too large";
	goto cleanup0;
	}

	// See inflateInit2 in the zlib manual, or in zlib.h, for details about how
	// the window_bits int also encodes the wire format wrapper.
	int window_bits = 0;
	switch (flavor) {
	case zlib_flavor_raw:
	window_bits = -15;
	break;
	case zlib_flavor_gzip:
	window_bits = +15 \| 16;
	break;
	case zlib_flavor_zlib:
	window_bits = +15;
	break;
	default:
	ret = "invalid zlib_flavor";
	goto cleanup0;
	}
	z_stream z = {0};
	int ii2_err = inflateInit2(&z, window_bits);
	if (ii2_err != Z_OK) {
	ret = "inflateInit2 failed";
	goto cleanup0;
	}

	while (true) {
	z.next_in = src->data.ptr + src->meta.ri;
	z.avail_in = src->meta.wi - src->meta.ri;
	if (z.avail_in > rlimit) {
	z.avail_in = rlimit;
	}
	uInt initial_avail_in = z.avail_in;

	z.next_out = dst->data.ptr + dst->meta.wi;
	z.avail_out = dst->data.len - dst->meta.wi;
	if (z.avail_out > wlimit) {
	z.avail_out = wlimit;
	}
	uInt initial_avail_out = z.avail_out;

	// TODO: s/Z_NO_FLUSH/Z_SYNC_FLUSH/ more closely matches Wuffs' behavior.
	int i_err = inflate(&z, Z_NO_FLUSH);

	if (initial_avail_in < z.avail_in) {
	ret = "inconsistent avail_in";
	goto cleanup1;
	}
	src->meta.ri += initial_avail_in - z.avail_in;

	if (initial_avail_out < z.avail_out) {
	ret = "inconsistent avail_out";
	goto cleanup1;
	}
	dst->meta.wi += initial_avail_out - z.avail_out;

	if (i_err == Z_STREAM_END) {
	break;
	} else if (i_err == Z_NEED_DICT) {
	if (dictionary) {
	int isd_err =
	inflateSetDictionary(&z, dictionary->ptr, dictionary->len);
	if (isd_err != Z_OK) {
	ret = "inflateSetDictionary failed";
	goto cleanup1;
	}
	dictionary = NULL;
	continue;
	}
	ret = "inflate failed (need dict)";
	goto cleanup1;
	} else if (i_err == Z_DATA_ERROR) {
	ret = "inflate failed (data error)";
	goto cleanup1;
	} else if (i_err != Z_OK) {
	ret = "inflate failed";
	goto cleanup1;
	}
	}

	cleanup1:;
	int ie_err = inflateEnd(&z);
	if ((ie_err != Z_OK) && !ret) {
	ret = "inflateEnd failed";
	}

	cleanup0:;
	return ret;
	}

	const char* //
	mimic_deflate_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
	zlib_flavor_raw);
	}

	const char* //
	mimic_gzip_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
	zlib_flavor_gzip);
	}

	const char* //
	mimic_zlib_decode(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	uint32_t wuffs_initialize_flags,
	uint64_t wlimit,
	uint64_t rlimit) {
	return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
	zlib_flavor_zlib);
	}

	const char* //
	mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
	wuffs_base__io_buffer* src,
	wuffs_base__slice_u8 dictionary) {
	return mimic_deflate_gzip_zlib_decode(dst, src, &dictionary, UINT64_MAX,
	UINT64_MAX, zlib_flavor_zlib);
	}

	#endif
	// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB