extlz4 0.2.4.2

data/contrib/lz4/lib/xxhash.h

@@ -0,0 +1,293 @@
+/*
+   xxHash - Extremely Fast Hash algorithm
+   Header File
+   Copyright (C) 2012-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - xxHash source repository : https://github.com/Cyan4973/xxHash
+*/
+
+/* Notice extracted from xxHash homepage :
+
+xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
+It also successfully passes all tests from the SMHasher suite.
+
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
+
+Name            Speed       Q.Score   Author
+xxHash          5.4 GB/s     10
+CrapWow         3.2 GB/s      2       Andrew
+MumurHash 3a    2.7 GB/s     10       Austin Appleby
+SpookyHash      2.0 GB/s     10       Bob Jenkins
+SBox            1.4 GB/s      9       Bret Mulvey
+Lookup3         1.2 GB/s      9       Bob Jenkins
+SuperFastHash   1.2 GB/s      1       Paul Hsieh
+CityHash64      1.05 GB/s    10       Pike & Alakuijala
+FNV             0.55 GB/s     5       Fowler, Noll, Vo
+CRC32           0.43 GB/s     9
+MD5-32          0.33 GB/s    10       Ronald L. Rivest
+SHA1-32         0.28 GB/s    10
+
+Q.Score is a measure of quality of the hash function.
+It depends on successfully passing SMHasher test set.
+10 is a perfect score.
+
+A 64-bits version, named XXH64, is available since r35.
+It offers much better speed, but for 64-bits applications only.
+Name     Speed on 64 bits    Speed on 32 bits
+XXH64       13.8 GB/s            1.9 GB/s
+XXH32        6.8 GB/s            6.0 GB/s
+*/
+
+#ifndef XXHASH_H_5627135585666179
+#define XXHASH_H_5627135585666179 1
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* ****************************
+*  Definitions
+******************************/
+#include <stddef.h>   /* size_t */
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+
+
+/* ****************************
+*  API modifier
+******************************/
+/** XXH_PRIVATE_API
+*   This is useful to include xxhash functions in `static` mode
+*   in order to inline them, and remove their symbol from the public list.
+*   Methodology :
+*     #define XXH_PRIVATE_API
+*     #include "xxhash.h"
+*   `xxhash.c` is automatically included.
+*   It's not useful to compile and link it as a separate module.
+*/
+#ifdef XXH_PRIVATE_API
+#  ifndef XXH_STATIC_LINKING_ONLY
+#    define XXH_STATIC_LINKING_ONLY
+#  endif
+#  if defined(__GNUC__)
+#    define XXH_PUBLIC_API static __inline __attribute__((unused))
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#    define XXH_PUBLIC_API static inline
+#  elif defined(_MSC_VER)
+#    define XXH_PUBLIC_API static __inline
+#  else
+#    define XXH_PUBLIC_API static   /* this version may generate warnings for unused static functions; disable the relevant warning */
+#  endif
+#else
+#  define XXH_PUBLIC_API   /* do nothing */
+#endif /* XXH_PRIVATE_API */
+
+/*!XXH_NAMESPACE, aka Namespace Emulation :
+
+If you want to include _and expose_ xxHash functions from within your own library,
+but also want to avoid symbol collisions with other libraries which may also include xxHash,
+
+you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
+with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
+
+Note that no change is required within the calling program as long as it includes `xxhash.h` :
+regular symbol name will be automatically translated by this header.
+*/
+#ifdef XXH_NAMESPACE
+#  define XXH_CAT(A,B) A##B
+#  define XXH_NAME2(A,B) XXH_CAT(A,B)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
+#endif
+
+
+/* *************************************
+*  Version
+***************************************/
+#define XXH_VERSION_MAJOR    0
+#define XXH_VERSION_MINOR    6
+#define XXH_VERSION_RELEASE  2
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+
+
+/*-**********************************************************************
+*  32-bits hash
+************************************************************************/
+typedef unsigned int       XXH32_hash_t;
+
+/*! XXH32() :
+    Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
+    The memory between input & input+length must be valid (allocated and read-accessible).
+    "seed" can be used to alter the result predictably.
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
+
+/*======   Streaming   ======*/
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
+
+/*
+These functions generate the xxHash of an input provided in multiple segments.
+Note that, for small input, they are slower than single-call functions, due to state management.
+For small input, prefer `XXH32()` and `XXH64()` .
+
+XXH state must first be allocated, using XXH*_createState() .
+
+Start a new hash by initializing state with a seed, using XXH*_reset().
+
+Then, feed the hash state by calling XXH*_update() as many times as necessary.
+Obviously, input must be allocated and read accessible.
+The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
+
+Finally, a hash value can be produced anytime, by using XXH*_digest().
+This function returns the nn-bits hash as an int or long long.
+
+It's still possible to continue inserting input into the hash state after a digest,
+and generate some new hashes later on, by calling again XXH*_digest().
+
+When done, free XXH state space if it was allocated dynamically.
+*/
+
+/*======   Canonical representation   ======*/
+
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
+
+/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
+*  The canonical representation uses human-readable write convention, aka big-endian (large digits first).
+*  These functions allow transformation of hash result into and from its canonical format.
+*  This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
+*/
+
+
+#ifndef XXH_NO_LONG_LONG
+/*-**********************************************************************
+*  64-bits hash
+************************************************************************/
+typedef unsigned long long XXH64_hash_t;
+
+/*! XXH64() :
+    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
+    "seed" can be used to alter the result predictably.
+    This function runs faster on 64-bits systems, but slower on 32-bits systems (see benchmark).
+*/
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
+
+/*======   Streaming   ======*/
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
+
+/*======   Canonical representation   ======*/
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+#endif  /* XXH_NO_LONG_LONG */
+
+
+#ifdef XXH_STATIC_LINKING_ONLY
+
+/* ================================================================================================
+   This section contains definitions which are not guaranteed to remain stable.
+   They may change in future versions, becoming incompatible with a different version of the library.
+   They shall only be used with static linking.
+   Never use these definitions in association with dynamic linking !
+=================================================================================================== */
+
+/* These definitions are only meant to allow allocation of XXH state
+   statically, on stack, or in a struct for example.
+   Do not use members directly. */
+
+   struct XXH32_state_s {
+       unsigned total_len_32;
+       unsigned large_len;
+       unsigned v1;
+       unsigned v2;
+       unsigned v3;
+       unsigned v4;
+       unsigned mem32[4];   /* buffer defined as U32 for alignment */
+       unsigned memsize;
+       unsigned reserved;   /* never read nor write, will be removed in a future version */
+   };   /* typedef'd to XXH32_state_t */
+
+#ifndef XXH_NO_LONG_LONG
+   struct XXH64_state_s {
+       unsigned long long total_len;
+       unsigned long long v1;
+       unsigned long long v2;
+       unsigned long long v3;
+       unsigned long long v4;
+       unsigned long long mem64[4];   /* buffer defined as U64 for alignment */
+       unsigned memsize;
+       unsigned reserved[2];          /* never read nor write, will be removed in a future version */
+   };   /* typedef'd to XXH64_state_t */
+#endif
+
+#  ifdef XXH_PRIVATE_API
+#    include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
+#  endif
+
+#endif /* XXH_STATIC_LINKING_ONLY */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* XXHASH_H_5627135585666179 */

data/examples/frameapi.rb

@@ -0,0 +1,43 @@
+#!ruby
+
+#
+# This code is under public domain (CC0)
+# <http://creativecommons.org/publicdomain/zero/1.0/>.
+#
+# To the extent possible under law, dearblue has waived all copyright
+# and related or neighboring rights to this work.
+#
+#     dearblue <dearblue@users.sourceforce.jp>
+#
+
+# need for calcration crc32 in this example
+class String
+  require "zlib"
+
+  def crc32
+    Zlib.crc32(self)
+  end
+end
+
+########
+
+# first, load library
+require "extlz4"
+
+# prepair source data
+src = File.read(ARGV[0] || __FILE__, mode: "rb")
+puts "%s:%d: src.bytesize=%d, src.crc32=0x%08X\n" %
+        [__FILE__, __LINE__, src.bytesize, src.crc32]
+
+# compress data by LZ4 Frame
+encdata = LZ4.encode(src)
+# OR, encdata = LZ4.encode(src, level = 1)
+puts "%s:%d: encdata.bytesize=%d, encdata.crc32=0x%08X\n" %
+        [__FILE__, __LINE__, encdata.bytesize, encdata.crc32]
+
+decdata = LZ4.decode(encdata)
+puts "%s:%d: decdata.bytesize=%d, decdata.crc32=0x%08X\n" %
+        [__FILE__, __LINE__, decdata.bytesize, decdata.crc32]
+
+puts "%s:%d: comparison source data and decompressed data: %s\n" %
+        [__FILE__, __LINE__, src == decdata ? "SAME" : "NOT SAME (BUG!)"]

data/ext/blockapi.c

@@ -0,0 +1,1046 @@
+#include "extlz4.h"
+#include <lz4.h>
+#include <lz4hc.h>
+
+#define RDOCFAKE(code)
+
+RDOCFAKE(extlz4_mLZ4 = rb_define_module("LZ4"));
+
+#if __GNUC__ || __clang__ || EXTLZ4_FORCE_EXPECT
+#define AUX_LIKELY(x)   __builtin_expect(!!(x), 1)
+#define AUX_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define AUX_LIKELY(x)   (x)
+#define AUX_UNLIKELY(x) (x)
+#endif
+
+
+static void *
+aux_LZ4_compress_fast_continue_nogvl(va_list *vp)
+{
+    LZ4_stream_t *context = va_arg(*vp, LZ4_stream_t *);
+    const char *src = va_arg(*vp, const char *);
+    char *dest = va_arg(*vp, char *);
+    int srcsize = va_arg(*vp, int);
+    int destsize = va_arg(*vp, int);
+    int acceleration = va_arg(*vp, int);
+
+    // NOTE: キャストについては aux_LZ4_decompress_safe_continue_nogvl() を参照されたし
+    return (void *)(intptr_t)LZ4_compress_fast_continue(context, src, dest, srcsize, destsize, acceleration);
+}
+
+static int
+aux_LZ4_compress_fast_continue(void *context, const char *src, char *dest, int srcsize, int destsize, int acceleration)
+{
+    return (int)aux_thread_call_without_gvl(
+            aux_LZ4_compress_fast_continue_nogvl, NULL,
+            context, src, dest, srcsize, destsize, acceleration);
+}
+
+static void *
+aux_LZ4_compressHC_continue_nogvl(va_list *vp)
+{
+    LZ4_streamHC_t *context = va_arg(*vp, LZ4_streamHC_t *);
+    const char *src = va_arg(*vp, const char *);
+    char *dest = va_arg(*vp, char *);
+    int srcsize = va_arg(*vp, int);
+    int destsize = va_arg(*vp, int);
+
+    // NOTE: キャストについては aux_LZ4_decompress_safe_continue_nogvl() を参照されたし
+    return (void *)(intptr_t)LZ4_compress_HC_continue(context, src, dest, srcsize, destsize);
+}
+
+static int
+aux_LZ4_compressHC_continue(void *context, const char *src, char *dest, int srcsize, int destsize, int acceleration__ignored__)
+{
+    (void)acceleration__ignored__;
+    return (int)aux_thread_call_without_gvl(
+            aux_LZ4_compressHC_continue_nogvl, NULL,
+            context, src, dest, srcsize, destsize);
+}
+
+static void *
+aux_LZ4_decompress_safe_continue_nogvl(va_list *vp)
+{
+    LZ4_streamDecode_t *context = va_arg(*vp, LZ4_streamDecode_t *);
+    const char *src = va_arg(*vp, const char *);
+    char *dest = va_arg(*vp, char *);
+    int srcsize = va_arg(*vp, int);
+    int maxsize = va_arg(*vp, int);
+
+    // NOTE: キャストを (int) -> (intptr_t) -> (void *) としている理由は、
+    // NOTE: (int) -> (void *) とするとコンパイラが警告してくるのを避けるため
+    return (void *)(intptr_t)LZ4_decompress_safe_continue(context, src, dest, srcsize, maxsize);
+}
+
+static int
+aux_LZ4_decompress_safe_continue(LZ4_streamDecode_t *context, const char *src, char *dest, int srcsize, int maxsize)
+{
+    return (int)aux_thread_call_without_gvl(
+            aux_LZ4_decompress_safe_continue_nogvl, NULL,
+            context, src, dest, srcsize, maxsize);
+}
+
+static inline size_t
+aux_lz4_expandsize(const char **p, const char *end, size_t size)
+{
+    while (AUX_LIKELY(*p < end)) {
+        int s = (uint8_t)*(*p) ++;
+        size += s;
+        if (AUX_LIKELY(s != 255)) {
+            return size;
+        }
+    }
+
+    rb_raise(extlz4_eError, "encounted invalid end of sequence");
+}
+
+static inline size_t
+aux_lz4_scanseq(const char *p, const char *end, size_t *linksize)
+{
+    size_t size = 0;
+    while (AUX_LIKELY(p < end)) {
+        uint8_t token = (uint8_t)*p ++;
+        size_t s = token >> 4;
+        if (AUX_LIKELY(s == 15)) {
+            s = aux_lz4_expandsize(&p, end, s);
+        }
+        size += s;
+        p += s;
+
+        if (AUX_UNLIKELY(p + 2 >= end)) {
+            if (p == end) {
+#if 0
+                s = token & 0x0f;
+                if (s != 0) {
+                    // TODO: raise? or do nothing?
+                }
+#endif
+                return size;
+            }
+            break;
+        }
+        size_t offset = (uint8_t)*p ++;
+        offset |= ((size_t)((uint8_t)*p ++)) << 8;
+        if (linksize) {
+            ssize_t n = offset - size;
+            if (AUX_UNLIKELY(n > 0 && n > (ssize_t)*linksize)) {
+                *linksize = n;
+            }
+        }
+#if 0
+        if (AUX_UNLIKELY(offset == 0)) {
+            rb_raise(extlz4_eError, "offset is zero");
+        }
+#endif
+        s = token & 0x0f;
+        if (AUX_LIKELY(s == 15)) {
+            s = aux_lz4_expandsize(&p, end, s);
+        }
+        size += s + 4;
+    }
+
+    rb_raise(extlz4_eError, "encounted invalid end of sequence");
+}
+
+/*
+ * lz4 シーケンスから伸張後のバイト数を得る
+ *
+ * str が文字列であることを保証するのは呼び出し元の責任
+ */
+static size_t
+aux_lz4_scansize(VALUE str)
+{
+    const char *p;
+    size_t size;
+    RSTRING_GETMEM(str, p, size);
+
+    return aux_lz4_scanseq(p, p + size, NULL);
+}
+
+/*
+ * offset トークンがバッファの負の数を表しているか確認する。
+ *
+ * 戻り値はその最大距離を返す (負の数として見るならば最小値だが、絶対値に変換する)。
+ *
+ * 名称の link は LZ4 frame からとった。
+ */
+static size_t
+aux_lz4_linksize(VALUE str)
+{
+    const char *p;
+    size_t size;
+    RSTRING_GETMEM(str, p, size);
+
+    size_t linksize = 0;
+    aux_lz4_scanseq(p, p + size, &linksize);
+
+    return linksize;
+}
+
+static inline VALUE
+aux_shouldbe_string(VALUE obj)
+{
+    rb_check_type(obj, RUBY_T_STRING);
+    return obj;
+}
+
+static inline size_t
+aux_lz4_compressbound(VALUE src)
+{
+    return LZ4_compressBound(RSTRING_LEN(src));
+}
+
+enum {
+    MAX_PREDICT_SIZE = 65536,
+};
+
+static inline VALUE
+make_predict(VALUE predict)
+{
+    if (NIL_P(predict)) {
+        return Qnil;
+    }
+
+    rb_check_type(predict, RUBY_T_STRING);
+    size_t size = RSTRING_LEN(predict);
+    if (size == 0) {
+        return Qnil;
+    }
+    if (size > MAX_PREDICT_SIZE) {
+        predict = rb_str_subseq(predict, size - MAX_PREDICT_SIZE, MAX_PREDICT_SIZE);
+    } else {
+        predict = rb_str_dup(predict);
+    }
+    return rb_str_freeze(predict);
+}
+
+
+/*
+ * calculate destination size from source data
+ */
+typedef size_t aux_calc_destsize_f(VALUE src);
+
+static inline void
+blockprocess_args(int argc, VALUE argv[], VALUE *src, VALUE *dest, size_t *maxsize, int *level, aux_calc_destsize_f *calcsize)
+{
+    const VALUE *argend = argv + argc;
+    VALUE tmp;
+
+    if (level) {
+        int w = -1;
+        if (argc > 1) {
+            tmp = argv[0];
+            if (NIL_P(tmp)) {
+                argv ++;
+            } else if (rb_obj_is_kind_of(tmp, rb_cNumeric)) {
+                argv ++;
+                w = NUM2INT(tmp);
+            }
+        }
+        *level = w;
+    }
+
+    if (argv < argend) {
+        *src = aux_shouldbe_string(argv[0]);
+        switch (argend - argv) {
+        case 1:
+            *maxsize = calcsize(*src);
+            *dest = rb_str_buf_new(*maxsize);
+            return;
+        case 2:
+            tmp = argv[1];
+            if (RB_TYPE_P(tmp, RUBY_T_STRING)) {
+                *maxsize = calcsize(*src);
+                *dest = aux_shouldbe_string(tmp);
+                aux_str_reserve(*dest, *maxsize);
+            } else {
+                *maxsize = NUM2SIZET(tmp);
+                *dest = rb_str_buf_new(*maxsize);
+            }
+            return;
+        case 3:
+            *maxsize = NUM2SIZET(argv[1]);
+            *dest = aux_shouldbe_string(argv[2]);
+            aux_str_reserve(*dest, *maxsize);
+            return;
+        }
+    }
+
+    rb_error_arity(argc, 1, (level ? 4 : 3));
+}
+
+/*
+ * Document-class: LZ4::BlockEncoder
+ *
+ * このクラスは LZ4 Block API を扱うためのものです。
+ */
+
+typedef void blockencoder_reset_f(void *context, int level);
+typedef void *blockencoder_create_f(void);
+typedef int blockencoder_free_f(void *context);
+typedef int blockencoder_loaddict_f(void *context, const char *dict, int dictsize);
+typedef int blockencoder_savedict_f(void *context, char *dict, int dictsize);
+typedef int blockencoder_update_f(void *context, const char *src, char *dest, int srcsize, int destsize, int acceleration);
+typedef int blockencoder_update_unlinked_f(void *context, const char *src, char *dest, int srcsize, int destsize);
+
+struct blockencoder_traits
+{
+    blockencoder_reset_f *reset;
+    blockencoder_create_f *create;
+    blockencoder_free_f *free;
+    blockencoder_loaddict_f *loaddict;
+    blockencoder_savedict_f *savedict;
+    blockencoder_update_f *update;
+    /* blockencoder_update_unlinked_f *update_unlinked; */
+};
+
+static void
+aux_LZ4_resetStream(LZ4_stream_t *context, int level__ignored__)
+{
+    (void)level__ignored__;
+    LZ4_resetStream(context);
+}
+
+static const struct blockencoder_traits blockencoder_traits_std = {
+    .reset = (blockencoder_reset_f *)aux_LZ4_resetStream,
+    .create = (blockencoder_create_f *)LZ4_createStream,
+    .free = (blockencoder_free_f *)LZ4_freeStream,
+    .loaddict = (blockencoder_loaddict_f *)LZ4_loadDict,
+    .savedict = (blockencoder_savedict_f *)LZ4_saveDict,
+    .update = (blockencoder_update_f *)aux_LZ4_compress_fast_continue,
+    /* .update_unlinked = (blockencoder_update_unlinked_f *)LZ4_compress_limitedOutput_withState, */
+};
+
+static const struct blockencoder_traits blockencoder_traits_hc = {
+    .reset = (blockencoder_reset_f *)LZ4_resetStreamHC,
+    .create = (blockencoder_create_f *)LZ4_createStreamHC,
+    .free = (blockencoder_free_f *)LZ4_freeStreamHC,
+    .loaddict = (blockencoder_loaddict_f *)LZ4_loadDictHC,
+    .savedict = (blockencoder_savedict_f *)LZ4_saveDictHC,
+    .update = (blockencoder_update_f *)aux_LZ4_compressHC_continue,
+    /* .update_unlinked = (blockencoder_update_unlinked_f *)LZ4_compressHC_limitedOutput_withStateHC, */
+};
+
+struct blockencoder
+{
+    void *context;
+    const struct blockencoder_traits *traits;
+    VALUE predict;
+    int level;
+    int prefixsize;
+    char prefix[1 << 16]; /* 64 KiB; LZ4_loadDict, LZ4_saveDict */
+};
+
+static void
+blkenc_mark(void *pp)
+{
+    struct blockencoder *p = pp;
+    rb_gc_mark(p->predict);
+}
+
+static void
+blkenc_free(void *pp)
+{
+    struct blockencoder *p = pp;
+    if (p->context && p->traits) {
+        p->traits->free(p->context);
+    }
+    memset(p, 0, sizeof(*p));
+    xfree(p);
+}
+
+static const rb_data_type_t blockencoder_type = {
+    .wrap_struct_name = "extlz4.LZ4.BlockEncoder",
+    .function.dmark = blkenc_mark,
+    .function.dfree = blkenc_free,
+    /* .function.dsize = blkenc_size, */
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+blkenc_alloc(VALUE klass)
+{
+    struct blockencoder *p;
+    VALUE v = TypedData_Make_Struct(klass, struct blockencoder, &blockencoder_type, p);
+    p->predict = Qnil;
+    return v;
+}
+
+static inline struct blockencoder *
+getencoderp(VALUE enc)
+{
+    return getrefp(enc, &blockencoder_type);
+}
+
+static inline struct blockencoder *
+getencoder(VALUE enc)
+{
+    return getref(enc, &blockencoder_type);
+}
+
+static inline struct blockencoder *
+encoder_context(VALUE enc)
+{
+    struct blockencoder *p = getencoder(enc);
+    if (!p->context) {
+        rb_raise(extlz4_eError,
+                "not initialized yet - #<%s:%p>",
+                rb_obj_classname(enc), (void *)enc);
+    }
+
+    return p;
+}
+
+static inline void
+blkenc_setup(int argc, VALUE argv[], struct blockencoder *p, VALUE predict)
+{
+    rb_check_arity(argc, 0, 2);
+
+    if (p->context) {
+        void *cx = p->context;
+        p->context = NULL;
+        p->traits->free(cx);
+    }
+
+    if (argc == 0 || NIL_P(argv[0])) {
+        p->level = 1;
+        p->traits = &blockencoder_traits_std;
+    } else {
+        p->level = NUM2UINT(argv[0]);
+        if (p->level < 0) {
+            p->traits = &blockencoder_traits_std;
+            p->level = -p->level;
+        } else {
+            p->traits = &blockencoder_traits_hc;
+        }
+    }
+
+    if (argc < 2) {
+        p->predict = predict;
+    } else {
+        p->predict = make_predict(argv[1]);
+    }
+
+    p->context = p->traits->create();
+    if (!p->context) {
+        rb_gc();
+        p->context = p->traits->create();
+        if (!p->context) {
+            errno = ENOMEM;
+            rb_sys_fail("failed context allocation by LZ4_createStream()");
+        }
+    }
+
+    p->traits->reset(p->context, p->level);
+
+    if (NIL_P(p->predict)) {
+        p->traits->loaddict(p->context, NULL, 0);
+    } else {
+        /*
+         * NOTE: すぐ下で LZ4_saveDict() を実行するため、
+         * NOTE: p->predict のバッファ領域が保持されることはない。
+         */
+        p->traits->loaddict(p->context, RSTRING_PTR(p->predict), RSTRING_LEN(p->predict));
+    }
+
+    p->prefixsize = p->traits->savedict(p->context, p->prefix, sizeof(p->prefix));
+}
+
+/*
+ * call-seq:
+ *  initialize(level = nil, predict = nil)
+ *
+ * [INFECTION]
+ *  +self+ <- +predict+
+ *
+ * [RETURN]
+ *      self
+ *
+ * [level]
+ *      When given +nil+, encode normal compression.
+ *
+ *      When given +0+ .. +15+, encode high compression.
+ *
+ * [predict]
+ *      Preset dictionary.
+ */
+static VALUE
+blkenc_init(int argc, VALUE argv[], VALUE enc)
+{
+    struct blockencoder *p = getencoder(enc);
+    if (p->context) {
+        rb_raise(extlz4_eError,
+                "already initialized - #<%s:%p>",
+                rb_obj_classname(enc), (void *)enc);
+    }
+
+    blkenc_setup(argc, argv, p, Qnil);
+    rb_obj_infect(enc, p->predict);
+
+    return enc;
+}
+
+/*
+ * call-seq:
+ *  update(src, dest = "") -> dest
+ *  update(src, max_dest_size, dest = "") -> dest
+ *
+ * [INFECTION]
+ *      +dest+ <- +self+ <- +src+
+ */
+static VALUE
+blkenc_update(int argc, VALUE argv[], VALUE enc)
+{
+    struct blockencoder *p = encoder_context(enc);
+    VALUE src, dest;
+    size_t maxsize;
+    blockprocess_args(argc, argv, &src, &dest, &maxsize, NULL, aux_lz4_compressbound);
+    rb_obj_infect(enc, src);
+    rb_obj_infect(dest, enc);
+    char *srcp;
+    size_t srcsize;
+    RSTRING_GETMEM(src, srcp, srcsize);
+    int s = p->traits->update(p->context, srcp, RSTRING_PTR(dest), srcsize, maxsize, p->level);
+    if (s <= 0) {
+        rb_raise(extlz4_eError,
+                "destsize too small (given destsize is %zu)",
+                rb_str_capacity(dest));
+    }
+    p->prefixsize = p->traits->savedict(p->context, p->prefix, sizeof(p->prefix));
+    rb_str_set_len(dest, s);
+    return dest;
+}
+
+/*
+ * call-seq:
+ *  reset(level = nil) -> self
+ *  reset(level, predict) -> self
+ *
+ * [INFECTION]
+ *  +self+ < +predict+
+ *
+ * Reset block stream encoder.
+ */
+static VALUE
+blkenc_reset(int argc, VALUE argv[], VALUE enc)
+{
+    struct blockencoder *p = encoder_context(enc);
+    blkenc_setup(argc, argv, p, p->predict);
+    rb_obj_infect(enc, p->predict);
+
+    return enc;
+}
+
+static VALUE
+blkenc_release(VALUE enc)
+{
+    struct blockencoder *p = getencoder(enc);
+    if (p->traits && p->context) {
+        p->traits->free(p->context);
+    }
+    p->context = NULL;
+    p->traits = NULL;
+    memset(p->prefix, 0, sizeof(p->prefix));
+    p->prefixsize = 0;
+    return Qnil;
+}
+
+static VALUE
+blkenc_predict(VALUE enc)
+{
+    return getencoder(enc)->predict;
+}
+
+/*
+ * call-seq:
+ *  savedict -> dict or nil
+ *  savedict(buf) -> buf or nil
+ */
+static VALUE
+blkenc_savedict(int argc, VALUE argv[], VALUE enc)
+{
+    struct blockencoder *p = encoder_context(enc);
+    VALUE dict;
+
+    if (argc == 0) {
+        dict = rb_str_buf_new(p->prefixsize);
+    } else if (argc == 1) {
+        dict = argv[0];
+        aux_str_reserve(dict, p->prefixsize);
+    } else {
+        rb_error_arity(argc, 0, 1);
+    }
+
+    memcpy(RSTRING_PTR(dict), p->prefix, p->prefixsize);
+    if (p->prefixsize > 0) {
+        rb_str_set_len(dict, p->prefixsize);
+        rb_obj_infect(dict, enc);
+        return dict;
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+blkenc_inspect(VALUE enc)
+{
+    struct blockencoder *p = getencoderp(enc);
+    if (p && p->context) {
+        if (p->traits == &blockencoder_traits_std) {
+            return rb_sprintf("#<%s:%p (fast compression %d)%s>",
+                    rb_obj_classname(enc), (void *)enc, p->level,
+                    (NIL_P(p->predict)) ? "" : " (with predict)");
+        } else if (p->traits == &blockencoder_traits_hc) {
+            return rb_sprintf("#<%s:%p (high compression %d)%s>",
+                    rb_obj_classname(enc), (void *)enc, p->level,
+                    (NIL_P(p->predict)) ? "" : " (with predict)");
+        } else {
+            return rb_sprintf("#<%s:%p **INVALID COMPRESSOR**>",
+                    rb_obj_classname(enc), (void *)enc);
+        }
+    } else {
+        return rb_sprintf("#<%s:%p **NOT INITIALIZED**>",
+                rb_obj_classname(enc), (void *)enc);
+    }
+}
+
+/*
+ * call-seq:
+ *  compressbound(src) -> size
+ *
+ * Calcuration maximum size of encoded data in worst case.
+ */
+static VALUE
+blkenc_s_compressbound(VALUE mod, VALUE src)
+{
+    return SIZET2NUM(LZ4_compressBound(NUM2UINT(src)));
+}
+
+typedef int aux_lz4_encoder_f(const char *src, char *dest, int srcsize, int maxsize, int level);
+
+/*
+ * call-seq:
+ *  encode(src, dest = "") -> dest with compressed string data
+ *  encode(src, max_dest_size, dest = "") -> dest with compressed string data
+ *  encode(level, src, dest = "") -> dest with compressed string data
+ *  encode(level, src, max_dest_size, dest = "") -> dest with compressed string data
+ *
+ * Encode to block LZ4 data.
+ *
+ * level を指定した場合、より圧縮処理に時間を掛けて圧縮効率を高めることが出来ます。
+ *
+ * 実装の都合上、圧縮関数は LZ4_compress_fast / LZ4_compress_HC が使われます。
+ *
+ * [INFECTION]
+ *      +dest+ <- +src+
+ *
+ * [RETURN]
+ *      圧縮されたデータが文字列として返ります。dest を指定した場合は、圧縮データを格納した dest を返します。
+ *
+ *      圧縮データには自身の終わりやデータ長が含まれていないため、伸張する際には余計なデータが付随していると正常に伸張できません。
+ *
+ * [src]
+ *      圧縮対象となる文字列オブジェクトを指定します。
+ *
+ * [max_dest_size (optional)]
+ *      出力バッファの最大バイト数を指定します。圧縮時にこれよりも多くのバッファ長が必要になった場合は例外が発生します。
+ *
+ *      省略時は src 長から最悪値が計算されます。dest が最初に確保できれば圧縮処理中に例外が発生することがありません。
+ *
+ * [dest (optional)]
+ *      出力先とする文字列オブジェクトを指定します。
+ *
+ *      max_dest_size が同時に指定されない場合、出力バッファの最大バイト長は src 長から最悪値が求められて調整されます。
+ *
+ * [level (optional)]
+ *      圧縮レベルとしての数値または nil を指定します。
+ *
+ *      0 を指定した場合、LZ4 の規定値による高効率圧縮処理が行われます。
+ *
+ *      0 を超えた数値を指定した場合、LZ4 の高効率圧縮処理が行われます。
+ *
+ *      nil を与えるか省略した場合、通常の圧縮処理が行われます。
+ *
+ *      0 に満たない数値を指定した場合、高速圧縮処理が行われます。
+ *      内部でこの値は絶対値に変換されて LZ4_compress_fast() の acceleration 引数として渡されます。
+ */
+static VALUE
+blkenc_s_encode(int argc, VALUE argv[], VALUE lz4)
+{
+    VALUE src, dest;
+    size_t maxsize;
+    int level;
+    blockprocess_args(argc, argv, &src, &dest, &maxsize, &level, aux_lz4_compressbound);
+
+    aux_lz4_encoder_f *encoder;
+    if (level < 0) {
+        encoder = LZ4_compress_fast;
+        level = -level;
+    } else {
+        encoder = LZ4_compress_HC;
+    }
+
+    size_t srcsize = RSTRING_LEN(src);
+    if (srcsize > LZ4_MAX_INPUT_SIZE) {
+        rb_raise(extlz4_eError,
+                 "source size is too big for lz4 encode (given %zu, but max %zu bytes)",
+                 srcsize, (size_t)LZ4_MAX_INPUT_SIZE);
+    }
+    aux_str_reserve(dest, maxsize);
+    rb_str_set_len(dest, 0);
+    rb_obj_infect(dest, src);
+
+    int size = encoder(RSTRING_PTR(src), RSTRING_PTR(dest), srcsize, maxsize, level);
+    if (size <= 0) {
+        rb_raise(extlz4_eError,
+                 "failed LZ4 compress - maxsize is too small, or out of memory");
+    }
+
+    rb_str_set_len(dest, size);
+
+    return dest;
+}
+
+static void
+init_blockencoder(void)
+{
+    VALUE cBlockEncoder = rb_define_class_under(extlz4_mLZ4, "BlockEncoder", rb_cObject);
+    rb_define_alloc_func(cBlockEncoder, blkenc_alloc);
+    rb_define_method(cBlockEncoder, "initialize", RUBY_METHOD_FUNC(blkenc_init), -1);
+    rb_define_method(cBlockEncoder, "reset", RUBY_METHOD_FUNC(blkenc_reset), -1);
+    rb_define_method(cBlockEncoder, "update", RUBY_METHOD_FUNC(blkenc_update), -1);
+    rb_define_method(cBlockEncoder, "release", RUBY_METHOD_FUNC(blkenc_release), 0);
+    rb_define_method(cBlockEncoder, "predict", RUBY_METHOD_FUNC(blkenc_predict), 0);
+    rb_define_method(cBlockEncoder, "savedict", RUBY_METHOD_FUNC(blkenc_savedict), -1);
+    rb_define_method(cBlockEncoder, "inspect", RUBY_METHOD_FUNC(blkenc_inspect), 0);
+    rb_define_alias(cBlockEncoder, "encode", "update");
+    rb_define_alias(cBlockEncoder, "compress", "update");
+    rb_define_alias(cBlockEncoder, "free", "release");
+
+    rb_define_singleton_method(cBlockEncoder, "compressbound", blkenc_s_compressbound, 1);
+    rb_define_singleton_method(cBlockEncoder, "encode", blkenc_s_encode, -1);
+    rb_define_alias(rb_singleton_class(cBlockEncoder), "compress", "encode");
+
+    rb_define_const(extlz4_mLZ4, "LZ4HC_CLEVEL_MIN", INT2FIX(LZ4HC_CLEVEL_MIN));
+    rb_define_const(extlz4_mLZ4, "LZ4HC_CLEVEL_DEFAULT", INT2FIX(LZ4HC_CLEVEL_DEFAULT));
+    rb_define_const(extlz4_mLZ4, "LZ4HC_CLEVEL_OPT_MIN", INT2FIX(LZ4HC_CLEVEL_OPT_MIN));
+    rb_define_const(extlz4_mLZ4, "LZ4HC_CLEVEL_MAX", INT2FIX(LZ4HC_CLEVEL_MAX));
+
+    rb_define_const(extlz4_mLZ4, "HC_CLEVEL_MIN", INT2FIX(LZ4HC_CLEVEL_MIN));
+    rb_define_const(extlz4_mLZ4, "HC_CLEVEL_DEFAULT", INT2FIX(LZ4HC_CLEVEL_DEFAULT));
+    rb_define_const(extlz4_mLZ4, "HC_CLEVEL_OPT_MIN", INT2FIX(LZ4HC_CLEVEL_OPT_MIN));
+    rb_define_const(extlz4_mLZ4, "HC_CLEVEL_MAX", INT2FIX(LZ4HC_CLEVEL_MAX));
+}
+
+/*
+ * class LZ4::BlockDecoder
+ */
+
+struct blockdecoder
+{
+    void *context;
+    VALUE predict;
+    size_t dictsize;
+    char dictbuf[64 * 1024];
+};
+
+static void
+blkdec_mark(void *pp)
+{
+    struct blockdecoder *p = pp;
+    rb_gc_mark(p->predict);
+}
+
+static void
+blkdec_free(void *pp)
+{
+    struct blockdecoder *p = pp;
+    if (p->context) {
+        LZ4_freeStreamDecode(p->context);
+    }
+    memset(p, 0, sizeof(*p));
+    xfree(p);
+}
+
+static const rb_data_type_t blockdecoder_type = {
+    .wrap_struct_name = "extlz4.LZ4.BlockDecoder",
+    .function.dmark = blkdec_mark,
+    .function.dfree = blkdec_free,
+    /* .function.dsize = blkdec_size, */
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+blkdec_alloc(VALUE klass)
+{
+    struct blockdecoder *p;
+    VALUE v = TypedData_Make_Struct(klass, struct blockdecoder, &blockdecoder_type, p);
+    p->predict = Qnil;
+    return v;
+}
+
+static inline struct blockdecoder *
+getdecoderp(VALUE dec)
+{
+    return getrefp(dec, &blockdecoder_type);
+}
+
+static inline struct blockdecoder *
+getdecoder(VALUE dec)
+{
+    return getref(dec, &blockdecoder_type);
+}
+
+static inline void
+blkdec_setup(int argc, VALUE argv[], VALUE predict, struct blockdecoder *p)
+{
+    VALUE predict1;
+    rb_scan_args(argc, argv, "01", &predict1);
+    if (argc == 0) {
+        p->predict = predict;
+    } else {
+        if (NIL_P(predict1)) {
+            p->predict = predict;
+        } else {
+            rb_check_type(predict1, RUBY_T_STRING);
+            p->predict = predict = rb_str_dup(predict1);
+        }
+    }
+
+    if (!p->context) {
+        p->context = LZ4_createStreamDecode();
+        if (!p->context) {
+            rb_gc();
+            p->context = LZ4_createStreamDecode();
+            if (!p->context) {
+                errno = ENOMEM;
+                rb_sys_fail("failed LZ4_createStreamDecode()");
+            }
+        }
+    }
+
+    if (!NIL_P(predict)) {
+        const char *pdp;
+        RSTRING_GETMEM(predict, pdp, p->dictsize);
+        if (p->dictsize > sizeof(p->dictbuf)) {
+            pdp += p->dictsize - sizeof(p->dictbuf);
+            p->dictsize = sizeof(p->dictbuf);
+        }
+
+        memcpy(p->dictbuf, pdp, p->dictsize);
+    } else {
+        p->dictsize = 0;
+    }
+}
+
+/*
+ * call-seq:
+ *  initialize
+ *  initialize(preset_dictionary)
+ *
+ * [INFECTION]
+ *  +self+ < +preset_dictionary+
+ */
+static VALUE
+blkdec_init(int argc, VALUE argv[], VALUE dec)
+{
+    struct blockdecoder *p = getdecoder(dec);
+
+    blkdec_setup(argc, argv, Qnil, p);
+    rb_obj_infect(dec, p->predict);
+
+    return dec;
+}
+
+/*
+ * call-seq:
+ *  reset
+ *  reset(preset_dictionary)
+ *
+ * [INFECTION]
+ *  +self+ < +preset_dictionary+
+ */
+static VALUE
+blkdec_reset(int argc, VALUE argv[], VALUE dec)
+{
+    struct blockdecoder *p = getdecoder(dec);
+
+    blkdec_setup(argc, argv, p->predict, p);
+    rb_obj_infect(dec, p->predict);
+
+    return dec;
+}
+
+/*
+ * call-seq:
+ *  update(src, dest = "") -> dest for decoded string data
+ *  update(src, max_dest_size, dest = "") -> dest for decoded string data
+ *
+ * Decode block lz4 data of stream block.
+ *
+ * Given arguments and return values are same as LZ4#block_decode.
+ * See LZ4#block_decode for about its.
+ *
+ * 出力先は、max_dest_size が与えられていない場合、必要に応じて自動的に拡張されます。
+ * この場合、いったん圧縮された LZ4 データを走査するため、事前に僅かな CPU 時間を必要とします。
+ *
+ * [INFECTION]
+ *      +dest+ < +self+ < +src+
+ */
+static VALUE
+blkdec_update(int argc, VALUE argv[], VALUE dec)
+{
+    struct blockdecoder *p = getdecoder(dec);
+    if (!p->context) { rb_raise(extlz4_eError, "need reset (context not initialized)"); }
+    VALUE src, dest;
+    size_t maxsize;
+    blockprocess_args(argc, argv, &src, &dest, &maxsize, NULL, aux_lz4_scansize);
+    rb_obj_infect(dec, src);
+    rb_obj_infect(dest, dec);
+    const char *srcp;
+    size_t srcsize;
+    RSTRING_GETMEM(src, srcp, srcsize);
+    LZ4_setStreamDecode(p->context, p->dictbuf, p->dictsize);
+    int s = aux_LZ4_decompress_safe_continue(p->context, srcp, RSTRING_PTR(dest), srcsize, maxsize);
+    if (s < 0) {
+        rb_raise(extlz4_eError,
+                "`max_dest_size' too small, or corrupt lz4'd data");
+    }
+    rb_str_set_len(dest, s);
+
+    /* copy prefix */
+    if (s < sizeof(p->dictbuf)) {
+        ssize_t discard = (p->dictsize + s) - sizeof(p->dictbuf);
+        if (discard > 0) {
+            size_t remain = p->dictsize - discard;
+            memmove(p->dictbuf, (const char *)(p->dictbuf + discard), remain);
+            p->dictsize = remain;
+        }
+
+        memcpy(p->dictbuf + p->dictsize, RSTRING_PTR(dest), s);
+        p->dictsize += s;
+    } else {
+        memcpy(p->dictbuf, RSTRING_END(dest) - sizeof(p->dictbuf), sizeof(p->dictbuf));
+        p->dictsize = sizeof(p->dictbuf);
+    }
+
+    return dest;
+}
+
+/*
+ * call-seq:
+ *  release -> nil
+ *
+ * Release allocated internal heap memory.
+ */
+static VALUE
+blkdec_release(VALUE lz4)
+{
+    struct blockdecoder *p = getdecoderp(lz4);
+    if (!p) { return Qnil; }
+    if (p->context) {
+        LZ4_freeStreamDecode(p->context);
+        p->context = NULL;
+    }
+    // TODO: p->predict と p->prefix も rb_str_resize で 0 にするべきか?
+    p->predict = Qnil;
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *  scansize(lz4_blockencoded_data) -> integer
+ *
+ * Scan block lz4 data, and get decoded byte size.
+ *
+ * このメソッドは、block_decode メソッドに max_dest_size なしで利用する場合の検証目的で利用できるようにしてあります。
+ *
+ * その他の有用な使い方があるのかは不明です。
+ */
+static VALUE
+blkdec_s_scansize(VALUE mod, VALUE str)
+{
+    rb_check_type(str, RUBY_T_STRING);
+    return SIZET2NUM(aux_lz4_scansize(str));
+}
+
+/*
+ * call-seq:
+ *  linksize(lz4_blockencoded_data) -> prefix size as integer
+ *
+ * Scan block lz4 data, and get prefix byte size.
+ */
+static VALUE
+blkdec_s_linksize(VALUE mod, VALUE str)
+{
+    rb_check_type(str, RUBY_T_STRING);
+    return SIZET2NUM(aux_lz4_linksize(str));
+}
+
+/*
+ * call-seq:
+ *  decode(src, dest = "") -> dest with decoded string data
+ *  decode(src, max_dest_size, dest = "") -> dest with decoded string data
+ *
+ * Decode block LZ4 data.
+ *
+ * 出力先は、max_dest_size が与えられていない場合、必要に応じて自動的に拡張されます。
+ * この場合、いったん圧縮された LZ4 データを走査するため、事前に僅かな CPU 時間を必要とします。
+ *
+ * [INFECTION]
+ *      +dest+ < +src+
+ */
+static VALUE
+blkdec_s_decode(int argc, VALUE argv[], VALUE lz4)
+{
+    VALUE src, dest;
+    size_t maxsize;
+    blockprocess_args(argc, argv, &src, &dest, &maxsize, NULL, aux_lz4_scansize);
+
+    aux_str_reserve(dest, maxsize);
+    rb_str_set_len(dest, 0);
+    rb_obj_infect(dest, src);
+
+    int size = LZ4_decompress_safe(RSTRING_PTR(src), RSTRING_PTR(dest), RSTRING_LEN(src), maxsize);
+    if (size < 0) {
+        rb_raise(extlz4_eError,
+                 "failed LZ4_decompress_safe - max_dest_size is too small, or data is corrupted");
+    }
+
+    rb_str_set_len(dest, size);
+
+    return dest;
+}
+
+static void
+init_blockdecoder(void)
+{
+    VALUE cBlockDecoder = rb_define_class_under(extlz4_mLZ4, "BlockDecoder", rb_cObject);
+    rb_define_alloc_func(cBlockDecoder, blkdec_alloc);
+    rb_define_method(cBlockDecoder, "initialize", RUBY_METHOD_FUNC(blkdec_init), -1);
+    rb_define_method(cBlockDecoder, "reset", RUBY_METHOD_FUNC(blkdec_reset), -1);
+    rb_define_method(cBlockDecoder, "update", RUBY_METHOD_FUNC(blkdec_update), -1);
+    rb_define_method(cBlockDecoder, "release", RUBY_METHOD_FUNC(blkdec_release), 0);
+    rb_define_alias(cBlockDecoder, "decode", "update");
+    rb_define_alias(cBlockDecoder, "decompress", "update");
+    rb_define_alias(cBlockDecoder, "uncompress", "update");
+    rb_define_alias(cBlockDecoder, "free", "release");
+
+    rb_define_singleton_method(cBlockDecoder, "scansize", blkdec_s_scansize, 1);
+    rb_define_singleton_method(cBlockDecoder, "linksize", blkdec_s_linksize, 1);
+    rb_define_singleton_method(cBlockDecoder, "decode", blkdec_s_decode, -1);
+    rb_define_alias(rb_singleton_class(cBlockDecoder), "decompress", "decode");
+    rb_define_alias(rb_singleton_class(cBlockDecoder), "uncompress", "decode");
+}
+
+/*
+ * initializer blockapi.c
+ */
+
+void
+extlz4_init_blockapi(void)
+{
+    init_blockencoder();
+    init_blockdecoder();
+}