extlzham 0.0.1.PROTOTYPE3-x86-mingw32

data/contrib/lzham/lzhamlib/lzham_lib.cpp

@@ -0,0 +1,179 @@
+// File: lzham_lib.cpp - Static library entrypoints.
+// See Copyright Notice and license at the end of include/lzham.h
+#include "lzham_core.h"
+#include "lzham_decomp.h"
+#include "lzham_comp.h"
+
+extern "C" lzham_uint32 LZHAM_CDECL lzham_get_version(void)
+{
+   return LZHAM_DLL_VERSION;
+}
+
+extern "C" void LZHAM_CDECL lzham_set_memory_callbacks(lzham_realloc_func pRealloc, lzham_msize_func pMSize, void* pUser_data)
+{
+   lzham::lzham_lib_set_memory_callbacks(pRealloc, pMSize, pUser_data);
+}
+
+extern "C" lzham_decompress_state_ptr LZHAM_CDECL lzham_decompress_init(const lzham_decompress_params *pParams)
+{
+   return lzham::lzham_lib_decompress_init(pParams);
+}
+
+extern "C" lzham_decompress_state_ptr LZHAM_CDECL lzham_decompress_reinit(lzham_decompress_state_ptr p, const lzham_decompress_params *pParams)
+{
+   return lzham::lzham_lib_decompress_reinit(p, pParams);
+}
+
+extern "C" lzham_uint32 LZHAM_CDECL lzham_decompress_deinit(lzham_decompress_state_ptr p)
+{
+   return lzham::lzham_lib_decompress_deinit(p);
+}
+
+extern "C" lzham_decompress_status_t LZHAM_CDECL lzham_decompress(
+   lzham_decompress_state_ptr p,
+   const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, 
+   lzham_uint8 *pOut_buf, size_t *pOut_buf_size,
+   lzham_bool no_more_input_bytes_flag)
+{
+   return lzham::lzham_lib_decompress(p, pIn_buf, pIn_buf_size, pOut_buf, pOut_buf_size, no_more_input_bytes_flag);
+}   
+
+extern "C" lzham_decompress_status_t LZHAM_CDECL lzham_decompress_memory(const lzham_decompress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32)
+{
+   return lzham::lzham_lib_decompress_memory(pParams, pDst_buf, pDst_len, pSrc_buf, src_len, pAdler32);
+}
+
+extern "C" lzham_compress_state_ptr LZHAM_CDECL lzham_compress_init(const lzham_compress_params *pParams)
+{
+   return lzham::lzham_lib_compress_init(pParams);
+}
+
+extern "C" lzham_compress_state_ptr LZHAM_CDECL lzham_compress_reinit(lzham_compress_state_ptr p)
+{
+   return lzham::lzham_lib_compress_reinit(p);
+}
+
+extern "C" lzham_uint32 LZHAM_CDECL lzham_compress_deinit(lzham_compress_state_ptr p)
+{
+   return lzham::lzham_lib_compress_deinit(p);
+}
+
+extern "C" lzham_compress_status_t LZHAM_CDECL lzham_compress(
+   lzham_compress_state_ptr p,
+   const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, 
+   lzham_uint8 *pOut_buf, size_t *pOut_buf_size,
+   lzham_bool no_more_input_bytes_flag)
+{
+   return lzham::lzham_lib_compress(p, pIn_buf, pIn_buf_size, pOut_buf, pOut_buf_size, no_more_input_bytes_flag);
+}   
+
+extern "C" lzham_compress_status_t LZHAM_CDECL lzham_compress2(
+   lzham_compress_state_ptr p,
+   const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, 
+   lzham_uint8 *pOut_buf, size_t *pOut_buf_size,
+   lzham_flush_t flush_type)
+{
+   return lzham::lzham_lib_compress2(p, pIn_buf, pIn_buf_size, pOut_buf, pOut_buf_size, flush_type);
+}   
+
+extern "C" lzham_compress_status_t LZHAM_CDECL lzham_compress_memory(const lzham_compress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32)
+{
+   return lzham::lzham_lib_compress_memory(pParams, pDst_buf, pDst_len, pSrc_buf, src_len, pAdler32);
+}
+
+// ----------------- zlib-style API's
+
+extern "C" const char * LZHAM_CDECL lzham_z_version(void)
+{
+   return LZHAM_Z_VERSION;
+}
+
+extern "C" lzham_z_ulong LZHAM_CDECL lzham_z_adler32(lzham_z_ulong adler, const unsigned char *ptr, size_t buf_len)
+{
+   return lzham::lzham_lib_z_adler32(adler, ptr, buf_len);
+}
+
+extern "C" lzham_z_ulong LZHAM_CDECL lzham_z_crc32(lzham_z_ulong crc, const lzham_uint8 *ptr, size_t buf_len)
+{
+   return lzham::lzham_lib_z_crc32(crc, ptr, buf_len);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_deflateInit(lzham_z_streamp pStream, int level)
+{
+   return lzham::lzham_lib_z_deflateInit(pStream, level);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_deflateInit2(lzham_z_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
+{
+   return lzham::lzham_lib_z_deflateInit2(pStream, level, method, window_bits, mem_level, strategy);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_deflateReset(lzham_z_streamp pStream)
+{
+   return lzham::lzham_lib_z_deflateReset(pStream);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_deflate(lzham_z_streamp pStream, int flush)
+{
+   return lzham::lzham_lib_z_deflate(pStream, flush);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_deflateEnd(lzham_z_streamp pStream)
+{
+   return lzham::lzham_lib_z_deflateEnd(pStream);
+}
+
+extern "C" lzham_z_ulong LZHAM_CDECL lzham_z_deflateBound(lzham_z_streamp pStream, lzham_z_ulong source_len)
+{
+   return lzham::lzham_lib_z_deflateBound(pStream, source_len);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_compress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len)
+{
+   return lzham::lzham_lib_z_compress(pDest, pDest_len, pSource, source_len);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_compress2(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len, int level)
+{
+   return lzham::lzham_lib_z_compress2(pDest, pDest_len, pSource, source_len, level);
+}
+
+extern "C" lzham_z_ulong LZHAM_CDECL lzham_z_compressBound(lzham_z_ulong source_len)
+{
+   return lzham::lzham_lib_z_compressBound(source_len);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_inflateInit(lzham_z_streamp pStream)
+{
+   return lzham::lzham_lib_z_inflateInit(pStream);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_inflateInit2(lzham_z_streamp pStream, int window_bits)
+{
+   return lzham::lzham_lib_z_inflateInit2(pStream, window_bits);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_inflateReset(lzham_z_streamp pStream)
+{
+   return lzham::lzham_lib_z_inflateReset(pStream);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_inflate(lzham_z_streamp pStream, int flush)
+{
+   return lzham::lzham_lib_z_inflate(pStream, flush);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_inflateEnd(lzham_z_streamp pStream)
+{
+   return lzham::lzham_lib_z_inflateEnd(pStream);
+}
+
+extern "C" int LZHAM_CDECL lzham_z_uncompress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len)
+{
+   return lzham::lzham_lib_z_uncompress(pDest, pDest_len, pSource, source_len);
+}
+
+extern "C" const char * LZHAM_CDECL lzham_z_error(int err)
+{
+   return lzham::lzham_lib_z_error(err);
+}

data/examples/basic.rb

@@ -0,0 +1,48 @@
+#!ruby
+
+require "extlzham"
+
+# directly string encode / decode
+p data = LZHAM.encode("abcdefghijklmnopqrstuvwxyz" * 10)
+p LZHAM.decode(data)
+
+
+# directly string encode / decode with dictionaly size
+# (IMPORTANT! MUST BE SAME SIZE both encoding and decoding)
+dictsize = 20 # log(2)'d dictionaly size. This case is 1 MiB (2 ** 20).
+p data = LZHAM.encode("abcdefghijklmnopqrstuvwxyz" * 10, dictsize: dictsize)
+p LZHAM.decode(data, dictsize: dictsize)
+
+
+# streaming processing
+
+# setup streaming data
+ss = StringIO.new("abcdefghijklmnopqrstuvwxyz" * 10) # source stream
+es = StringIO.new # encoded stream
+ds = StringIO.new # destination stream
+
+# streaming encode with block
+ss.rewind
+es.rewind
+LZHAM.encode(es) { |lzham| lzham << ss.read }
+
+# streaming encode without block
+ss.rewind
+es.rewind
+lzham = LZHAM.encode(es)
+lzham << ss.read
+lzham.finish # or lzham.close
+
+# streaming decode with block
+ss.rewind
+es.rewind
+ds.rewind
+LZHAM.decode(ds) { |lzham| lzham << es.read }
+
+# streaming decode without block
+ss.rewind
+es.rewind
+ds.rewind
+lzham = LZHAM.decode(ds)
+lzham << es.read
+lzham.finish # or lzham.close

data/ext/constants.c

@@ -0,0 +1,64 @@
+#include "extlzham.h"
+
+VALUE mConsts;
+
+void
+extlzham_init_constants(void)
+{
+    RDOCFAKE(mLZHAM = rb_define_module("LZHAM"));
+    mConsts = rb_define_module_under(mLZHAM, "Constants");
+    rb_include_module(mLZHAM, mConsts);
+    rb_define_const(mConsts, "NO_FLUSH", INT2FIX(LZHAM_NO_FLUSH));
+    rb_define_const(mConsts, "SYNC_FLUSH", INT2FIX(LZHAM_SYNC_FLUSH));
+    rb_define_const(mConsts, "FULL_FLUSH", INT2FIX(LZHAM_FULL_FLUSH));
+    rb_define_const(mConsts, "FINISH", INT2FIX(LZHAM_FINISH));
+    rb_define_const(mConsts, "TABLE_FLUSH", INT2FIX(LZHAM_TABLE_FLUSH));
+    rb_define_const(mConsts, "MIN_DICT_SIZE_LOG2", INT2FIX(LZHAM_MIN_DICT_SIZE_LOG2));
+    rb_define_const(mConsts, "MAX_DICT_SIZE_LOG2", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
+    rb_define_const(mConsts, "MAX_DICT_SIZE_LOG2_X86", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
+    rb_define_const(mConsts, "MAX_DICT_SIZE_LOG2_X64", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X64));
+    rb_define_const(mConsts, "MAX_HELPER_THREADS", INT2FIX(LZHAM_MAX_HELPER_THREADS));
+    rb_define_const(mConsts, "COMP_LEVEL_FASTEST", INT2FIX(LZHAM_COMP_LEVEL_FASTEST));
+    rb_define_const(mConsts, "COMP_LEVEL_FASTER", INT2FIX(LZHAM_COMP_LEVEL_FASTER));
+    rb_define_const(mConsts, "COMP_LEVEL_DEFAULT", INT2FIX(LZHAM_COMP_LEVEL_DEFAULT));
+    rb_define_const(mConsts, "COMP_LEVEL_BETTER", INT2FIX(LZHAM_COMP_LEVEL_BETTER));
+    rb_define_const(mConsts, "COMP_LEVEL_UBER", INT2FIX(LZHAM_COMP_LEVEL_UBER));
+    rb_define_const(mConsts, "COMP_FLAG_EXTREME_PARSING", INT2FIX(LZHAM_COMP_FLAG_EXTREME_PARSING));
+    rb_define_const(mConsts, "COMP_FLAG_DETERMINISTIC_PARSING", INT2FIX(LZHAM_COMP_FLAG_DETERMINISTIC_PARSING));
+    rb_define_const(mConsts, "COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO", INT2FIX(LZHAM_COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO));
+    rb_define_const(mConsts, "COMP_FLAG_WRITE_ZLIB_STREAM", INT2FIX(LZHAM_COMP_FLAG_WRITE_ZLIB_STREAM));
+    rb_define_const(mConsts, "INSANELY_SLOW_TABLE_UPDATE_RATE", INT2FIX(LZHAM_INSANELY_SLOW_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "SLOWEST_TABLE_UPDATE_RATE", INT2FIX(LZHAM_SLOWEST_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "DEFAULT_TABLE_UPDATE_RATE", INT2FIX(LZHAM_DEFAULT_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "FASTEST_TABLE_UPDATE_RATE", INT2FIX(LZHAM_FASTEST_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "DECOMP_FLAG_OUTPUT_UNBUFFERED", INT2FIX(LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED));
+    rb_define_const(mConsts, "DECOMP_FLAG_COMPUTE_ADLER32", INT2FIX(LZHAM_DECOMP_FLAG_COMPUTE_ADLER32));
+    rb_define_const(mConsts, "DECOMP_FLAG_READ_ZLIB_STREAM", INT2FIX(LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM));
+
+    rb_define_const(mConsts, "LZHAM_NO_FLUSH", INT2FIX(LZHAM_NO_FLUSH));
+    rb_define_const(mConsts, "LZHAM_SYNC_FLUSH", INT2FIX(LZHAM_SYNC_FLUSH));
+    rb_define_const(mConsts, "LZHAM_FULL_FLUSH", INT2FIX(LZHAM_FULL_FLUSH));
+    rb_define_const(mConsts, "LZHAM_FINISH", INT2FIX(LZHAM_FINISH));
+    rb_define_const(mConsts, "LZHAM_TABLE_FLUSH", INT2FIX(LZHAM_TABLE_FLUSH));
+    rb_define_const(mConsts, "LZHAM_MIN_DICT_SIZE_LOG2", INT2FIX(LZHAM_MIN_DICT_SIZE_LOG2));
+    rb_define_const(mConsts, "LZHAM_MAX_DICT_SIZE_LOG2", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
+    rb_define_const(mConsts, "LZHAM_MAX_DICT_SIZE_LOG2_X86", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X86));
+    rb_define_const(mConsts, "LZHAM_MAX_DICT_SIZE_LOG2_X64", INT2FIX(LZHAM_MAX_DICT_SIZE_LOG2_X64));
+    rb_define_const(mConsts, "LZHAM_MAX_HELPER_THREADS", INT2FIX(LZHAM_MAX_HELPER_THREADS));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_FASTEST", INT2FIX(LZHAM_COMP_LEVEL_FASTEST));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_FASTER", INT2FIX(LZHAM_COMP_LEVEL_FASTER));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_DEFAULT", INT2FIX(LZHAM_COMP_LEVEL_DEFAULT));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_BETTER", INT2FIX(LZHAM_COMP_LEVEL_BETTER));
+    rb_define_const(mConsts, "LZHAM_COMP_LEVEL_UBER", INT2FIX(LZHAM_COMP_LEVEL_UBER));
+    rb_define_const(mConsts, "LZHAM_COMP_FLAG_EXTREME_PARSING", INT2FIX(LZHAM_COMP_FLAG_EXTREME_PARSING));
+    rb_define_const(mConsts, "LZHAM_COMP_FLAG_DETERMINISTIC_PARSING", INT2FIX(LZHAM_COMP_FLAG_DETERMINISTIC_PARSING));
+    rb_define_const(mConsts, "LZHAM_COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO", INT2FIX(LZHAM_COMP_FLAG_TRADEOFF_DECOMPRESSION_RATE_FOR_COMP_RATIO));
+    rb_define_const(mConsts, "LZHAM_COMP_FLAG_WRITE_ZLIB_STREAM", INT2FIX(LZHAM_COMP_FLAG_WRITE_ZLIB_STREAM));
+    rb_define_const(mConsts, "LZHAM_INSANELY_SLOW_TABLE_UPDATE_RATE", INT2FIX(LZHAM_INSANELY_SLOW_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "LZHAM_SLOWEST_TABLE_UPDATE_RATE", INT2FIX(LZHAM_SLOWEST_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "LZHAM_DEFAULT_TABLE_UPDATE_RATE", INT2FIX(LZHAM_DEFAULT_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "LZHAM_FASTEST_TABLE_UPDATE_RATE", INT2FIX(LZHAM_FASTEST_TABLE_UPDATE_RATE));
+    rb_define_const(mConsts, "LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED", INT2FIX(LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED));
+    rb_define_const(mConsts, "LZHAM_DECOMP_FLAG_COMPUTE_ADLER32", INT2FIX(LZHAM_DECOMP_FLAG_COMPUTE_ADLER32));
+    rb_define_const(mConsts, "LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM", INT2FIX(LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM));
+}

data/ext/decoder.c

@@ -0,0 +1,313 @@
+#include "extlzham.h"
+
+VALUE cDecoder;
+
+/*
+ * decoder
+ */
+
+static inline lzham_decompress_params
+aux_conv_decode_params(VALUE opts)
+{
+    lzham_decompress_params p;
+    memset(&p, 0, sizeof(p));
+    p.m_struct_size = sizeof(p);
+    if (NIL_P(opts)) {
+        p.m_dict_size_log2 = LZHAM_MIN_DICT_SIZE_LOG2;
+        p.m_table_update_rate = 0;
+        p.m_decompress_flags = 0; // (see lzham_decompress_flags enum)
+        p.m_num_seed_bytes = 0;
+        p.m_pSeed_bytes = NULL;
+        p.m_table_max_update_interval = 0;
+        p.m_table_update_interval_slow_rate = 0;
+    } else {
+        p.m_dict_size_log2 = aux_getoptu32(opts, id_dictsize, LZHAM_MIN_DICT_SIZE_LOG2);
+        p.m_table_update_rate = aux_getoptu32(opts, id_table_update_rate, 0);
+        p.m_decompress_flags = aux_getoptu32(opts, id_flags, 0);
+        p.m_num_seed_bytes = 0;
+        p.m_pSeed_bytes = NULL;
+        p.m_table_max_update_interval = aux_getoptu32(opts, id_table_max_update_interval, 0);
+        p.m_table_update_interval_slow_rate = aux_getoptu32(opts, id_table_update_interval_slow_rate, 0);
+    }
+
+    return p;
+}
+
+/*
+ * call-seq:
+ *  decode(string, max_decoded_size, opts = {}) -> decoded string
+ */
+static VALUE
+dec_s_decode(int argc, VALUE argv[], VALUE mod)
+{
+    VALUE src, size, opts;
+    rb_scan_args(argc, argv, "2:", &src, &size, &opts);
+    rb_check_type(src, RUBY_T_STRING);
+    rb_str_locktmp(src);
+    size_t srcsize = RSTRING_LEN(src);
+    size_t destsize = NUM2SIZET(size);
+    VALUE dest = rb_str_buf_new(destsize);
+    lzham_decompress_params p = aux_conv_decode_params(opts);
+    lzham_decompress_status_t s;
+    s = lzham_decompress_memory(&p,
+            (lzham_uint8 *)RSTRING_PTR(dest), &destsize,
+            (lzham_uint8 *)RSTRING_PTR(src), srcsize, NULL);
+
+    rb_str_unlocktmp(src);
+
+    if (s != LZHAM_DECOMP_STATUS_SUCCESS) {
+        rb_str_resize(dest, 0);
+        extlzham_decode_error(s);
+    }
+
+    rb_str_resize(dest, destsize);
+    rb_str_set_len(dest, destsize);
+
+    return dest;
+}
+
+struct decoder
+{
+    lzham_decompress_state_ptr decoder;
+    VALUE outport;
+    VALUE outbuf;
+};
+
+static void
+dec_mark(struct decoder *p)
+{
+    if (p) {
+        rb_gc_mark(p->outport);
+        rb_gc_mark(p->outbuf);
+    }
+}
+
+static void
+dec_free(struct decoder *p)
+{
+    if (p) {
+        if (p->decoder) {
+            lzham_decompress_deinit(p->decoder);
+        }
+    }
+}
+
+static VALUE
+dec_alloc(VALUE klass)
+{
+    struct decoder *p;
+    VALUE obj = Data_Make_Struct(klass, struct decoder, dec_mark, dec_free, p);
+    return obj;
+}
+
+static inline struct decoder *
+getdecoderp(VALUE obj)
+{
+    struct decoder *p;
+    Data_Get_Struct(obj, struct decoder, p);
+    return p;
+}
+
+static inline struct decoder *
+getdecoder(VALUE obj)
+{
+    struct decoder *p = getdecoderp(obj);
+    if (!p || !p->decoder) {
+        rb_raise(eError,
+                 "not initialized - #<%s:%p>",
+                 rb_obj_classname(obj), (void *)obj);
+    }
+    return p;
+}
+
+/*
+ * call-seq:
+ *  initialize(outport = nil, opts = {})
+ */
+static VALUE
+dec_init(int argc, VALUE argv[], VALUE dec)
+{
+    struct decoder *p = DATA_PTR(dec);
+    if (p->decoder) {
+        rb_raise(eError,
+                 "already initialized - #<%s:%p>",
+                 rb_obj_classname(dec), (void *)dec);
+    }
+
+    VALUE outport, opts;
+    rb_scan_args(argc, argv, "01:", &outport, &opts);
+    if (NIL_P(outport)) { outport = rb_str_buf_new(0); }
+    lzham_decompress_params params = aux_conv_decode_params(opts);
+    p->decoder = lzham_decompress_init(&params);
+    if (!p->decoder) {
+        rb_raise(eError,
+                 "failed lzham_decompress_init - #<%s:%p>",
+                 rb_obj_classname(dec), (void *)dec);
+    }
+
+    p->outbuf = rb_str_buf_new(WORKBUF_SIZE);
+    p->outport = outport;
+
+    return dec;
+}
+
+struct aux_lzham_decompress_nogvl
+{
+    lzham_decompress_state_ptr state;
+    const lzham_uint8 *inbuf;
+    size_t *insize;
+    lzham_uint8 *outbuf;
+    size_t *outsize;
+    lzham_bool flags;
+};
+
+static void *
+aux_lzham_decompress_nogvl(void *px)
+{
+    struct aux_lzham_decompress_nogvl *p = px;
+    return (void *)lzham_decompress(p->state, p->inbuf, p->insize, p->outbuf, p->outsize, p->flags);
+}
+
+static inline lzham_decompress_status_t
+aux_lzham_decompress(lzham_decompress_state_ptr state,
+        const lzham_uint8 *inbuf, size_t *insize,
+        lzham_uint8 *outbuf, size_t *outsize,
+        lzham_bool flags)
+{
+    struct aux_lzham_decompress_nogvl p = {
+        .state = state,
+        .inbuf = inbuf,
+        .insize = insize,
+        .outbuf = outbuf,
+        .outsize = outsize,
+        .flags = flags,
+    };
+
+    return (lzham_decompress_status_t)rb_thread_call_without_gvl(aux_lzham_decompress_nogvl, &p, 0, 0);
+}
+
+struct dec_update_args
+{
+    VALUE decoder;
+    VALUE src;
+    int flush;
+};
+
+static VALUE
+dec_update_protected(struct dec_update_args *args)
+{
+    struct decoder *p = getdecoder(args->decoder);
+    const char *inbuf, *intail;
+
+    if (NIL_P(args->src)) {
+        inbuf = NULL;
+        intail = NULL;
+    } else {
+        inbuf = RSTRING_PTR(args->src);
+        intail = inbuf + RSTRING_LEN(args->src);
+    }
+
+    lzham_decompress_status_t s;
+    do {
+        size_t insize = intail - inbuf;
+        aux_str_reserve(p->outbuf, WORKBUF_SIZE);
+        rb_str_locktmp(p->outbuf);
+        size_t outsize = rb_str_capacity(p->outbuf);
+        s = aux_lzham_decompress(p->decoder,
+                (lzham_uint8 *)inbuf, &insize,
+                (lzham_uint8 *)RSTRING_PTR(p->outbuf), &outsize, args->flush);
+        rb_str_unlocktmp(p->outbuf);
+//fprintf(stderr, "%s:%d:%s: status=%s (%d), insize=%zu, outsize=%zu\n", __FILE__, __LINE__, __func__, extlzham_decode_status_str(s), s, insize, outsize);
+        if (!NIL_P(args->src)) {
+            inbuf += insize;
+        }
+        if (s != LZHAM_DECOMP_STATUS_NOT_FINISHED &&
+            s != LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT &&
+            s != LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT &&
+            s != LZHAM_DECOMP_STATUS_SUCCESS) {
+
+            extlzham_decode_error(s);
+        }
+        if (outsize > 0) {
+            rb_str_set_len(p->outbuf, outsize);
+            rb_funcall2(p->outport, id_op_lshift, 1, &p->outbuf);
+        }
+    } while (inbuf < intail || s == LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT);
+
+    return 0;
+}
+
+static inline void
+dec_update_common(VALUE dec, VALUE src, int flush)
+{
+    struct dec_update_args args = { dec, src, flush };
+    if (NIL_P(src)) {
+        dec_update_protected(&args);
+    } else {
+        rb_str_locktmp(src);
+        int state;
+        rb_protect((VALUE (*)(VALUE))dec_update_protected, (VALUE)&args, &state);
+        rb_str_unlocktmp(src);
+        if (state) {
+            rb_jump_tag(state);
+        }
+    }
+}
+
+/*
+ * call-seq:
+ *  update(src, flush = false) -> self
+ */
+static VALUE
+dec_update(int argc, VALUE argv[], VALUE dec)
+{
+    VALUE src, flush;
+    rb_scan_args(argc, argv, "11", &src, &flush);
+    rb_check_type(src, RUBY_T_STRING);
+    dec_update_common(dec, src, RTEST(flush) ? 1 : 0);
+    return dec;
+}
+
+static VALUE
+dec_finish(VALUE dec)
+{
+    dec_update_common(dec, Qnil, 1);
+    return dec;
+}
+
+static VALUE
+dec_op_lshift(VALUE dec, VALUE src)
+{
+    rb_check_type(src, RUBY_T_STRING);
+    dec_update_common(dec, src, 0);
+    return dec;
+}
+
+static VALUE
+dec_get_outport(VALUE dec)
+{
+    return getdecoder(dec)->outport;
+}
+
+static VALUE
+dec_set_outport(VALUE dec, VALUE outport)
+{
+    return getdecoder(dec)->outport = outport;
+}
+
+void
+extlzham_init_decoder(void)
+{
+    RDOCFAKE(mLZHAM = rb_define_module("LZHAM"));
+    cDecoder = rb_define_class_under(mLZHAM, "Decoder", rb_cObject);
+    rb_include_module(cDecoder, mConsts);
+    rb_define_alloc_func(cDecoder, dec_alloc);
+    rb_define_singleton_method(cDecoder, "decode", RUBY_METHOD_FUNC(dec_s_decode), -1);
+    rb_define_method(cDecoder, "initialize", RUBY_METHOD_FUNC(dec_init), -1);
+    rb_define_method(cDecoder, "update", RUBY_METHOD_FUNC(dec_update), -1);
+    rb_define_method(cDecoder, "finish", RUBY_METHOD_FUNC(dec_finish), 0);
+    rb_define_method(cDecoder, "<<", RUBY_METHOD_FUNC(dec_op_lshift), 1);
+    rb_define_method(cDecoder, "outport", RUBY_METHOD_FUNC(dec_get_outport), 0);
+    rb_define_method(cDecoder, "outport=", RUBY_METHOD_FUNC(dec_set_outport), 1);
+
+}