lz4-native-ruby 0.1.1 → 1.0.1

data/{vendor/lz4/lib → ext/lz4_native}/lz4.c

@@ -1,6 +1,6 @@
 /*
    LZ4 - Fast LZ compression algorithm
-   Copyright (C) 2011-2023, Yann Collet.
+   Copyright (c) Yann Collet. All rights reserved.
 
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
@@ -77,7 +77,8 @@
 #ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
 #  if defined(__GNUC__) && \
   ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \
-  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) \
+  || (defined(__riscv) && defined(__riscv_zicclsm)) )
 #    define LZ4_FORCE_MEMORY_ACCESS 2
 #  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__) || defined(_MSC_VER)
 #    define LZ4_FORCE_MEMORY_ACCESS 1
@@ -301,12 +302,12 @@ static int LZ4_isAligned(const void* ptr, size_t alignment)
 #include <limits.h>
 #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
 # include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef uintptr_t uptrval;
+  typedef unsigned char BYTE; /*uint8_t not necessarily blessed to alias arbitrary type*/
+  typedef uint16_t      U16;
+  typedef uint32_t      U32;
+  typedef  int32_t      S32;
+  typedef uint64_t      U64;
+  typedef uintptr_t     uptrval;
 #else
 # if UINT_MAX != 4294967295UL
 #   error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4"
@@ -478,13 +479,15 @@ static const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
 #ifndef LZ4_FAST_DEC_LOOP
 #  if defined __i386__ || defined _M_IX86 || defined __x86_64__ || defined _M_X64
 #    define LZ4_FAST_DEC_LOOP 1
-#  elif defined(__aarch64__) && defined(__APPLE__)
-#    define LZ4_FAST_DEC_LOOP 1
-#  elif defined(__aarch64__) && !defined(__clang__)
-     /* On non-Apple aarch64, we disable this optimization for clang because
+#  elif defined(__aarch64__)
+#    if defined(__clang__) && defined(__ANDROID__)
+     /* On Android aarch64, we disable this optimization for clang because
       * on certain mobile chipsets, performance is reduced with clang. For
       * more information refer to https://github.com/lz4/lz4/pull/707 */
-#    define LZ4_FAST_DEC_LOOP 1
+#      define LZ4_FAST_DEC_LOOP 0
+#    else
+#      define LZ4_FAST_DEC_LOOP 1
+#    endif
 #  else
 #    define LZ4_FAST_DEC_LOOP 0
 #  endif
@@ -896,7 +899,7 @@ LZ4_prepareTable(LZ4_stream_t_internal* const cctx,
           || tableType == byPtr
           || inputSize >= 4 KB)
         {
-            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
+            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", (void*)cctx);
             MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
             cctx->currentOffset = 0;
             cctx->tableType = (U32)clearedTable;
@@ -1532,7 +1535,7 @@ LZ4_stream_t* LZ4_createStream(void)
 {
     LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
     LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal));
-    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
+    DEBUGLOG(4, "LZ4_createStream %p", (void*)lz4s);
     if (lz4s == NULL) return NULL;
     LZ4_initStream(lz4s, sizeof(*lz4s));
     return lz4s;
@@ -1563,7 +1566,7 @@ LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
  * prefer initStream() which is more general */
 void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
 {
-    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
+    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", (void*)LZ4_stream);
     MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal));
 }
 
@@ -1575,7 +1578,7 @@ void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
 int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
 {
     if (!LZ4_stream) return 0;   /* support free on NULL */
-    DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
+    DEBUGLOG(5, "LZ4_freeStream %p", (void*)LZ4_stream);
     FREEMEM(LZ4_stream);
     return (0);
 }
@@ -1594,7 +1597,7 @@ int LZ4_loadDict_internal(LZ4_stream_t* LZ4_dict,
     const BYTE* const dictEnd = p + dictSize;
     U32 idx32;
 
-    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);
+    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, (void*)dictionary, (void*)LZ4_dict);
 
     /* It's necessary to reset the context,
      * and not just continue it with prepareTable()
@@ -1661,7 +1664,7 @@ void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dict
         &(dictionaryStream->internal_donotuse);
 
     DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
-             workingStream, dictionaryStream,
+             (void*)workingStream, (void*)dictionaryStream,
              dictCtx != NULL ? dictCtx->dictSize : 0);
 
     if (dictCtx != NULL) {
@@ -1725,7 +1728,7 @@ int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
       && (inputSize > 0)               /* tolerance : don't lose history, in case next invocation would use prefix mode */
       && (streamPtr->dictCtx == NULL)  /* usingDictCtx */
       ) {
-        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary);
+        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, (void*)streamPtr->dictionary);
         /* remove dictionary existence from history, to employ faster prefix mode */
         streamPtr->dictSize = 0;
         streamPtr->dictionary = (const BYTE*)source;
@@ -1815,7 +1818,7 @@ int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
 {
     LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
 
-    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer);
+    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, (void*)safeBuffer);
 
     if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
     if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }
@@ -2311,8 +2314,8 @@ LZ4_decompress_generic(
                       */
                     if ((ip+length != iend) || (cpy > oend)) {
                         DEBUGLOG(5, "should have been last run of literals")
-                        DEBUGLOG(5, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend);
-                        DEBUGLOG(5, "or cpy(%p) > (oend-MFLIMIT)(%p)", cpy, oend-MFLIMIT);
+                        DEBUGLOG(5, "ip(%p) + length(%i) = %p != iend (%p)", (void*)ip, (int)length, (void*)(ip+length), (void*)iend);
+                        DEBUGLOG(5, "or cpy(%p) > (oend-MFLIMIT)(%p)", (void*)cpy, (void*)(oend-MFLIMIT));
                         DEBUGLOG(5, "after writing %u bytes / %i bytes available", (unsigned)(op-(BYTE*)dst), outputSize);
                         goto _output_error;
                     }

data/{vendor/lz4/lib → ext/lz4_native}/lz4.h

@@ -1,7 +1,7 @@
 /*
  *  LZ4 - Fast LZ compression algorithm
  *  Header File
- *  Copyright (C) 2011-2023, Yann Collet.
+ *  Copyright (c) Yann Collet. All rights reserved.
 
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
@@ -258,10 +258,12 @@ LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* d
  * @return : Nb bytes written into 'dst' (necessarily <= dstCapacity)
  *           or 0 if compression fails.
  *
- * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+):
- *        the produced compressed content could, in specific circumstances,
- *        require to be decompressed into a destination buffer larger
- *        by at least 1 byte than the content to decompress.
+ * Note : 'targetDstSize' must be >= 1, because it's the smallest valid lz4 payload.
+ *
+ * Note 2:from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+):
+ *        the produced compressed content could, in rare circumstances,
+ *        require to be decompressed into a destination buffer
+ *        larger by at least 1 byte than decompressesSize.
  *        If an application uses `LZ4_compress_destSize()`,
  *        it's highly recommended to update liblz4 to v1.9.2 or better.
  *        If this can't be done or ensured,
@@ -698,10 +700,10 @@ int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int*
 
 #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
 # include <stdint.h>
-  typedef  int8_t  LZ4_i8;
-  typedef uint8_t  LZ4_byte;
-  typedef uint16_t LZ4_u16;
-  typedef uint32_t LZ4_u32;
+  typedef int8_t         LZ4_i8;
+  typedef unsigned char  LZ4_byte;
+  typedef uint16_t       LZ4_u16;
+  typedef uint32_t       LZ4_u32;
 #else
   typedef   signed char  LZ4_i8;
   typedef unsigned char  LZ4_byte;

data/ext/lz4_native/lz4_native.c

@@ -0,0 +1,442 @@
+/*
+ * LZ4 Native Ruby Extension
+ * Provides complete bindings for lz4.h, lz4hc.h, and lz4frame.h
+ */
+
+#include "ruby.h"
+#include "lz4.h"
+#include "lz4hc.h"
+#include "lz4frame.h"
+#include <string.h>
+
+/* Module and class definitions */
+static VALUE mLZ4Native;
+static VALUE mLZ4;
+static VALUE mLZ4HC;
+static VALUE mLZ4Frame;
+static VALUE eLZ4Error;
+static VALUE eLZ4CompressionError;
+static VALUE eLZ4DecompressionError;
+static VALUE eLZ4FrameError;
+
+/*
+ * ============================================================================
+ * LZ4 Basic Functions (lz4.h)
+ * ============================================================================
+ */
+
+/*
+ * call-seq:
+ *   LZ4.compress_default(source) -> compressed_string
+ *
+ * Compresses source data using default LZ4 compression.
+ * Returns compressed data as a binary string.
+ */
+static VALUE
+lz4_compress_default_wrapper(VALUE self, VALUE source)
+{
+    Check_Type(source, T_STRING);
+
+    const char* src = RSTRING_PTR(source);
+    int src_size = (int)RSTRING_LEN(source);
+
+    if (src_size > LZ4_MAX_INPUT_SIZE) {
+        rb_raise(eLZ4CompressionError, "Input size exceeds LZ4_MAX_INPUT_SIZE");
+    }
+
+    int max_dst_size = LZ4_compressBound(src_size);
+    if (max_dst_size == 0) {
+        rb_raise(eLZ4CompressionError, "Invalid input size");
+    }
+
+    VALUE result = rb_str_buf_new(max_dst_size);
+    char* dst = RSTRING_PTR(result);
+
+    int compressed_size = LZ4_compress_default(src, dst, src_size, max_dst_size);
+
+    if (compressed_size <= 0) {
+        rb_raise(eLZ4CompressionError, "Compression failed");
+    }
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+/*
+ * call-seq:
+ *   LZ4.decompress_safe(source, max_size) -> decompressed_string
+ *
+ * Decompresses LZ4 compressed data safely.
+ * max_size must be >= actual decompressed size.
+ */
+static VALUE
+lz4_decompress_safe_wrapper(VALUE self, VALUE source, VALUE max_size)
+{
+    Check_Type(source, T_STRING);
+    Check_Type(max_size, T_FIXNUM);
+
+    const char* src = RSTRING_PTR(source);
+    int src_size = (int)RSTRING_LEN(source);
+    int dst_capacity = NUM2INT(max_size);
+
+    if (dst_capacity <= 0) {
+        rb_raise(eLZ4DecompressionError, "Invalid max_size");
+    }
+
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char* dst = RSTRING_PTR(result);
+
+    int decompressed_size = LZ4_decompress_safe(src, dst, src_size, dst_capacity);
+
+    if (decompressed_size < 0) {
+        rb_raise(eLZ4DecompressionError, "Decompression failed - possibly corrupt data");
+    }
+
+    rb_str_set_len(result, decompressed_size);
+    return result;
+}
+
+/*
+ * call-seq:
+ *   LZ4.compress_bound(input_size) -> max_compressed_size
+ *
+ * Returns maximum compressed size for given input size.
+ */
+static VALUE
+lz4_compress_bound_wrapper(VALUE self, VALUE input_size)
+{
+    Check_Type(input_size, T_FIXNUM);
+    int size = NUM2INT(input_size);
+    int bound = LZ4_compressBound(size);
+    return INT2NUM(bound);
+}
+
+/*
+ * call-seq:
+ *   LZ4.compress_fast(source, acceleration) -> compressed_string
+ *
+ * Compresses with acceleration factor (higher = faster, less compression).
+ */
+static VALUE
+lz4_compress_fast_wrapper(VALUE self, VALUE source, VALUE acceleration)
+{
+    Check_Type(source, T_STRING);
+    Check_Type(acceleration, T_FIXNUM);
+
+    const char* src = RSTRING_PTR(source);
+    int src_size = (int)RSTRING_LEN(source);
+    int accel = NUM2INT(acceleration);
+
+    int max_dst_size = LZ4_compressBound(src_size);
+    VALUE result = rb_str_buf_new(max_dst_size);
+    char* dst = RSTRING_PTR(result);
+
+    int compressed_size = LZ4_compress_fast(src, dst, src_size, max_dst_size, accel);
+
+    if (compressed_size <= 0) {
+        rb_raise(eLZ4CompressionError, "Compression failed");
+    }
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+/*
+ * call-seq:
+ *   LZ4.version_number -> integer
+ *
+ * Returns the LZ4 library version number.
+ */
+static VALUE
+lz4_version_number_wrapper(VALUE self)
+{
+    return INT2NUM(LZ4_versionNumber());
+}
+
+/*
+ * call-seq:
+ *   LZ4.version_string -> string
+ *
+ * Returns the LZ4 library version string.
+ */
+static VALUE
+lz4_version_string_wrapper(VALUE self)
+{
+    return rb_str_new_cstr(LZ4_versionString());
+}
+
+/*
+ * ============================================================================
+ * LZ4 HC Functions (lz4hc.h)
+ * ============================================================================
+ */
+
+/*
+ * call-seq:
+ *   LZ4HC.compress(source, compression_level = 9) -> compressed_string
+ *
+ * Compresses using high-compression mode.
+ * compression_level: 1-12 (default 9), higher = better compression, slower.
+ */
+static VALUE
+lz4hc_compress_wrapper(int argc, VALUE *argv, VALUE self)
+{
+    VALUE source, level;
+    rb_scan_args(argc, argv, "11", &source, &level);
+
+    Check_Type(source, T_STRING);
+    int compression_level = NIL_P(level) ? LZ4HC_CLEVEL_DEFAULT : NUM2INT(level);
+
+    if (compression_level < LZ4HC_CLEVEL_MIN) {
+        compression_level = LZ4HC_CLEVEL_MIN;
+    } else if (compression_level > LZ4HC_CLEVEL_MAX) {
+        compression_level = LZ4HC_CLEVEL_MAX;
+    }
+
+    const char* src = RSTRING_PTR(source);
+    int src_size = (int)RSTRING_LEN(source);
+
+    int max_dst_size = LZ4_compressBound(src_size);
+    VALUE result = rb_str_buf_new(max_dst_size);
+    char* dst = RSTRING_PTR(result);
+
+    int compressed_size = LZ4_compress_HC(src, dst, src_size, max_dst_size, compression_level);
+
+    if (compressed_size <= 0) {
+        rb_raise(eLZ4CompressionError, "HC compression failed");
+    }
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+/*
+ * call-seq:
+ *   LZ4HC.sizeof_state -> integer
+ *
+ * Returns the size needed for HC compression state.
+ */
+static VALUE
+lz4hc_sizeof_state_wrapper(VALUE self)
+{
+    return INT2NUM(LZ4_sizeofStateHC());
+}
+
+/*
+ * ============================================================================
+ * LZ4 Frame Functions (lz4frame.h)
+ * ============================================================================
+ */
+
+/*
+ * call-seq:
+ *   LZ4Frame.compress_frame(source, options = {}) -> compressed_frame
+ *
+ * Compresses data into a complete LZ4 frame (self-contained format).
+ * Options hash can include:
+ *   - block_size: :max64KB, :max256KB, :max1MB, :max4MB (default :max64KB)
+ *   - block_mode: :linked, :independent (default :linked)
+ *   - checksum: true/false (default false)
+ *   - compression_level: 0-12 (default 0 = fast mode)
+ */
+static VALUE
+lz4frame_compress_frame_wrapper(int argc, VALUE *argv, VALUE self)
+{
+    VALUE source, options;
+    rb_scan_args(argc, argv, "11", &source, &options);
+
+    Check_Type(source, T_STRING);
+
+    const char* src = RSTRING_PTR(source);
+    size_t src_size = RSTRING_LEN(source);
+
+    /* Set up preferences */
+    LZ4F_preferences_t prefs;
+    memset(&prefs, 0, sizeof(prefs));
+    prefs.frameInfo.blockSizeID = LZ4F_max64KB;
+    prefs.frameInfo.blockMode = LZ4F_blockLinked;
+    prefs.frameInfo.contentChecksumFlag = LZ4F_noContentChecksum;
+    prefs.compressionLevel = 0;
+
+    /* Parse options if provided */
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+
+        VALUE block_size = rb_hash_aref(options, ID2SYM(rb_intern("block_size")));
+        if (!NIL_P(block_size)) {
+            ID bs_id = SYM2ID(block_size);
+            if (bs_id == rb_intern("max64KB")) prefs.frameInfo.blockSizeID = LZ4F_max64KB;
+            else if (bs_id == rb_intern("max256KB")) prefs.frameInfo.blockSizeID = LZ4F_max256KB;
+            else if (bs_id == rb_intern("max1MB")) prefs.frameInfo.blockSizeID = LZ4F_max1MB;
+            else if (bs_id == rb_intern("max4MB")) prefs.frameInfo.blockSizeID = LZ4F_max4MB;
+        }
+
+        VALUE block_mode = rb_hash_aref(options, ID2SYM(rb_intern("block_mode")));
+        if (!NIL_P(block_mode)) {
+            ID bm_id = SYM2ID(block_mode);
+            if (bm_id == rb_intern("linked")) prefs.frameInfo.blockMode = LZ4F_blockLinked;
+            else if (bm_id == rb_intern("independent")) prefs.frameInfo.blockMode = LZ4F_blockIndependent;
+        }
+
+        VALUE checksum = rb_hash_aref(options, ID2SYM(rb_intern("checksum")));
+        if (RTEST(checksum)) {
+            prefs.frameInfo.contentChecksumFlag = LZ4F_contentChecksumEnabled;
+        }
+
+        VALUE comp_level = rb_hash_aref(options, ID2SYM(rb_intern("compression_level")));
+        if (!NIL_P(comp_level)) {
+            prefs.compressionLevel = NUM2INT(comp_level);
+        }
+    }
+
+    size_t dst_capacity = LZ4F_compressFrameBound(src_size, &prefs);
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char* dst = RSTRING_PTR(result);
+
+    size_t compressed_size = LZ4F_compressFrame(dst, dst_capacity, src, src_size, &prefs);
+
+    if (LZ4F_isError(compressed_size)) {
+        rb_raise(eLZ4FrameError, "Frame compression failed: %s",
+                 LZ4F_getErrorName(compressed_size));
+    }
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+/*
+ * call-seq:
+ *   LZ4Frame.decompress_frame(source) -> decompressed_string
+ *
+ * Decompresses a complete LZ4 frame.
+ */
+static VALUE
+lz4frame_decompress_frame_wrapper(VALUE self, VALUE source)
+{
+    Check_Type(source, T_STRING);
+
+    const char* src = RSTRING_PTR(source);
+    size_t src_size = RSTRING_LEN(source);
+
+    /* Create decompression context */
+    LZ4F_dctx* dctx;
+    LZ4F_errorCode_t err = LZ4F_createDecompressionContext(&dctx, LZ4F_VERSION);
+    if (LZ4F_isError(err)) {
+        rb_raise(eLZ4FrameError, "Failed to create decompression context: %s",
+                 LZ4F_getErrorName(err));
+    }
+
+    /* Allocate output buffer - start with 4x input size, may need to grow */
+    size_t dst_capacity = src_size * 4;
+    if (dst_capacity < 1024) dst_capacity = 1024;
+
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char* dst = RSTRING_PTR(result);
+    size_t total_decompressed = 0;
+
+    size_t src_pos = 0;
+
+    while (src_pos < src_size) {
+        size_t src_remaining = src_size - src_pos;
+        size_t dst_remaining = dst_capacity - total_decompressed;
+
+        /* Ensure we have space, grow if needed */
+        if (dst_remaining < 64 * 1024) {
+            dst_capacity *= 2;
+            rb_str_resize(result, dst_capacity);
+            dst = RSTRING_PTR(result);
+            dst_remaining = dst_capacity - total_decompressed;
+        }
+
+        size_t ret = LZ4F_decompress(dctx,
+                                     dst + total_decompressed, &dst_remaining,
+                                     src + src_pos, &src_remaining,
+                                     NULL);
+
+        if (LZ4F_isError(ret)) {
+            LZ4F_freeDecompressionContext(dctx);
+            rb_raise(eLZ4FrameError, "Frame decompression failed: %s",
+                     LZ4F_getErrorName(ret));
+        }
+
+        src_pos += src_remaining;
+        total_decompressed += dst_remaining;
+
+        /* ret == 0 means frame is complete */
+        if (ret == 0) {
+            break;
+        }
+    }
+
+    LZ4F_freeDecompressionContext(dctx);
+
+    rb_str_set_len(result, total_decompressed);
+    return result;
+}
+
+/*
+ * call-seq:
+ *   LZ4Frame.version -> integer
+ *
+ * Returns the LZ4F API version number.
+ */
+static VALUE
+lz4frame_version_wrapper(VALUE self)
+{
+    return INT2NUM(LZ4F_getVersion());
+}
+
+/*
+ * call-seq:
+ *   LZ4Frame.compression_level_max -> integer
+ *
+ * Returns the maximum compression level supported.
+ */
+static VALUE
+lz4frame_compression_level_max_wrapper(VALUE self)
+{
+    return INT2NUM(LZ4F_compressionLevel_max());
+}
+
+/*
+ * Extension initialization
+ */
+void
+Init_lz4_native(void)
+{
+    /* Main module */
+    mLZ4Native = rb_define_module("LZ4Native");
+
+    /* LZ4 basic module */
+    mLZ4 = rb_define_module_under(mLZ4Native, "LZ4");
+    rb_define_singleton_method(mLZ4, "compress_default", lz4_compress_default_wrapper, 1);
+    rb_define_singleton_method(mLZ4, "decompress_safe", lz4_decompress_safe_wrapper, 2);
+    rb_define_singleton_method(mLZ4, "compress_bound", lz4_compress_bound_wrapper, 1);
+    rb_define_singleton_method(mLZ4, "compress_fast", lz4_compress_fast_wrapper, 2);
+    rb_define_singleton_method(mLZ4, "version_number", lz4_version_number_wrapper, 0);
+    rb_define_singleton_method(mLZ4, "version_string", lz4_version_string_wrapper, 0);
+
+    /* LZ4HC module */
+    mLZ4HC = rb_define_module_under(mLZ4Native, "LZ4HC");
+    rb_define_singleton_method(mLZ4HC, "compress", lz4hc_compress_wrapper, -1);
+    rb_define_singleton_method(mLZ4HC, "sizeof_state", lz4hc_sizeof_state_wrapper, 0);
+
+    /* LZ4Frame module */
+    mLZ4Frame = rb_define_module_under(mLZ4Native, "LZ4Frame");
+    rb_define_singleton_method(mLZ4Frame, "compress_frame", lz4frame_compress_frame_wrapper, -1);
+    rb_define_singleton_method(mLZ4Frame, "decompress_frame", lz4frame_decompress_frame_wrapper, 1);
+    rb_define_singleton_method(mLZ4Frame, "version", lz4frame_version_wrapper, 0);
+    rb_define_singleton_method(mLZ4Frame, "compression_level_max", lz4frame_compression_level_max_wrapper, 0);
+
+    /* Exception classes */
+    eLZ4Error = rb_define_class_under(mLZ4Native, "Error", rb_eStandardError);
+    eLZ4CompressionError = rb_define_class_under(mLZ4Native, "CompressionError", eLZ4Error);
+    eLZ4DecompressionError = rb_define_class_under(mLZ4Native, "DecompressionError", eLZ4Error);
+    eLZ4FrameError = rb_define_class_under(mLZ4Native, "FrameError", eLZ4Error);
+
+    /* Constants */
+    rb_define_const(mLZ4, "MAX_INPUT_SIZE", INT2NUM(LZ4_MAX_INPUT_SIZE));
+    rb_define_const(mLZ4HC, "CLEVEL_MIN", INT2NUM(LZ4HC_CLEVEL_MIN));
+    rb_define_const(mLZ4HC, "CLEVEL_DEFAULT", INT2NUM(LZ4HC_CLEVEL_DEFAULT));
+    rb_define_const(mLZ4HC, "CLEVEL_MAX", INT2NUM(LZ4HC_CLEVEL_MAX));
+}