libdeflate 0.1.0

data/ext/libdeflate/libdeflate/tools/pgo_build.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Try gcc profile-guided optimizations
+
+set -eu
+
+MAKE="make -j$(grep -c processor /proc/cpuinfo)"
+DATAFILE="$HOME/data/silesia"
+
+$MAKE benchmark > /dev/null
+echo "====================="
+echo "Original performance:"
+echo "---------------------"
+./benchmark "$@" "$DATAFILE"
+
+$MAKE CFLAGS=-fprofile-generate LDFLAGS=-fprofile-generate benchmark > /dev/null
+./benchmark "$@" "$DATAFILE" > /dev/null
+$MAKE CFLAGS=-fprofile-use benchmark > /dev/null
+rm -f {lib,programs}/*.gcda
+echo "=========================="
+echo "PGO-optimized performance:"
+echo "--------------------------"
+./benchmark "$@" "$DATAFILE"

data/ext/libdeflate/libdeflate/tools/produce_gzip_benchmark_table.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+set -e
+
+do_benchmark() {
+	usize=$(stat -c %s "$file")
+	"$HOME/proj/libdeflate/benchmark" -g -s $usize "$@" "$file" \
+			| grep Compressed | cut -f 4 -d ' '
+}
+
+echo "File | zlib -6 | zlib -9 | libdeflate -6 | libdeflate -9 | libdeflate -12"
+echo "-----|---------|---------|---------------|---------------|---------------"
+
+for file in "$@"; do
+	echo -n "$(basename "$file")"
+	results=()
+	results+=($(do_benchmark -Y -6))
+	results+=($(do_benchmark -Y -9))
+	results+=($(do_benchmark -6))
+	results+=($(do_benchmark -9))
+	results+=($(do_benchmark -12))
+	best=2000000000
+	for result in "${results[@]}"; do
+		if (( result < best)); then
+			best=$result
+		fi
+	done
+	for result in "${results[@]}"; do
+		if (( result == best )); then
+			em="**"
+		else
+			em=""
+		fi
+		echo -n " | ${em}${result}${em}"
+	done
+	echo
+done

data/ext/libdeflate/libdeflate/tools/run_tests.sh

@@ -0,0 +1,305 @@
+#!/bin/bash
+#
+# Test script for libdeflate
+#
+#	Usage: ./tools/run_tests.sh [TESTGROUP]... [-TESTGROUP]...
+#
+# By default all tests are run, but it is possible to explicitly include or
+# exclude specific test groups.
+#
+
+set -eu -o pipefail
+cd "$(dirname "$0")/.."
+
+TESTGROUPS=(all)
+
+set_test_groups() {
+	TESTGROUPS=("$@")
+	local have_exclusion=0
+	local have_all=0
+	for group in "${TESTGROUPS[@]}"; do
+		if [[ $group == -* ]]; then
+			have_exclusion=1
+		elif [[ $group == all ]]; then
+			have_all=1
+		fi
+	done
+	if (( have_exclusion && !have_all )); then
+		TESTGROUPS=(all "${TESTGROUPS[@]}")
+	fi
+}
+
+if [ $# -gt 0 ]; then
+	set_test_groups "$@"
+fi
+
+SMOKEDATA="${SMOKEDATA:=$HOME/data/smokedata}"
+if [ ! -e "$SMOKEDATA" ]; then
+	echo "SMOKEDATA (value: $SMOKEDATA) does not exist.  Set the" \
+	      "environmental variable SMOKEDATA to a file to use in" \
+	      "compression/decompression tests." 1>&2
+	exit 1
+fi
+
+NDKDIR="${NDKDIR:=/opt/android-ndk}"
+
+FILES=("$SMOKEDATA" ./tools/exec_tests.sh benchmark test_checksums)
+EXEC_TESTS_CMD="WRAPPER= SMOKEDATA=\"$(basename $SMOKEDATA)\" sh exec_tests.sh"
+NPROC=$(grep -c processor /proc/cpuinfo)
+VALGRIND="valgrind --quiet --error-exitcode=100 --leak-check=full --errors-for-leak-kinds=all"
+SANITIZE_CFLAGS="-fsanitize=undefined -fno-sanitize-recover=undefined,integer"
+
+TMPFILE="$(mktemp)"
+trap "rm -f \"$TMPFILE\"" EXIT
+
+###############################################################################
+
+rm -f run_tests.log
+exec >  >(tee -ia run_tests.log)
+exec 2> >(tee -ia run_tests.log >&2)
+
+TESTS_SKIPPED=0
+log_skip() {
+	log "[WARNING, TEST SKIPPED]: $@"
+	TESTS_SKIPPED=1
+}
+
+log() {
+	echo "[$(date)] $@"
+}
+
+run_cmd() {
+	log "$@"
+	"$@" > /dev/null
+}
+
+test_group_included() {
+	local included=0 group
+	for group in "${TESTGROUPS[@]}"; do
+		if [ "$group" = "$1" ]; then
+			included=1 # explicitly included
+			break
+		fi
+		if [ "$group" = "-$1" ]; then
+			included=0 # explicitly excluded
+			break
+		fi
+		if [ "$group" = "all" ]; then # implicitly included
+			included=1
+		fi
+	done
+	if (( included )); then
+		log "Starting test group: $1"
+	fi
+	(( included ))
+}
+
+###############################################################################
+
+native_build_and_test() {
+	make "$@" -j$NPROC all test_programs > /dev/null
+	WRAPPER="$WRAPPER" SMOKEDATA="$SMOKEDATA" sh ./tools/exec_tests.sh \
+			> /dev/null
+}
+
+native_tests() {
+	test_group_included native || return 0
+	local compiler cflags compilers=(gcc)
+	shopt -s nullglob
+	compilers+=(/usr/bin/gcc-[0-9]*)
+	compilers+=(/usr/bin/clang-[0-9]*)
+	compilers+=(/opt/gcc*/bin/gcc)
+	compilers+=(/opt/clang*/bin/clang)
+	shopt -u nullglob
+	for compiler in ${compilers[@]}; do
+		for cflags in "" "-march=native" "-m32"; do
+			if [ "$compiler" = "/usr/bin/gcc-4.8" -a \
+			     "$cflags" = "-m32" ]; then
+				continue
+			fi
+			log "Running tests with CC=$compiler," \
+				"CFLAGS=$cflags"
+			WRAPPER= native_build_and_test \
+				CC=$compiler CFLAGS="$cflags -Werror"
+		done
+	done
+
+	log "Running tests with Valgrind"
+	WRAPPER="$VALGRIND" native_build_and_test
+
+	log "Running tests with undefined behavior sanitizer"
+	WRAPPER= native_build_and_test CC=clang CFLAGS="$SANITIZE_CFLAGS"
+}
+
+###############################################################################
+
+android_build() {
+	run_cmd ./tools/android_build.sh --ndkdir="$NDKDIR" "$@"
+}
+
+android_build_and_test() {
+	android_build "$@"
+	run_cmd adb push "${FILES[@]}" /data/local/tmp/
+
+	# Note: adb shell always returns 0, even if the shell command fails...
+	log "adb shell \"cd /data/local/tmp && $EXEC_TESTS_CMD\""
+	adb shell "cd /data/local/tmp && $EXEC_TESTS_CMD" > "$TMPFILE"
+	if ! grep -q "exec_tests finished successfully" "$TMPFILE"; then
+		log "Android test failure!  adb shell output:"
+		cat "$TMPFILE"
+		return 1
+	fi
+}
+
+android_tests() {
+	local compiler
+
+	test_group_included android || return 0
+	if [ ! -e $NDKDIR ]; then
+		log_skip "Android NDK was not found in NDKDIR=$NDKDIR!" \
+		         "If you want to run the Android tests, set the" \
+			 "environmental variable NDKDIR to the location of" \
+			 "your Android NDK installation"
+		return 0
+	fi
+
+	if ! type -P adb > /dev/null; then
+		log_skip "adb (android-tools) is not installed"
+		return 0
+	fi
+
+	if ! adb devices | grep -q 'device$'; then
+		log_skip "No Android device is currently attached"
+		return 0
+	fi
+
+	for compiler in gcc clang; do
+		android_build_and_test --arch=arm --compiler=$compiler
+
+		android_build_and_test --arch=arm --compiler=$compiler \
+				       --disable-neon
+
+		# arm64: currently compiled but not run
+		android_build --arch=arm64 --compiler=$compiler
+	done
+}
+
+###############################################################################
+
+mips_tests() {
+	test_group_included mips || return 0
+	if ! ping -c 1 dd-wrt > /dev/null; then
+		log_skip "Can't run MIPS tests: dd-wrt system not available"
+		return 0
+	fi
+	run_cmd ./tools/mips_build.sh
+	run_cmd scp "${FILES[@]}" root@dd-wrt:
+	run_cmd ssh root@dd-wrt "$EXEC_TESTS_CMD"
+}
+
+###############################################################################
+
+windows_tests() {
+	local arch
+
+	test_group_included windows || return 0
+
+	# Windows: currently compiled but not run
+	for arch in i686 x86_64; do
+		local compiler=${arch}-w64-mingw32-gcc
+		if ! type -P $compiler > /dev/null; then
+			log_skip "$compiler not found"
+			continue
+		fi
+		run_cmd make CC=$compiler CFLAGS=-Werror -j$NPROC \
+			all test_programs
+	done
+}
+
+###############################################################################
+
+static_analysis_tests() {
+	test_group_included static_analysis || return 0
+	if ! type -P scan-build > /dev/null; then
+		log_skip "clang static analyzer (scan-build) not found"
+		return 0
+	fi
+	run_cmd scan-build --status-bugs make -j$NPROC all test_programs
+}
+
+###############################################################################
+
+gzip_tests() {
+	test_group_included gzip || return 0
+
+	local gzip gunzip
+	run_cmd make -j$NPROC gzip gunzip
+	for gzip in "$PWD/gzip" /usr/bin/gzip; do
+		for gunzip in "$PWD/gunzip" /usr/bin/gunzip; do
+			log "Running gzip program tests with GZIP=$gzip," \
+				"GUNZIP=$gunzip"
+			GZIP="$gzip" GUNZIP="$gunzip" SMOKEDATA="$SMOKEDATA" \
+				./tools/gzip_tests.sh
+		done
+	done
+
+	log "Running gzip program tests with Valgrind"
+	GZIP="$VALGRIND $PWD/gzip" GUNZIP="$VALGRIND $PWD/gunzip" \
+		SMOKEDATA="$SMOKEDATA" ./tools/gzip_tests.sh
+
+	log "Running gzip program tests with undefined behavior sanitizer"
+	run_cmd make -j$NPROC CC=clang CFLAGS="$SANITIZE_CFLAGS" gzip gunzip
+	GZIP="$PWD/gzip" GUNZIP="$PWD/gunzip" \
+		SMOKEDATA="$SMOKEDATA" ./tools/gzip_tests.sh
+}
+
+###############################################################################
+
+edge_case_tests() {
+	test_group_included edge_case || return 0
+
+	# Regression test for "deflate_compress: fix corruption with long
+	# literal run".  Try to compress a file longer than 65535 bytes where no
+	# 2-byte sequence (3 would be sufficient) is repeated <= 32768 bytes
+	# apart, and the distribution of bytes remains constant throughout, and
+	# yet not all bytes are used so the data is still slightly compressible.
+	# There will be no matches in this data, but the compressor should still
+	# output a compressed block, and this block should contain more than
+	# 65535 consecutive literals, which triggered the bug.
+	#
+	# Note: on random data, this situation is extremely unlikely if the
+	# compressor uses all matches it finds, since random data will on
+	# average have a 3-byte match every (256**3)/32768 = 512 bytes.
+	python3 > "$TMPFILE" << EOF
+import sys
+for i in range(2):
+    for stride in range(1,251):
+        b = bytes(stride*multiple % 251 for multiple in range(251))
+        sys.stdout.buffer.write(b)
+EOF
+	run_cmd make -j$NPROC benchmark
+	run_cmd ./benchmark -3 "$TMPFILE"
+	run_cmd ./benchmark -6 "$TMPFILE"
+	run_cmd ./benchmark -12 "$TMPFILE"
+}
+
+###############################################################################
+
+log "Starting libdeflate tests"
+log "	TESTGROUPS=(${TESTGROUPS[@]})"
+log "	SMOKEDATA=$SMOKEDATA"
+log "	NDKDIR=$NDKDIR"
+
+native_tests
+android_tests
+mips_tests
+windows_tests
+static_analysis_tests
+gzip_tests
+edge_case_tests
+
+if (( TESTS_SKIPPED )); then
+	log "No tests failed, but some tests were skipped.  See above."
+else
+	log "All tests passed!"
+fi

data/ext/libdeflate/libdeflate/tools/windows_build.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -eu
+
+make -j CC=i686-w64-mingw32-gcc all test_programs
+cp -vf *.exe /j/exe/
+make -j CC=x86_64-w64-mingw32-gcc all test_programs
+cp -vf *.exe /j/exe64/
+
+sudo $HOME/bin/sudo/restart-smbd

data/ext/libdeflate/libdeflate_ext.c

@@ -0,0 +1,389 @@
+#include "libdeflate_ext.h"
+
+#define DEFAULT_COMPRESSION 6
+
+#define FORMAT_DEFLATE 0
+#define FORMAT_ZLIB 1
+#define FORMAT_GZIP 2
+
+VALUE rb_eLibdefalteError, rb_eBadDataError;
+
+/*
+ * call-seq:
+ *    Libdeflate.adler32(str = nil, adler = nil) -> integer
+ *
+ * Updates an Adler-32 checksum with <i>str</i>. If <i>str</i> is omitted, it
+ * returns the initial value of Adler-32 checksum. If <i>adler</i> is omitted,
+ * it assumes that the initial value of Adler-32 checksum is given.
+ *
+ *    Libdeflate.adler32                                #=> 1
+ *    Libdeflate.adler32('foo')                         #=> 42074437
+ *    Libdeflate.adler32('oo', Libdeflate.adler32('f')) #=> 42074437
+ */
+static VALUE
+rb_libdeflate_adler32(int argc, VALUE *argv, VALUE self)
+{
+    VALUE str, adler;
+    unsigned long checksum;
+
+    rb_scan_args(argc, argv, "02", &str, &adler);
+
+    if (!NIL_P(adler)) {
+        checksum = NUM2ULONG(adler);
+    } else if (!NIL_P(str)) {
+        checksum = libdeflate_adler32(0, NULL, 0);
+    } else {
+        checksum = 0;
+    }
+
+    if (NIL_P(str)) {
+        checksum = libdeflate_adler32(checksum, NULL, 0);
+    } else {
+        StringValue(str);
+        checksum = libdeflate_adler32(checksum, RSTRING_PTR(str), RSTRING_LEN(str));
+    }
+
+    return ULONG2NUM(checksum);
+}
+
+/*
+ * call-seq:
+ *    Libdeflate.crc32(str = nil, crc = nil) -> integer
+ *
+ * Updates a CRC-32 checksum with <i>str</i>. If <i>str</i> is omitted, it
+ * returns the initial value of CRC-32 checksum. If <i>crc</i> is omitted, it
+ * assumes that the initial value of CRC-32 checksum is given.
+ *
+ *    Libdeflate.crc32                              #=> 0
+ *    Libdeflate.crc32('foo')                       #=> 2356372769
+ *    Libdeflate.crc32('oo', Libdeflate.crc32('f')) #=> 2356372769
+ */
+static VALUE
+rb_libdeflate_crc32(int argc, VALUE *argv, VALUE self)
+{
+    VALUE str, crc;
+    unsigned long checksum;
+
+    rb_scan_args(argc, argv, "02", &str, &crc);
+
+    if (!NIL_P(crc)) {
+        checksum = NUM2ULONG(crc);
+    } else if (!NIL_P(str)) {
+        checksum = libdeflate_crc32(0, NULL, 0);
+    } else {
+        checksum = 0;
+    }
+
+    if (NIL_P(str)) {
+        checksum = libdeflate_crc32(checksum, NULL, 0);
+    } else {
+        StringValue(str);
+        checksum = libdeflate_crc32(checksum, RSTRING_PTR(str), RSTRING_LEN(str));
+    }
+
+    return ULONG2NUM(checksum);
+}
+
+static void
+compressor_free(void *ptr)
+{
+    libdeflate_free_compressor((struct libdeflate_compressor *)ptr);
+}
+
+static const rb_data_type_t compressor_data_type = {
+    "compressor",
+    { NULL, compressor_free, NULL, },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE
+rb_compressor_s_allocate(VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass, &compressor_data_type, 0);
+}
+
+/*
+ * call-seq:
+ *    initialize(level = DEFAULT_COMPRESSION) -> compressor
+ *
+ * Returns a new Libdeflate::Compressor object. <i>level</i> must be in range
+ * from 1 to 12, and defaults to DEFAULT_COMPRESSION.
+ *
+ *    Libdeflate::Compressor.new #=> #<Libdeflate::Compressor:0x007fad31b672c8>
+ */
+static VALUE
+rb_compressor_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE level;
+    int compression_level;
+    struct libdeflate_compressor *c;
+
+    rb_scan_args(argc, argv, "01", &level);
+
+    compression_level = NIL_P(level) ? DEFAULT_COMPRESSION : FIX2INT(level);
+
+    c = libdeflate_alloc_compressor(compression_level);
+    if (c == NULL) {
+        rb_raise(rb_eLibdefalteError, "libdeflate_alloc_compressor: compression_level=%d", compression_level);
+    }
+
+    DATA_PTR(self) = c;
+
+    return self;
+}
+
+static inline struct libdeflate_compressor *
+check_compressor(VALUE self)
+{
+      return rb_check_typeddata(self, &compressor_data_type);
+}
+
+/*
+ * call-seq:
+ *    compressor.compress(str, format = DEFLATE, outbuf = nil) -> string
+ *
+ * Compresses the given string into <i>format</i>. Valid values of <i>format</i>
+ * are DEFLATE (default), ZLIB and GZIP. If <i>outbuf</i> is given, the
+ * resulting compressed data will be written to it.
+ *
+ *    compressor.compress('foo')                   #=> "\x01\x03\x00\xFC\xFFfoo"
+ *    compressor.compress('foo', Libdeflate::ZLIB) #=> "x\x9C\x01\x03\x00\xFC\xFFfoo\x02\x82\x01E"
+ *
+ *    outbuf = 'bar'
+ *    compressor.compress('foo', nil, outbuf) #=> "\x01\x03\x00\xFC\xFFfoo"
+ *    outbuf                                  #=> "\x01\x03\x00\xFC\xFFfoo"
+ */
+static VALUE
+rb_compressor_compress(int argc, VALUE *argv, VALUE self)
+{
+    struct libdeflate_compressor *c = check_compressor(self);
+    VALUE str, format, outbuf;
+    size_t (*compress_func)(struct libdeflate_compressor *, const void *, size_t, void *, size_t);
+    size_t (*compress_bound_func)(struct libdeflate_compressor *, size_t);
+    size_t out_nbytes, max_out_nbytes;
+
+    rb_scan_args(argc, argv, "12", &str, &format, &outbuf);
+
+    StringValue(str);
+
+    switch (NIL_P(format) ? FORMAT_DEFLATE : FIX2INT(format)) {
+        case FORMAT_DEFLATE:
+            compress_func = &libdeflate_deflate_compress;
+            compress_bound_func = &libdeflate_deflate_compress_bound;
+            break;
+        case FORMAT_ZLIB:
+            compress_func = &libdeflate_zlib_compress;
+            compress_bound_func = &libdeflate_zlib_compress_bound;
+            break;
+        case FORMAT_GZIP:
+            compress_func = &libdeflate_gzip_compress;
+            compress_bound_func = &libdeflate_gzip_compress_bound;
+            break;
+        default:
+            rb_raise(rb_eLibdefalteError, "unknown compressed data format: %d", FIX2INT(format));
+    }
+
+    if (NIL_P(outbuf)) {
+        outbuf = rb_str_buf_new(compress_bound_func(c, RSTRING_LEN(str)));
+    } else {
+        StringValue(outbuf);
+        rb_str_modify(outbuf);
+    }
+
+    out_nbytes = compress_func(c,
+                               RSTRING_PTR(str),
+                               RSTRING_LEN(str),
+                               RSTRING_PTR(outbuf),
+                               rb_str_capacity(outbuf));
+
+    if (out_nbytes > 0) {
+        rb_str_set_len(outbuf, out_nbytes);
+        OBJ_INFECT(outbuf, str);
+        return outbuf;
+    }
+
+    max_out_nbytes = compress_bound_func(c, RSTRING_LEN(str));
+    if (rb_str_capacity(outbuf) >= max_out_nbytes) {
+        rb_raise(rb_eLibdefalteError, "failed to compress data");
+    }
+
+    rb_str_modify_expand(outbuf, max_out_nbytes - RSTRING_LEN(outbuf));
+
+    out_nbytes = compress_func(c,
+                               RSTRING_PTR(str),
+                               RSTRING_LEN(str),
+                               RSTRING_PTR(outbuf),
+                               rb_str_capacity(outbuf));
+
+    if (out_nbytes == 0) {
+        rb_raise(rb_eLibdefalteError, "failed to compress data");
+    }
+
+    rb_str_set_len(outbuf, out_nbytes);
+    OBJ_INFECT(outbuf, str);
+
+    return outbuf;
+}
+
+static void
+decompressor_free(void *ptr)
+{
+    libdeflate_free_decompressor((struct libdeflate_decompressor *)ptr);
+}
+
+static const rb_data_type_t decompressor_data_type = {
+    "decompressor",
+    { NULL, decompressor_free, NULL, },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE
+rb_decompressor_s_allocate(VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass, &decompressor_data_type, 0);
+}
+
+/*
+ * call-seq:
+ *    initialize -> decompressor
+ *
+ * Returns a new Libdeflate::Decompressor object.
+ *
+ *    Libdeflate::Decompressor.new #=> #<Libdeflate::Decompressor:0x007fde591a6500>
+ */
+static VALUE
+rb_decompressor_initialize(VALUE self)
+{
+    struct libdeflate_decompressor *d = libdeflate_alloc_decompressor();
+    if (d == NULL) {
+        rb_raise(rb_eLibdefalteError, "libdeflate_alloc_decompressor");
+    }
+
+    DATA_PTR(self) = d;
+
+    return self;
+}
+
+static inline struct libdeflate_decompressor *
+check_decompressor(VALUE self)
+{
+      return rb_check_typeddata(self, &decompressor_data_type);
+}
+
+static long
+next_power_of_two(long n) {
+  n--;
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+#if LONG_MAX > UINT32_MAX
+  n |= n >> 32;
+#endif
+  n++;
+  return n;
+}
+
+/*
+ * call-seq:
+ *    decompressor.decompress(str, format = nil, outbuf = nil) -> string
+ *
+ * Decompresses the given string compressed in <i>format</i>. Valid values of
+ * <i>format</i> are DEFLATE (default), ZLIB and GZIP. If <i>outbuf</i> is
+ * given, the resulting uncompressed data will be written to it.
+ *
+ *    decompressor.decompress("\x01\x03\x00\xFC\xFFfoo")                                     #=> "foo"
+ *    decompressor.decompress("x\x9C\x01\x03\x00\xFC\xFFfoo\x02\x82\x01E", Libdeflate::ZLIB) #=> "foo"
+ *
+ *    outbuf = 'bar'
+ *    decompressor.decompress("\x01\x03\x00\xFC\xFFfoo", nil, outbuf) #=> "foo"
+ *    outbuf                                                          #=> "foo"
+ */
+static VALUE
+rb_compressor_decompress(int argc, VALUE *argv, VALUE self)
+{
+    struct libdeflate_decompressor *d = check_decompressor(self);
+    VALUE str, format, outbuf;
+    enum libdeflate_result (*decompress_func)(struct libdeflate_decompressor *, const void *, size_t, void *, size_t, size_t *);
+    size_t actual_out_nbytes_ret;
+    enum libdeflate_result decompress_result;
+
+    rb_scan_args(argc, argv, "12", &str, &format, &outbuf);
+
+    StringValue(str);
+
+    switch (NIL_P(format) ? FORMAT_DEFLATE : FIX2INT(format)) {
+        case FORMAT_DEFLATE:
+            decompress_func = &libdeflate_deflate_decompress;
+            break;
+        case FORMAT_ZLIB:
+            decompress_func = &libdeflate_zlib_decompress;
+            break;
+        case FORMAT_GZIP:
+            decompress_func = &libdeflate_gzip_decompress;
+            break;
+        default:
+            rb_raise(rb_eLibdefalteError, "unknown compressed data format: %d", FIX2INT(format));
+    }
+
+    if (NIL_P(outbuf)) {
+        outbuf = rb_str_buf_new(next_power_of_two(RSTRING_LEN(str)) << 4);
+    } else {
+        StringValue(outbuf);
+        rb_str_modify(outbuf);
+    }
+
+    for (;;) {
+        decompress_result = decompress_func(d,
+                                            RSTRING_PTR(str),
+                                            RSTRING_LEN(str),
+                                            RSTRING_PTR(outbuf),
+                                            rb_str_capacity(outbuf),
+                                            &actual_out_nbytes_ret);
+
+        if (decompress_result != LIBDEFLATE_INSUFFICIENT_SPACE) {
+            break;
+        }
+
+        rb_str_modify_expand(outbuf, (rb_str_capacity(outbuf) << 1) - RSTRING_LEN(outbuf));
+    }
+
+    if (decompress_result == LIBDEFLATE_BAD_DATA) {
+        rb_raise(rb_eBadDataError, "failed to decompress data");
+    } else if (decompress_result != LIBDEFLATE_SUCCESS) {
+        rb_raise(rb_eLibdefalteError, "failed to decompress data");
+    }
+
+    rb_str_set_len(outbuf, actual_out_nbytes_ret);
+    OBJ_INFECT(outbuf, str);
+
+    return outbuf;
+}
+
+void
+Init_libdeflate_ext(void)
+{
+    VALUE rb_mLibdeflate, rb_cCompressor, rb_cDecompressor;
+
+    rb_mLibdeflate = rb_define_module("Libdeflate");
+    rb_eLibdefalteError = rb_define_class_under(rb_mLibdeflate, "Error", rb_eStandardError);
+    rb_eBadDataError = rb_define_class_under(rb_mLibdeflate, "BadDataError", rb_eLibdefalteError);
+
+    rb_define_const(rb_mLibdeflate, "DEFLATE", INT2FIX(FORMAT_DEFLATE));
+    rb_define_const(rb_mLibdeflate, "ZLIB", INT2FIX(FORMAT_ZLIB));
+    rb_define_const(rb_mLibdeflate, "GZIP", INT2FIX(FORMAT_GZIP));
+
+    rb_define_module_function(rb_mLibdeflate, "adler32", rb_libdeflate_adler32, -1);
+    rb_define_module_function(rb_mLibdeflate, "crc32", rb_libdeflate_crc32, -1);
+
+    rb_cCompressor = rb_define_class_under(rb_mLibdeflate, "Compressor", rb_cObject);
+    rb_define_alloc_func(rb_cCompressor, rb_compressor_s_allocate);
+    rb_define_method(rb_cCompressor, "initialize", rb_compressor_initialize, -1);
+    rb_define_method(rb_cCompressor, "compress", rb_compressor_compress, -1);
+
+    rb_cDecompressor = rb_define_class_under(rb_mLibdeflate, "Decompressor", rb_cObject);
+    rb_define_alloc_func(rb_cDecompressor, rb_decompressor_s_allocate);
+    rb_define_method(rb_cDecompressor, "initialize", rb_decompressor_initialize, 0);
+    rb_define_method(rb_cDecompressor, "decompress", rb_compressor_decompress, -1);
+}