extlz4 0.2.4.2

data/ext/depend

@@ -0,0 +1,4 @@
+blockapi.o: blockapi.c extlz4.h
+extlz4.o: extlz4.c extlz4.h
+frameapi.o: frameapi.c extlz4.h hashargs.h
+hashargs.o: hashargs.c hashargs.h

data/ext/extconf.rb

@@ -0,0 +1,60 @@
+#!ruby
+#vim: set fileencoding:utf-8
+
+require "mkmf"
+
+module MyExtensions
+  refine Object do
+    # ruby-2.3 から追加されたメソッドの確認と追加
+
+    unless Object.method_defined?(:append_cppflags)
+      def append_cppflags(flags)
+        return false unless try_cppflags(flags)
+        $CPPFLAGS << " #{flags}"
+        true
+      end
+    end
+
+    unless Object.method_defined?(:append_cflags)
+      def append_cflags(flags)
+        return false unless try_cflags(flags)
+        $CFLAGS << " #{flags}"
+        true
+      end
+    end
+
+    unless Object.method_defined?(:append_ldflags)
+      def append_ldflags(flags)
+        return false unless try_ldflags(flags)
+        $LDFLAGS << " #{flags}"
+        true
+      end
+    end
+  end
+end
+
+using MyExtensions
+
+
+# TODO: システムにインストールされた lz4 がある場合、バージョンを確認してより新しければそちらを利用する
+
+append_cppflags "-I$(srcdir)/../contrib/lz4/lib"
+
+if RbConfig::CONFIG["arch"] =~ /mingw/
+  append_ldflags "-static-libgcc"
+else
+  if try_compile(%q(__attribute__ ((visibility("default"))) void testfunc(void) { }))
+    if append_cflags "-fvisibility=hidden"
+      localsymbol = true
+    end
+  end
+end
+
+if localsymbol
+  $defs << %q('-DRBEXT_API=__attribute__ ((visibility("default")))') <<
+           %q(-DRBEXT_VISIBILITY=1)
+else
+  $defs << %q(-DRBEXT_API=)
+end
+
+create_makefile File.join(RUBY_VERSION[/\d+\.\d+/], "extlz4")

data/ext/extlz4.c

@@ -0,0 +1,69 @@
+#include "extlz4.h"
+#include <lz4.h>
+
+VALUE extlz4_eError;
+
+/*
+ * version information
+ */
+
+static VALUE
+libver_major(VALUE ver)
+{
+    return INT2FIX(LZ4_VERSION_MAJOR);
+}
+
+static VALUE
+libver_minor(VALUE ver)
+{
+    return INT2FIX(LZ4_VERSION_MINOR);
+}
+
+static VALUE
+libver_release(VALUE ver)
+{
+    return INT2FIX(LZ4_VERSION_RELEASE);
+}
+
+static VALUE
+libver_to_s(VALUE ver)
+{
+    return rb_sprintf("%d.%d.%d", LZ4_VERSION_MAJOR, LZ4_VERSION_MINOR, LZ4_VERSION_RELEASE);
+}
+
+/*
+ * initialize library
+ */
+
+VALUE extlz4_mLZ4;
+
+RBEXT_API void
+Init_extlz4(void)
+{
+    extlz4_mLZ4 = rb_define_module("LZ4");
+
+    /*
+     * Document-const: LZ4::LIBVERSION
+     *
+     * This constant value means api version number of original lz4 library as array'd integers.
+     *
+     * And it's has any singleton methods, so they are +#major+, +#minor+, +#release+ and +#to_s+.
+     *
+     * 実体が配列である理由は、比較を行いやすくすることを意図しているためです。
+     */
+    VALUE ver = rb_ary_new3(3,
+            INT2FIX(LZ4_VERSION_MAJOR),
+            INT2FIX(LZ4_VERSION_MINOR),
+            INT2FIX(LZ4_VERSION_RELEASE));
+    rb_define_singleton_method(ver, "major", libver_major, 0);
+    rb_define_singleton_method(ver, "minor", libver_minor, 0);
+    rb_define_singleton_method(ver, "release", libver_release, 0);
+    rb_define_singleton_method(ver, "to_s", libver_to_s, 0);
+    rb_obj_freeze(ver);
+    rb_define_const(extlz4_mLZ4, "LIBVERSION", ver);
+
+    extlz4_eError = rb_define_class_under(extlz4_mLZ4, "Error", rb_eRuntimeError);
+
+    extlz4_init_blockapi();
+    extlz4_init_frameapi();
+}

data/ext/extlz4.h

@@ -0,0 +1,109 @@
+#ifndef EXTLZ4_H
+#define EXTLZ4_H 1
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#ifndef RB_OBJ_FROZEN
+#   define RB_OBJ_FROZEN    OBJ_FROZEN
+#endif
+
+extern VALUE extlz4_mLZ4;      /* module LZ4 */
+extern VALUE extlz4_eError;    /* class LZ4::Error < ::RuntimeError */
+
+extern void extlz4_init_blockapi(void);
+extern void extlz4_init_frameapi(void);
+
+#define AUX_FUNCALL(RECV, METHOD, ...)                          \
+    ({                                                          \
+        VALUE args__[] = { __VA_ARGS__ };                       \
+        rb_funcall2((RECV), (METHOD),                           \
+                sizeof(args__) / sizeof(args__[0]), args__);    \
+    })                                                          \
+
+static inline void *
+aux_thread_call_without_gvl(void *(*func)(va_list *), void (*cancel)(va_list *), ...)
+{
+    va_list va1, va2;
+    va_start(va1, cancel);
+    va_start(va2, cancel);
+    void *s = rb_thread_call_without_gvl((void *(*)(void *))func, &va1, (void (*)(void *))cancel, &va2);
+    va_end(va1);
+    va_end(va2);
+    return s;
+}
+
+static inline void
+aux_str_reserve(VALUE str, size_t size)
+{
+    if (rb_str_capacity(str) < size) {
+        rb_str_modify_expand(str, size - RSTRING_LEN(str));
+        if (rb_str_capacity(str) < size) {
+            errno = ENOMEM;
+            rb_sys_fail("output buffer is not reallocated");
+        }
+    } else {
+        rb_str_modify(str);
+    }
+}
+/*
+ * rb_str_drop_bytes は共有オブジェクトを生成して返すので、
+ * それとは違う、破壊的メソッドとしての関数。
+ */
+static inline VALUE
+aux_str_drop_bytes(VALUE str, size_t dropsize)
+{
+    char *p;
+    size_t size;
+    RSTRING_GETMEM(str, p, size);
+    if (dropsize > size) {
+        dropsize = size;
+    } else {
+        memmove(p, p + dropsize, size - dropsize);
+    }
+    rb_str_set_len(str, size - dropsize);
+    return str;
+}
+
+static inline char *
+aux_str_getmem(VALUE str, char **ptr, size_t *size)
+{
+    if (rb_type_p(str, RUBY_T_STRING)) {
+        RSTRING_GETMEM(str, *ptr, *size);
+    } else {
+        *ptr = NULL;
+        *size = 0;
+    }
+
+    return *ptr;
+}
+
+static inline void *
+checkref(VALUE obj, void *p)
+{
+    if (!p) {
+        rb_raise(rb_eRuntimeError,
+                "not initialized object or invalid reference - #<%s:%p>",
+                rb_obj_classname(obj), (void *)obj);
+    }
+    return p;
+}
+
+static inline void *
+getrefp(VALUE obj, const rb_data_type_t *type)
+{
+    void *p;
+    TypedData_Get_Struct(obj, void, type, p);
+    return p;
+}
+
+static inline void *
+getref(VALUE obj, const rb_data_type_t *type)
+{
+    return checkref(obj, getrefp(obj, type));
+}
+
+#endif /* !EXTLZ4_H */

data/ext/frameapi.c

@@ -0,0 +1,780 @@
+#include "extlz4.h"
+#include <lz4frame.h>
+#include <lz4frame_static.h>
+#include "hashargs.h"
+
+static ID id_op_lshift;
+static ID id_read;
+
+enum {
+    FLAG_LEGACY = 1 << 0,
+    FLAG_BLOCK_LINK = 1 << 1,
+    FLAG_BLOCK_SUM = 1 << 2,
+    FLAG_STREAM_SIZE = 1 << 3,
+    FLAG_STREAM_SUM = 1 << 4,
+
+    WORK_BUFFER_SIZE = 256 * 1024, /* 256 KiB */
+    AUX_LZ4FRAME_HEADER_MAX = 19,
+
+    AUX_LZ4F_BLOCK_SIZE_MAX = 4 * 1024 * 1024, /* 4 MiB : maximum block size of LZ4 Frame */
+    AUX_LZ4F_FINISH_SIZE = 16, /* from lz4frame.c */
+
+    AUX_LZ4F_PARTIAL_READ_SIZE = 256 * 1024, /* 256 KiB */
+};
+
+/*** auxiliary and common functions ***/
+
+static inline void
+aux_lz4f_check_error(size_t err)
+{
+    if (LZ4F_isError(err)) {
+        rb_raise(extlz4_eError,
+                 "%s (0x%04x)",
+                 LZ4F_getErrorName(err), -(int)err);
+    }
+}
+
+static void *
+aux_LZ4F_compressUpdate_nogvl(va_list *p)
+{
+    LZ4F_compressionContext_t encoder = va_arg(*p, LZ4F_compressionContext_t);
+    char *dest = va_arg(*p, char *);
+    size_t destsize = va_arg(*p, size_t);
+    const char *src = va_arg(*p, const char *);
+    size_t srcsize = va_arg(*p, size_t);
+    LZ4F_compressOptions_t *opts = va_arg(*p, LZ4F_compressOptions_t *);
+
+    return (void *)LZ4F_compressUpdate(encoder, dest, destsize, src, srcsize, opts);
+}
+
+static size_t
+aux_LZ4F_compressUpdate(LZ4F_compressionContext_t encoder,
+        char *dest, size_t destsize, const char *src, size_t srcsize,
+        LZ4F_compressOptions_t *opts)
+{
+    return (size_t)aux_thread_call_without_gvl(aux_LZ4F_compressUpdate_nogvl, NULL,
+            encoder, dest, destsize, src, srcsize, opts);
+}
+
+static int
+aux_frame_level(const LZ4F_preferences_t *p)
+{
+    return p->compressionLevel;
+}
+
+static int
+aux_frame_blocksize(const LZ4F_frameInfo_t *info)
+{
+    int bsid = info->blockSizeID;
+    if (bsid == 0) {
+        bsid = LZ4F_max4MB;
+    }
+    return 1 << (bsid * 2 + 8);
+}
+
+static int
+aux_frame_blocklink(const LZ4F_frameInfo_t *info)
+{
+    return info->blockMode == LZ4F_blockLinked;
+}
+
+static int
+aux_frame_checksum(const LZ4F_frameInfo_t *info)
+{
+    return info->contentChecksumFlag == LZ4F_contentChecksumEnabled;
+}
+
+/*** class LZ4::Encoder ***/
+
+struct encoder
+{
+    VALUE outport;
+    VALUE workbuf;
+    LZ4F_preferences_t prefs;
+    LZ4F_compressionContext_t encoder;
+};
+
+static void
+encoder_mark(void *pp)
+{
+    struct encoder *p = pp;
+    rb_gc_mark(p->outport);
+    rb_gc_mark(p->workbuf);
+}
+
+static void
+encoder_free(void *pp)
+{
+    struct encoder *p = pp;
+    if (p->encoder) {
+        LZ4F_freeCompressionContext(p->encoder);
+    }
+    memset(p, 0, sizeof(*p));
+    xfree(p);
+}
+
+static const rb_data_type_t encoder_type = {
+    .wrap_struct_name = "extlz4.LZ4.Encoder",
+    .function.dmark = encoder_mark,
+    .function.dfree = encoder_free,
+    /* .function.dsize = encoder_size, */
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+fenc_alloc(VALUE mod)
+{
+    struct encoder *p;
+    VALUE obj = TypedData_Make_Struct(mod, struct encoder, &encoder_type, p);
+    p->outport = Qnil;
+    p->workbuf = Qnil;
+    return obj;
+}
+
+static inline int
+fenc_init_args_blocksize(size_t size)
+{
+    if (size == 0) {
+        return LZ4F_default;
+    } else if (size <= 64 * 1024) {
+        return LZ4F_max64KB;
+    } else if (size <= 256 * 1024) {
+        return LZ4F_max256KB;
+    } else if (size <= 1 * 1024 * 1024) {
+        return LZ4F_max1MB;
+    } else {
+        return LZ4F_max4MB;
+    }
+}
+
+static inline void
+fenc_init_args(int argc, VALUE argv[], VALUE *outport, LZ4F_preferences_t *prefs)
+{
+    VALUE level, opts;
+    rb_scan_args(argc, argv, "02:", outport, &level, &opts);
+
+    memset(prefs, 0, sizeof(*prefs));
+
+    if (NIL_P(*outport)) {
+        *outport = rb_str_buf_new(0);
+    }
+
+    prefs->compressionLevel = NIL_P(level) ? 1 : NUM2INT(level);
+
+    if (!NIL_P(opts)) {
+        VALUE blocksize, blocklink, checksum;
+        RBX_SCANHASH(opts, Qnil,
+                RBX_SCANHASH_ARGS("blocksize", &blocksize, Qnil),
+                RBX_SCANHASH_ARGS("blocklink", &blocklink, Qfalse),
+                RBX_SCANHASH_ARGS("checksum", &checksum, Qtrue));
+        // prefs->autoFlush = TODO;
+        prefs->frameInfo.blockSizeID = NIL_P(blocksize) ? LZ4F_default : fenc_init_args_blocksize(NUM2INT(blocksize));
+        prefs->frameInfo.blockMode = RTEST(blocklink) ? LZ4F_blockLinked : LZ4F_blockIndependent;
+        prefs->frameInfo.contentChecksumFlag = RTEST(checksum) ? LZ4F_contentChecksumEnabled : LZ4F_noContentChecksum;
+    } else {
+        prefs->frameInfo.blockSizeID = LZ4F_default;
+        prefs->frameInfo.blockMode = LZ4F_blockIndependent;
+        prefs->frameInfo.contentChecksumFlag = LZ4F_contentChecksumEnabled;
+    }
+}
+
+static struct encoder *
+getencoderp(VALUE enc)
+{
+    return getrefp(enc, &encoder_type);
+}
+
+static struct encoder *
+getencoder(VALUE enc)
+{
+    return getref(enc, &encoder_type);
+}
+
+/*
+ * call-seq:
+ *  initialize(outport = "".b, level = 1, blocksize: nil, blocklink: false, checksum: true)
+ */
+static VALUE
+fenc_init(int argc, VALUE argv[], VALUE enc)
+{
+    struct encoder *p = getencoder(enc);
+    VALUE outport;
+    fenc_init_args(argc, argv, &outport, &p->prefs);
+
+    LZ4F_errorCode_t status;
+    status = LZ4F_createCompressionContext(&p->encoder, LZ4F_VERSION);
+    aux_lz4f_check_error(status);
+    p->workbuf = rb_str_buf_new(AUX_LZ4F_BLOCK_SIZE_MAX);
+    size_t s = LZ4F_compressBegin(p->encoder, RSTRING_PTR(p->workbuf), rb_str_capacity(p->workbuf), &p->prefs);
+    aux_lz4f_check_error(s);
+    rb_str_set_len(p->workbuf, s);
+    rb_funcall2(outport, id_op_lshift, 1, &p->workbuf);
+    p->outport = outport;
+    rb_obj_infect(p->outport, enc);
+    return enc;
+}
+
+static inline void
+fenc_update(struct encoder *p, VALUE src, LZ4F_compressOptions_t *opts)
+{
+    rb_check_type(src, RUBY_T_STRING);
+    const char *srcp = RSTRING_PTR(src);
+    const char *srctail = srcp + RSTRING_LEN(src);
+    while (srcp < srctail) {
+        size_t srcsize = srctail - srcp;
+        if (srcsize > AUX_LZ4F_BLOCK_SIZE_MAX) { srcsize = AUX_LZ4F_BLOCK_SIZE_MAX; }
+        size_t destsize = LZ4F_compressBound(srcsize, &p->prefs);
+        aux_str_reserve(p->workbuf, destsize);
+        char *destp = RSTRING_PTR(p->workbuf);
+        size_t size = aux_LZ4F_compressUpdate(p->encoder, destp, destsize, srcp, srcsize, opts);
+        aux_lz4f_check_error(size);
+        rb_str_set_len(p->workbuf, size);
+        rb_funcall2(p->outport, id_op_lshift, 1, &p->workbuf);
+        srcp += srcsize;
+    }
+}
+
+/*
+ * call-seq:
+ *  write(src) -> self
+ */
+static VALUE
+fenc_write(int argc, VALUE argv[], VALUE enc)
+{
+    struct encoder *p = getencoder(enc);
+    VALUE src;
+    rb_scan_args(argc, argv, "1", &src);
+    rb_obj_infect(enc, src);
+    rb_obj_infect(enc, p->workbuf);
+    rb_obj_infect(p->outport, enc);
+    fenc_update(p, src, NULL);
+    return enc;
+}
+
+static VALUE
+fenc_push(VALUE enc, VALUE src)
+{
+    struct encoder *p = getencoder(enc);
+    rb_obj_infect(enc, src);
+    rb_obj_infect(enc, p->workbuf);
+    rb_obj_infect(p->outport, enc);
+    fenc_update(p, src, NULL);
+    return enc;
+}
+
+static VALUE
+fenc_flush(VALUE enc)
+{
+    struct encoder *p = getencoder(enc);
+    size_t destsize = AUX_LZ4F_BLOCK_SIZE_MAX + AUX_LZ4F_FINISH_SIZE;
+    aux_str_reserve(p->workbuf, destsize);
+    char *destp = RSTRING_PTR(p->workbuf);
+    size_t size = LZ4F_flush(p->encoder, destp, destsize, NULL);
+    aux_lz4f_check_error(size);
+    rb_str_set_len(p->workbuf, size);
+    rb_funcall2(p->outport, id_op_lshift, 1, &p->workbuf);
+
+    return enc;
+}
+
+static VALUE
+fenc_close(VALUE enc)
+{
+    struct encoder *p = getencoder(enc);
+    size_t destsize = AUX_LZ4F_BLOCK_SIZE_MAX + AUX_LZ4F_FINISH_SIZE;
+    aux_str_reserve(p->workbuf, destsize);
+    char *destp = RSTRING_PTR(p->workbuf);
+    size_t size = LZ4F_compressEnd(p->encoder, destp, destsize, NULL);
+    aux_lz4f_check_error(size);
+    rb_str_set_len(p->workbuf, size);
+    rb_funcall2(p->outport, id_op_lshift, 1, &p->workbuf);
+
+    return enc;
+}
+
+static VALUE
+fenc_getoutport(VALUE enc)
+{
+    return getencoder(enc)->outport;
+}
+
+static VALUE
+fenc_setoutport(VALUE enc, VALUE outport)
+{
+    return getencoder(enc)->outport = outport;
+}
+
+static VALUE
+fenc_prefs_level(VALUE enc)
+{
+    return INT2NUM(aux_frame_level(&getencoder(enc)->prefs));
+}
+
+static int
+fenc_blocksize(struct encoder *p)
+{
+    return aux_frame_blocksize(&p->prefs.frameInfo);
+}
+
+static VALUE
+fenc_prefs_blocksize(VALUE enc)
+{
+    return INT2NUM(fenc_blocksize(getencoder(enc)));
+}
+
+static VALUE
+fenc_prefs_blocklink(VALUE enc)
+{
+    return aux_frame_blocklink(&getencoder(enc)->prefs.frameInfo) ? Qtrue : Qfalse;
+}
+
+static VALUE
+fenc_prefs_checksum(VALUE enc)
+{
+    return aux_frame_checksum(&getencoder(enc)->prefs.frameInfo) ? Qtrue : Qfalse;
+}
+
+static VALUE
+fenc_inspect(VALUE enc)
+{
+    struct encoder *p = getencoderp(enc);
+    if (p) {
+        return rb_sprintf("#<%s:%p outport=#<%s:%p>, level=%d, blocksize=%d, blocklink=%s, checksum=%s>",
+                rb_obj_classname(enc), (void *)enc,
+                rb_obj_classname(p->outport), (void *)p->outport,
+                p->prefs.compressionLevel, fenc_blocksize(p),
+                aux_frame_blocklink(&p->prefs.frameInfo) ? "true" : "false",
+                aux_frame_checksum(&p->prefs.frameInfo) ? "true" : "false");
+    } else {
+        return rb_sprintf("#<%s:%p **INVALID REFERENCE**>",
+                rb_obj_classname(enc), (void *)enc);
+    }
+}
+
+/*** class LZ4::Decoder ***/
+
+struct decoder
+{
+    VALUE inport;
+    VALUE readbuf;  /* read buffer from inport */
+    VALUE inbuf;
+    VALUE outbuf;
+    size_t outoff;  /* offset in outbuf */
+    size_t status;  /* status code of LZ4F_decompress */
+    LZ4F_frameInfo_t info;
+    LZ4F_decompressionContext_t decoder;
+};
+
+static void
+decoder_mark(void *pp)
+{
+    struct decoder *p = pp;
+    rb_gc_mark(p->inport);
+    rb_gc_mark(p->readbuf);
+    rb_gc_mark(p->inbuf);
+    rb_gc_mark(p->outbuf);
+}
+
+static void
+decoder_free(void *pp)
+{
+    struct decoder *p = pp;
+    if (p->decoder) {
+        LZ4F_freeDecompressionContext(p->decoder);
+    }
+    memset(p, 0, sizeof(*p));
+    xfree(p);
+}
+
+static const rb_data_type_t decoder_type = {
+    .wrap_struct_name = "extlz4.LZ4.Decoder",
+    .function.dmark = decoder_mark,
+    .function.dfree = decoder_free,
+    /* .function.dsize = decoder_size, */
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+fdec_alloc(VALUE mod)
+{
+    struct decoder *p;
+    VALUE obj = TypedData_Make_Struct(mod, struct decoder, &decoder_type, p);
+    p->inport = Qnil;
+    p->readbuf = Qnil;
+    p->inbuf = Qnil;
+    p->outbuf = Qnil;
+    p->outoff = 0;
+    p->status = 0;
+    return obj;
+}
+
+static struct decoder *
+getdecoderp(VALUE dec)
+{
+    return getrefp(dec, &decoder_type);
+}
+
+static struct decoder *
+getdecoder(VALUE dec)
+{
+    return getref(dec, &decoder_type);
+}
+
+static inline VALUE
+aux_read(VALUE obj, size_t size, VALUE buf)
+{
+    if (NIL_P(buf) || RB_OBJ_FROZEN(buf)) {
+        buf = rb_str_buf_new(size);
+    }
+
+    if (NIL_P(AUX_FUNCALL(obj, id_read, SIZET2NUM(size), buf))) {
+        return Qnil;
+    } else {
+        if (RSTRING_LEN(buf) > size) {
+            rb_raise(rb_eRuntimeError, "most read (%d, but expected to %d)", (int)RSTRING_LEN(buf), (int)size);
+        }
+        return buf;
+    }
+}
+
+/*
+ * call-seq:
+ *  initialize(inport) -> self
+ *
+ * [inport]
+ *  An I/O (liked) object for data read from LZ4 Frame.
+ *
+ *  This object need +.read+ method.
+ */
+static VALUE
+fdec_init(int argc, VALUE argv[], VALUE dec)
+{
+    struct decoder *p = getdecoder(dec);
+    VALUE inport;
+    //VALUE readblocksize;
+    rb_scan_args(argc, argv, "1", &inport);
+    LZ4F_errorCode_t err = LZ4F_createDecompressionContext(&p->decoder, LZ4F_VERSION);
+    aux_lz4f_check_error(err);
+    rb_obj_infect(dec, inport);
+    p->inport = inport;
+    p->readbuf = rb_str_buf_new(0);
+    char *readp;
+    size_t readsize;
+    size_t zero = 0;
+    size_t s = 4; /* magic number size of lz4 frame */
+    int i;
+    for (i = 0; i < 2; i ++) {
+        /*
+         * first step: check magic number
+         * second step: check frame information
+         */
+        aux_read(inport, s, p->readbuf);
+        aux_str_getmem(p->readbuf, &readp, &readsize);
+        if (!readp || readsize < s) {
+            rb_raise(extlz4_eError,
+                     "unexpected EOF (read error) - #<%s:%p>",
+                     rb_obj_classname(inport), (const void *)inport);
+        }
+        s = LZ4F_decompress(p->decoder, NULL, &zero, readp, &readsize, NULL);
+        aux_lz4f_check_error(s);
+    }
+    p->status = s;
+    s = LZ4F_getFrameInfo(p->decoder, &p->info, NULL, &zero);
+    aux_lz4f_check_error(s);
+    p->outbuf = rb_str_tmp_new(1 << (8 + p->info.blockSizeID * 2));
+    rb_str_set_len(p->outbuf, 0);
+
+    return dec;
+}
+
+static inline void
+fdec_read_args(int argc, VALUE argv[], size_t *size, VALUE *buf)
+{
+    switch (argc) {
+    case 0:
+        *size = ~(size_t)0;
+        *buf = rb_str_buf_new(0);
+        break;
+    case 1:
+        *size = NUM2SIZET(argv[0]);
+        *buf = rb_str_buf_new(*size);
+        break;
+    case 2:
+        *size = NUM2SIZET(argv[0]);
+        *buf = argv[1];
+        rb_check_type(*buf, RUBY_T_STRING);
+        rb_str_modify(*buf);
+        rb_str_set_len(*buf, 0);
+        break;
+    default:
+        rb_error_arity(argc, 0, 2);
+    }
+}
+
+static void
+fdec_read_fetch(VALUE dec, struct decoder *p)
+{
+    if (NIL_P(p->inbuf)) {
+        p->inbuf = rb_str_tmp_new(256);
+        rb_str_set_len(p->inbuf, 0);
+    }
+
+    while (RSTRING_LEN(p->inbuf) < p->status) {
+        p->readbuf = aux_read(p->inport, p->status - RSTRING_LEN(p->inbuf), p->readbuf);
+        if (NIL_P(p->readbuf)) {
+            rb_raise(rb_eRuntimeError,
+                    "unexpected EOF (read error) - #<%s:%p>",
+                    rb_obj_classname(p->inport), (const void *)p->inport);
+        }
+        rb_check_type(p->readbuf, RUBY_T_STRING);
+        rb_str_buf_cat(p->inbuf, RSTRING_PTR(p->readbuf), RSTRING_LEN(p->readbuf));
+    }
+
+    char *inp;
+    size_t insize;
+    aux_str_getmem(p->inbuf, &inp, &insize);
+    char *outp = RSTRING_PTR(p->outbuf);
+    size_t outsize = rb_str_capacity(p->outbuf);
+    p->status = LZ4F_decompress(p->decoder, outp, &outsize, inp, &insize, NULL);
+    aux_lz4f_check_error(p->status);
+    memmove(RSTRING_PTR(p->inbuf), RSTRING_PTR(p->inbuf) + insize, RSTRING_LEN(p->inbuf) - insize);
+    rb_str_set_len(p->inbuf, RSTRING_LEN(p->inbuf) - insize);
+    rb_str_set_len(p->outbuf, outsize);
+    p->outoff = 0;
+    rb_thread_check_ints();
+}
+
+static size_t
+fdec_read_decode(VALUE dec, struct decoder *p, char *dest, size_t size)
+{
+    const char *const desthead = dest;
+    uintptr_t desttail = (uintptr_t)dest + size;
+
+    while ((uintptr_t)dest < desttail) {
+        if ((ssize_t)p->status < 1 && RSTRING_LEN(p->outbuf) < 1) {
+            break;
+        }
+
+        if (p->status > 0 && p->outoff >= RSTRING_LEN(p->outbuf)) {
+            fdec_read_fetch(dec, p);
+        }
+
+        if (size < RSTRING_LEN(p->outbuf) - p->outoff) {
+            memcpy(dest, RSTRING_PTR(p->outbuf) + p->outoff, size);
+            p->outoff += size;
+            dest += size;
+            break;
+        } else {
+            size_t s = RSTRING_LEN(p->outbuf) - p->outoff;
+            memcpy(dest, RSTRING_PTR(p->outbuf) + p->outoff, s);
+            p->outoff = 0;
+            rb_str_set_len(p->outbuf, 0);
+            dest += s;
+            size -= s;
+        }
+    }
+
+    return dest - desthead;
+}
+
+/*
+ * call-seq:
+ *  read -> string
+ *  read(size) -> string
+ *  read(size, buffer) -> buffer
+ */
+static VALUE
+fdec_read(int argc, VALUE argv[], VALUE dec)
+{
+    struct decoder *p = getdecoder(dec);
+    size_t size;
+    VALUE dest;
+    fdec_read_args(argc, argv, &size, &dest);
+    if (size == 0) {
+        rb_obj_infect(dest, dec);
+        return dest;
+    }
+
+    if (p->status == 0) {
+        return Qnil;
+    }
+
+    if ((ssize_t)size > 0) {
+        char *destp = RSTRING_PTR(dest);
+        size_t destsize = size;
+        destsize = fdec_read_decode(dec, p, destp, destsize);
+        rb_str_set_len(dest, destsize);
+    } else {
+        const size_t tmpsize = 4 * 1024 * 1024;
+        VALUE tmpbuf = rb_str_tmp_new(tmpsize);
+        char *tmp = RSTRING_PTR(tmpbuf);
+        size_t s;
+        rb_str_set_len(dest, 0);
+        while ((s = fdec_read_decode(dec, p, tmp, tmpsize)) > 0) {
+            rb_str_buf_cat(dest, tmp, s);
+        }
+        rb_str_resize(tmpbuf, 0);
+    }
+
+    rb_obj_infect(dest, dec);
+
+    if (RSTRING_LEN(dest) > 0) {
+        return dest;
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+ * call-seq:
+ *  getc -> String | nil
+ *
+ * Read one byte character.
+ */
+static VALUE
+fdec_getc(VALUE dec)
+{
+    struct decoder *p = getdecoder(dec);
+
+    if (p->status == 0) {
+        return Qnil;
+    }
+
+    char ch;
+    size_t s = fdec_read_decode(dec, p, &ch, 1);
+    if (s > 0) {
+        VALUE v = rb_str_new(&ch, 1);
+        rb_obj_infect(v, dec);
+        return v;
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+ * call-seq:
+ *  getbyte -> Integer | nil
+ *
+ * Read one byte code integer.
+ */
+static VALUE
+fdec_getbyte(VALUE dec)
+{
+    struct decoder *p = getdecoder(dec);
+
+    char ch;
+    size_t s = fdec_read_decode(dec, p, &ch, 1);
+    if (s > 0) {
+        return INT2FIX(ch);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+fdec_close(VALUE dec)
+{
+    struct decoder *p = getdecoder(dec);
+    p->status = 0;
+    // TODO: destroy decoder
+    return dec;
+}
+
+static VALUE
+fdec_eof(VALUE dec)
+{
+    struct decoder *p = getdecoder(dec);
+    if (p->status == 0) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE
+fdec_inport(VALUE dec)
+{
+    return getdecoder(dec)->inport;
+}
+
+static int
+fdec_blocksize(struct decoder *p)
+{
+    return aux_frame_blocksize(&p->info);
+}
+
+static VALUE
+fdec_prefs_blocksize(VALUE dec)
+{
+    return INT2NUM(fdec_blocksize(getdecoder(dec)));
+}
+
+static VALUE
+fdec_prefs_blocklink(VALUE dec)
+{
+    return aux_frame_blocklink(&getdecoder(dec)->info) ? Qtrue : Qfalse;
+}
+
+static VALUE
+fdec_prefs_checksum(VALUE dec)
+{
+    return aux_frame_checksum(&getdecoder(dec)->info) ? Qtrue : Qfalse;
+}
+
+static VALUE
+fdec_inspect(VALUE dec)
+{
+    struct decoder *p = getdecoderp(dec);
+    if (p) {
+        return rb_sprintf("#<%s:%p inport=#<%s:%p>, blocksize=%d, blocklink=%s, checksum=%s>",
+                rb_obj_classname(dec), (void *)dec,
+                rb_obj_classname(p->inport), (void *)p->inport,
+                fdec_blocksize(p),
+                aux_frame_blocklink(&p->info) ? "true" : "false",
+                aux_frame_checksum(&p->info) ? "true" : "false");
+    } else {
+        return rb_sprintf("#<%s:%p **INVALID REFERENCE**>",
+                rb_obj_classname(dec), (void *)dec);
+    }
+}
+
+/*** setup for LZ4::Encoder and LZ4::Decoder ***/
+
+void
+extlz4_init_frameapi(void)
+{
+    id_op_lshift = rb_intern("<<");
+    id_read = rb_intern("read");
+
+    VALUE cEncoder = rb_define_class_under(extlz4_mLZ4, "Encoder", rb_cObject);
+    rb_define_alloc_func(cEncoder, fenc_alloc);
+    rb_define_method(cEncoder, "initialize", RUBY_METHOD_FUNC(fenc_init), -1);
+    rb_define_method(cEncoder, "write", RUBY_METHOD_FUNC(fenc_write), -1);
+    rb_define_method(cEncoder, "<<", RUBY_METHOD_FUNC(fenc_push), 1);
+    rb_define_method(cEncoder, "flush", RUBY_METHOD_FUNC(fenc_flush), 0);
+    rb_define_method(cEncoder, "close", RUBY_METHOD_FUNC(fenc_close), 0);
+    rb_define_alias(cEncoder, "finish", "close");
+    rb_define_method(cEncoder, "outport", RUBY_METHOD_FUNC(fenc_getoutport), 0);
+    rb_define_method(cEncoder, "outport=", RUBY_METHOD_FUNC(fenc_setoutport), 1);
+    rb_define_method(cEncoder, "prefs_level", RUBY_METHOD_FUNC(fenc_prefs_level), 0);
+    rb_define_method(cEncoder, "prefs_blocksize", RUBY_METHOD_FUNC(fenc_prefs_blocksize), 0);
+    rb_define_method(cEncoder, "prefs_blocklink", RUBY_METHOD_FUNC(fenc_prefs_blocklink), 0);
+    rb_define_method(cEncoder, "prefs_checksum", RUBY_METHOD_FUNC(fenc_prefs_checksum), 0);
+    rb_define_method(cEncoder, "inspect", RUBY_METHOD_FUNC(fenc_inspect), 0);
+
+    VALUE cDecoder = rb_define_class_under(extlz4_mLZ4, "Decoder", rb_cObject);
+    rb_define_alloc_func(cDecoder, fdec_alloc);
+    rb_define_method(cDecoder, "initialize", RUBY_METHOD_FUNC(fdec_init), -1);
+    rb_define_method(cDecoder, "read", RUBY_METHOD_FUNC(fdec_read), -1);
+    rb_define_method(cDecoder, "getc", RUBY_METHOD_FUNC(fdec_getc), 0);
+    rb_define_method(cDecoder, "getbyte", RUBY_METHOD_FUNC(fdec_getbyte), 0);
+    rb_define_method(cDecoder, "close", RUBY_METHOD_FUNC(fdec_close), 0);
+    rb_define_alias(cDecoder, "finish", "close");
+    rb_define_method(cDecoder, "eof", RUBY_METHOD_FUNC(fdec_eof), 0);
+    rb_define_method(cDecoder, "inport", RUBY_METHOD_FUNC(fdec_inport), 0);
+    rb_define_alias(cDecoder, "eof?", "eof");
+    rb_define_method(cDecoder, "prefs_blocksize", RUBY_METHOD_FUNC(fdec_prefs_blocksize), 0);
+    rb_define_method(cDecoder, "prefs_blocklink", RUBY_METHOD_FUNC(fdec_prefs_blocklink), 0);
+    rb_define_method(cDecoder, "prefs_checksum", RUBY_METHOD_FUNC(fdec_prefs_checksum), 0);
+    rb_define_method(cDecoder, "inspect", RUBY_METHOD_FUNC(fdec_inspect), 0);
+}