zstd-native-ruby 1.0.0 → 1.0.2

data/ext/zstd_native/zstd_native.c

@@ -0,0 +1,852 @@
+#include <ruby.h>
+#include "zstd.h"
+
+static VALUE mZstdNative;
+static VALUE eZstdError;
+static VALUE cCCtx;
+static VALUE cDCtx;
+static VALUE cCStream;
+static VALUE cDStream;
+static VALUE cCDict;
+static VALUE cDDict;
+
+/* Forward declarations of data types */
+static const rb_data_type_t cctx_type;
+static const rb_data_type_t dctx_type;
+static const rb_data_type_t cstream_type;
+static const rb_data_type_t dstream_type;
+static const rb_data_type_t cdict_type;
+static const rb_data_type_t ddict_type;
+
+/* Helper function to check for errors */
+static void check_zstd_error(size_t code, const char *msg) {
+    if (ZSTD_isError(code)) {
+        rb_raise(eZstdError, "%s: %s", msg, ZSTD_getErrorName(code));
+    }
+}
+
+/* Module methods */
+
+static VALUE zstd_version_number(VALUE self) {
+    return UINT2NUM(ZSTD_versionNumber());
+}
+
+static VALUE zstd_version_string(VALUE self) {
+    return rb_str_new_cstr(ZSTD_versionString());
+}
+
+static VALUE zstd_compress(int argc, VALUE *argv, VALUE self) {
+    VALUE data, level_val;
+    rb_scan_args(argc, argv, "11", &data, &level_val);
+
+    Check_Type(data, T_STRING);
+    int level = NIL_P(level_val) ? ZSTD_CLEVEL_DEFAULT : NUM2INT(level_val);
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    size_t dst_capacity = ZSTD_compressBound(src_size);
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t compressed_size = ZSTD_compress(dst, dst_capacity, src, src_size, level);
+    check_zstd_error(compressed_size, "Compression failed");
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+static VALUE zstd_decompress(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    unsigned long long const dst_capacity = ZSTD_getFrameContentSize(src, src_size);
+
+    if (dst_capacity == ZSTD_CONTENTSIZE_ERROR) {
+        rb_raise(eZstdError, "Invalid compressed data");
+    }
+    if (dst_capacity == ZSTD_CONTENTSIZE_UNKNOWN) {
+        rb_raise(eZstdError, "Content size unknown");
+    }
+
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t decompressed_size = ZSTD_decompress(dst, dst_capacity, src, src_size);
+    check_zstd_error(decompressed_size, "Decompression failed");
+
+    rb_str_set_len(result, decompressed_size);
+    return result;
+}
+
+static VALUE zstd_compress_bound(VALUE self, VALUE size_val) {
+    size_t src_size = NUM2SIZET(size_val);
+    return SIZET2NUM(ZSTD_compressBound(src_size));
+}
+
+static VALUE zstd_frame_content_size(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    unsigned long long size = ZSTD_getFrameContentSize(src, src_size);
+    if (size == ZSTD_CONTENTSIZE_ERROR) {
+        rb_raise(eZstdError, "Invalid frame");
+    }
+    if (size == ZSTD_CONTENTSIZE_UNKNOWN) {
+        return Qnil;
+    }
+    return ULL2NUM(size);
+}
+
+static VALUE zstd_find_frame_compressed_size(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    size_t size = ZSTD_findFrameCompressedSize(src, src_size);
+    check_zstd_error(size, "Failed to find frame size");
+    return SIZET2NUM(size);
+}
+
+static VALUE zstd_min_clevel(VALUE self) {
+    return INT2NUM(ZSTD_minCLevel());
+}
+
+static VALUE zstd_max_clevel(VALUE self) {
+    return INT2NUM(ZSTD_maxCLevel());
+}
+
+static VALUE zstd_default_clevel(VALUE self) {
+    return INT2NUM(ZSTD_defaultCLevel());
+}
+
+/* CCtx class */
+
+static void cctx_free(void *ptr) {
+    if (ptr) {
+        ZSTD_freeCCtx((ZSTD_CCtx*)ptr);
+    }
+}
+
+static const rb_data_type_t cctx_type = {
+    "ZstdNative::CCtx",
+    {NULL, cctx_free, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE cctx_alloc(VALUE klass) {
+    ZSTD_CCtx *ctx = ZSTD_createCCtx();
+    if (!ctx) {
+        rb_raise(eZstdError, "Failed to create compression context");
+    }
+    return TypedData_Wrap_Struct(klass, &cctx_type, ctx);
+}
+
+static VALUE cctx_compress(VALUE self, VALUE data, VALUE level_val) {
+    Check_Type(data, T_STRING);
+    int level = NUM2INT(level_val);
+
+    ZSTD_CCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_CCtx, &cctx_type, ctx);
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    size_t dst_capacity = ZSTD_compressBound(src_size);
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t compressed_size = ZSTD_compressCCtx(ctx, dst, dst_capacity, src, src_size, level);
+    check_zstd_error(compressed_size, "CCtx compression failed");
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+static VALUE cctx_reset(VALUE self) {
+    ZSTD_CCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_CCtx, &cctx_type, ctx);
+
+    size_t result = ZSTD_CCtx_reset(ctx, ZSTD_reset_session_only);
+    check_zstd_error(result, "CCtx reset failed");
+    return Qnil;
+}
+
+static VALUE cctx_load_dictionary(VALUE self, VALUE dict) {
+    Check_Type(dict, T_STRING);
+
+    ZSTD_CCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_CCtx, &cctx_type, ctx);
+
+    const char *dict_data = RSTRING_PTR(dict);
+    size_t dict_size = RSTRING_LEN(dict);
+
+    size_t result = ZSTD_CCtx_loadDictionary(ctx, dict_data, dict_size);
+    check_zstd_error(result, "Failed to load dictionary");
+    return Qnil;
+}
+
+static VALUE cctx_ref_cdict(VALUE self, VALUE cdict_val) {
+    ZSTD_CCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_CCtx, &cctx_type, ctx);
+
+    ZSTD_CDict *cdict;
+    TypedData_Get_Struct(cdict_val, ZSTD_CDict, &cdict_type, cdict);
+
+    size_t result = ZSTD_CCtx_refCDict(ctx, cdict);
+    check_zstd_error(result, "Failed to reference CDict");
+    return Qnil;
+}
+
+static VALUE cctx_ref_prefix(VALUE self, VALUE prefix) {
+    Check_Type(prefix, T_STRING);
+
+    ZSTD_CCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_CCtx, &cctx_type, ctx);
+
+    const char *prefix_data = RSTRING_PTR(prefix);
+    size_t prefix_size = RSTRING_LEN(prefix);
+
+    size_t result = ZSTD_CCtx_refPrefix(ctx, prefix_data, prefix_size);
+    check_zstd_error(result, "Failed to reference prefix");
+    return Qnil;
+}
+
+static VALUE cctx_sizeof(VALUE self) {
+    ZSTD_CCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_CCtx, &cctx_type, ctx);
+    return SIZET2NUM(ZSTD_sizeof_CCtx(ctx));
+}
+
+/* DCtx class */
+
+static void dctx_free(void *ptr) {
+    if (ptr) {
+        ZSTD_freeDCtx((ZSTD_DCtx*)ptr);
+    }
+}
+
+static const rb_data_type_t dctx_type = {
+    "ZstdNative::DCtx",
+    {NULL, dctx_free, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE dctx_alloc(VALUE klass) {
+    ZSTD_DCtx *ctx = ZSTD_createDCtx();
+    if (!ctx) {
+        rb_raise(eZstdError, "Failed to create decompression context");
+    }
+    return TypedData_Wrap_Struct(klass, &dctx_type, ctx);
+}
+
+static VALUE dctx_decompress(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    ZSTD_DCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_DCtx, &dctx_type, ctx);
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    unsigned long long const dst_capacity = ZSTD_getFrameContentSize(src, src_size);
+
+    if (dst_capacity == ZSTD_CONTENTSIZE_ERROR) {
+        rb_raise(eZstdError, "Invalid compressed data");
+    }
+    if (dst_capacity == ZSTD_CONTENTSIZE_UNKNOWN) {
+        rb_raise(eZstdError, "Content size unknown");
+    }
+
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t decompressed_size = ZSTD_decompressDCtx(ctx, dst, dst_capacity, src, src_size);
+    check_zstd_error(decompressed_size, "DCtx decompression failed");
+
+    rb_str_set_len(result, decompressed_size);
+    return result;
+}
+
+static VALUE dctx_reset(VALUE self) {
+    ZSTD_DCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_DCtx, &dctx_type, ctx);
+
+    size_t result = ZSTD_DCtx_reset(ctx, ZSTD_reset_session_only);
+    check_zstd_error(result, "DCtx reset failed");
+    return Qnil;
+}
+
+static VALUE dctx_load_dictionary(VALUE self, VALUE dict) {
+    Check_Type(dict, T_STRING);
+
+    ZSTD_DCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_DCtx, &dctx_type, ctx);
+
+    const char *dict_data = RSTRING_PTR(dict);
+    size_t dict_size = RSTRING_LEN(dict);
+
+    size_t result = ZSTD_DCtx_loadDictionary(ctx, dict_data, dict_size);
+    check_zstd_error(result, "Failed to load dictionary");
+    return Qnil;
+}
+
+static VALUE dctx_ref_ddict(VALUE self, VALUE ddict_val) {
+    ZSTD_DCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_DCtx, &dctx_type, ctx);
+
+    ZSTD_DDict *ddict;
+    TypedData_Get_Struct(ddict_val, ZSTD_DDict, &ddict_type, ddict);
+
+    size_t result = ZSTD_DCtx_refDDict(ctx, ddict);
+    check_zstd_error(result, "Failed to reference DDict");
+    return Qnil;
+}
+
+static VALUE dctx_ref_prefix(VALUE self, VALUE prefix) {
+    Check_Type(prefix, T_STRING);
+
+    ZSTD_DCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_DCtx, &dctx_type, ctx);
+
+    const char *prefix_data = RSTRING_PTR(prefix);
+    size_t prefix_size = RSTRING_LEN(prefix);
+
+    size_t result = ZSTD_DCtx_refPrefix(ctx, prefix_data, prefix_size);
+    check_zstd_error(result, "Failed to reference prefix");
+    return Qnil;
+}
+
+static VALUE dctx_sizeof(VALUE self) {
+    ZSTD_DCtx *ctx;
+    TypedData_Get_Struct(self, ZSTD_DCtx, &dctx_type, ctx);
+    return SIZET2NUM(ZSTD_sizeof_DCtx(ctx));
+}
+
+/* CStream class */
+
+static void cstream_free(void *ptr) {
+    if (ptr) {
+        ZSTD_freeCStream((ZSTD_CStream*)ptr);
+    }
+}
+
+static const rb_data_type_t cstream_type = {
+    "ZstdNative::CStream",
+    {NULL, cstream_free, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE cstream_initialize(int argc, VALUE *argv, VALUE self) {
+    VALUE opts;
+    rb_scan_args(argc, argv, "01", &opts);
+
+    int level = ZSTD_CLEVEL_DEFAULT;
+    if (!NIL_P(opts)) {
+        Check_Type(opts, T_HASH);
+        VALUE level_val = rb_hash_aref(opts, ID2SYM(rb_intern("level")));
+        if (!NIL_P(level_val)) {
+            level = NUM2INT(level_val);
+        }
+    }
+
+    ZSTD_CStream *stream = ZSTD_createCStream();
+    if (!stream) {
+        rb_raise(eZstdError, "Failed to create compression stream");
+    }
+
+    size_t result = ZSTD_initCStream(stream, level);
+    if (ZSTD_isError(result)) {
+        ZSTD_freeCStream(stream);
+        rb_raise(eZstdError, "Failed to initialize compression stream: %s", ZSTD_getErrorName(result));
+    }
+
+    DATA_PTR(self) = stream;
+    return self;
+}
+
+static VALUE cstream_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &cstream_type, NULL);
+}
+
+static VALUE cstream_compress(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    ZSTD_CStream *stream;
+    TypedData_Get_Struct(self, ZSTD_CStream, &cstream_type, stream);
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    ZSTD_inBuffer input = {src, src_size, 0};
+
+    size_t out_capacity = ZSTD_CStreamOutSize();
+    VALUE result = rb_str_buf_new(out_capacity);
+    char *dst = RSTRING_PTR(result);
+    size_t total_written = 0;
+
+    while (input.pos < input.size) {
+        ZSTD_outBuffer output = {dst + total_written, out_capacity - total_written, 0};
+        size_t remaining = ZSTD_compressStream(stream, &output, &input);
+        check_zstd_error(remaining, "Stream compression failed");
+        total_written += output.pos;
+
+        if (total_written >= out_capacity) {
+            out_capacity *= 2;
+            rb_str_resize(result, out_capacity);
+            dst = RSTRING_PTR(result);
+        }
+    }
+
+    rb_str_set_len(result, total_written);
+    return result;
+}
+
+static VALUE cstream_flush(VALUE self) {
+    ZSTD_CStream *stream;
+    TypedData_Get_Struct(self, ZSTD_CStream, &cstream_type, stream);
+
+    size_t out_capacity = ZSTD_CStreamOutSize();
+    VALUE result = rb_str_buf_new(out_capacity);
+    char *dst = RSTRING_PTR(result);
+    size_t total_written = 0;
+
+    size_t remaining;
+    do {
+        ZSTD_outBuffer output = {dst + total_written, out_capacity - total_written, 0};
+        remaining = ZSTD_flushStream(stream, &output);
+        check_zstd_error(remaining, "Stream flush failed");
+        total_written += output.pos;
+
+        if (remaining > 0 && total_written >= out_capacity) {
+            out_capacity *= 2;
+            rb_str_resize(result, out_capacity);
+            dst = RSTRING_PTR(result);
+        }
+    } while (remaining > 0);
+
+    rb_str_set_len(result, total_written);
+    return result;
+}
+
+static VALUE cstream_finish(VALUE self) {
+    ZSTD_CStream *stream;
+    TypedData_Get_Struct(self, ZSTD_CStream, &cstream_type, stream);
+
+    size_t out_capacity = ZSTD_CStreamOutSize();
+    VALUE result = rb_str_buf_new(out_capacity);
+    char *dst = RSTRING_PTR(result);
+    size_t total_written = 0;
+
+    size_t remaining;
+    do {
+        ZSTD_outBuffer output = {dst + total_written, out_capacity - total_written, 0};
+        remaining = ZSTD_endStream(stream, &output);
+        check_zstd_error(remaining, "Stream end failed");
+        total_written += output.pos;
+
+        if (remaining > 0 && total_written >= out_capacity) {
+            out_capacity *= 2;
+            rb_str_resize(result, out_capacity);
+            dst = RSTRING_PTR(result);
+        }
+    } while (remaining > 0);
+
+    rb_str_set_len(result, total_written);
+    return result;
+}
+
+static VALUE cstream_in_size(VALUE self) {
+    return SIZET2NUM(ZSTD_CStreamInSize());
+}
+
+static VALUE cstream_out_size(VALUE self) {
+    return SIZET2NUM(ZSTD_CStreamOutSize());
+}
+
+/* DStream class */
+
+static void dstream_free(void *ptr) {
+    if (ptr) {
+        ZSTD_freeDStream((ZSTD_DStream*)ptr);
+    }
+}
+
+static const rb_data_type_t dstream_type = {
+    "ZstdNative::DStream",
+    {NULL, dstream_free, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE dstream_initialize(VALUE self) {
+    ZSTD_DStream *stream = ZSTD_createDStream();
+    if (!stream) {
+        rb_raise(eZstdError, "Failed to create decompression stream");
+    }
+
+    size_t result = ZSTD_initDStream(stream);
+    if (ZSTD_isError(result)) {
+        ZSTD_freeDStream(stream);
+        rb_raise(eZstdError, "Failed to initialize decompression stream: %s", ZSTD_getErrorName(result));
+    }
+
+    DATA_PTR(self) = stream;
+    return self;
+}
+
+static VALUE dstream_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &dstream_type, NULL);
+}
+
+static VALUE dstream_decompress(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+
+    ZSTD_DStream *stream;
+    TypedData_Get_Struct(self, ZSTD_DStream, &dstream_type, stream);
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    ZSTD_inBuffer input = {src, src_size, 0};
+
+    size_t out_capacity = ZSTD_DStreamOutSize();
+    VALUE result = rb_str_buf_new(out_capacity);
+    char *dst = RSTRING_PTR(result);
+    size_t total_written = 0;
+
+    while (input.pos < input.size) {
+        ZSTD_outBuffer output = {dst + total_written, out_capacity - total_written, 0};
+        size_t remaining = ZSTD_decompressStream(stream, &output, &input);
+        check_zstd_error(remaining, "Stream decompression failed");
+        total_written += output.pos;
+
+        if (total_written >= out_capacity && input.pos < input.size) {
+            out_capacity *= 2;
+            rb_str_resize(result, out_capacity);
+            dst = RSTRING_PTR(result);
+        }
+    }
+
+    rb_str_set_len(result, total_written);
+    return result;
+}
+
+static VALUE dstream_in_size(VALUE self) {
+    return SIZET2NUM(ZSTD_DStreamInSize());
+}
+
+static VALUE dstream_out_size(VALUE self) {
+    return SIZET2NUM(ZSTD_DStreamOutSize());
+}
+
+/* CDict class */
+
+static void cdict_free(void *ptr) {
+    if (ptr) {
+        ZSTD_freeCDict((ZSTD_CDict*)ptr);
+    }
+}
+
+static const rb_data_type_t cdict_type = {
+    "ZstdNative::CDict",
+    {NULL, cdict_free, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE cdict_initialize(int argc, VALUE *argv, VALUE self) {
+    VALUE dict, level_val;
+    rb_scan_args(argc, argv, "11", &dict, &level_val);
+
+    Check_Type(dict, T_STRING);
+    int level = NIL_P(level_val) ? ZSTD_CLEVEL_DEFAULT : NUM2INT(level_val);
+
+    const char *dict_data = RSTRING_PTR(dict);
+    size_t dict_size = RSTRING_LEN(dict);
+
+    ZSTD_CDict *cdict = ZSTD_createCDict(dict_data, dict_size, level);
+    if (!cdict) {
+        rb_raise(eZstdError, "Failed to create compression dictionary");
+    }
+
+    DATA_PTR(self) = cdict;
+    return self;
+}
+
+static VALUE cdict_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &cdict_type, NULL);
+}
+
+static VALUE cdict_sizeof(VALUE self) {
+    ZSTD_CDict *cdict;
+    TypedData_Get_Struct(self, ZSTD_CDict, &cdict_type, cdict);
+    return SIZET2NUM(ZSTD_sizeof_CDict(cdict));
+}
+
+/* DDict class */
+
+static void ddict_free(void *ptr) {
+    if (ptr) {
+        ZSTD_freeDDict((ZSTD_DDict*)ptr);
+    }
+}
+
+static const rb_data_type_t ddict_type = {
+    "ZstdNative::DDict",
+    {NULL, ddict_free, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE ddict_initialize(VALUE self, VALUE dict) {
+    Check_Type(dict, T_STRING);
+
+    const char *dict_data = RSTRING_PTR(dict);
+    size_t dict_size = RSTRING_LEN(dict);
+
+    ZSTD_DDict *ddict = ZSTD_createDDict(dict_data, dict_size);
+    if (!ddict) {
+        rb_raise(eZstdError, "Failed to create decompression dictionary");
+    }
+
+    DATA_PTR(self) = ddict;
+    return self;
+}
+
+static VALUE ddict_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &ddict_type, NULL);
+}
+
+static VALUE ddict_sizeof(VALUE self) {
+    ZSTD_DDict *ddict;
+    TypedData_Get_Struct(self, ZSTD_DDict, &ddict_type, ddict);
+    return SIZET2NUM(ZSTD_sizeof_DDict(ddict));
+}
+
+/* Dictionary helper functions */
+
+static VALUE zstd_compress_using_dict(int argc, VALUE *argv, VALUE self) {
+    VALUE data, dict, level_val;
+    rb_scan_args(argc, argv, "21", &data, &dict, &level_val);
+
+    Check_Type(data, T_STRING);
+    Check_Type(dict, T_STRING);
+    int level = NIL_P(level_val) ? ZSTD_CLEVEL_DEFAULT : NUM2INT(level_val);
+
+    ZSTD_CCtx *ctx = ZSTD_createCCtx();
+    if (!ctx) {
+        rb_raise(eZstdError, "Failed to create compression context");
+    }
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+    const char *dict_data = RSTRING_PTR(dict);
+    size_t dict_size = RSTRING_LEN(dict);
+
+    size_t dst_capacity = ZSTD_compressBound(src_size);
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t compressed_size = ZSTD_compress_usingDict(ctx, dst, dst_capacity, src, src_size, dict_data, dict_size, level);
+    ZSTD_freeCCtx(ctx);
+    check_zstd_error(compressed_size, "Dictionary compression failed");
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+static VALUE zstd_decompress_using_dict(VALUE self, VALUE data, VALUE dict) {
+    Check_Type(data, T_STRING);
+    Check_Type(dict, T_STRING);
+
+    ZSTD_DCtx *ctx = ZSTD_createDCtx();
+    if (!ctx) {
+        rb_raise(eZstdError, "Failed to create decompression context");
+    }
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+    const char *dict_data = RSTRING_PTR(dict);
+    size_t dict_size = RSTRING_LEN(dict);
+
+    unsigned long long const dst_capacity = ZSTD_getFrameContentSize(src, src_size);
+
+    if (dst_capacity == ZSTD_CONTENTSIZE_ERROR) {
+        ZSTD_freeDCtx(ctx);
+        rb_raise(eZstdError, "Invalid compressed data");
+    }
+    if (dst_capacity == ZSTD_CONTENTSIZE_UNKNOWN) {
+        ZSTD_freeDCtx(ctx);
+        rb_raise(eZstdError, "Content size unknown");
+    }
+
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t decompressed_size = ZSTD_decompress_usingDict(ctx, dst, dst_capacity, src, src_size, dict_data, dict_size);
+    ZSTD_freeDCtx(ctx);
+    check_zstd_error(decompressed_size, "Dictionary decompression failed");
+
+    rb_str_set_len(result, decompressed_size);
+    return result;
+}
+
+static VALUE zstd_compress_using_cdict(VALUE self, VALUE data, VALUE cdict_val) {
+    Check_Type(data, T_STRING);
+
+    ZSTD_CDict *cdict;
+    TypedData_Get_Struct(cdict_val, ZSTD_CDict, &cdict_type, cdict);
+
+    ZSTD_CCtx *ctx = ZSTD_createCCtx();
+    if (!ctx) {
+        rb_raise(eZstdError, "Failed to create compression context");
+    }
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    size_t dst_capacity = ZSTD_compressBound(src_size);
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t compressed_size = ZSTD_compress_usingCDict(ctx, dst, dst_capacity, src, src_size, cdict);
+    ZSTD_freeCCtx(ctx);
+    check_zstd_error(compressed_size, "CDict compression failed");
+
+    rb_str_set_len(result, compressed_size);
+    return result;
+}
+
+static VALUE zstd_decompress_using_ddict(VALUE self, VALUE data, VALUE ddict_val) {
+    Check_Type(data, T_STRING);
+
+    ZSTD_DDict *ddict;
+    TypedData_Get_Struct(ddict_val, ZSTD_DDict, &ddict_type, ddict);
+
+    ZSTD_DCtx *ctx = ZSTD_createDCtx();
+    if (!ctx) {
+        rb_raise(eZstdError, "Failed to create decompression context");
+    }
+
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+
+    unsigned long long const dst_capacity = ZSTD_getFrameContentSize(src, src_size);
+
+    if (dst_capacity == ZSTD_CONTENTSIZE_ERROR) {
+        ZSTD_freeDCtx(ctx);
+        rb_raise(eZstdError, "Invalid compressed data");
+    }
+    if (dst_capacity == ZSTD_CONTENTSIZE_UNKNOWN) {
+        ZSTD_freeDCtx(ctx);
+        rb_raise(eZstdError, "Content size unknown");
+    }
+
+    VALUE result = rb_str_buf_new(dst_capacity);
+    char *dst = RSTRING_PTR(result);
+
+    size_t decompressed_size = ZSTD_decompress_usingDDict(ctx, dst, dst_capacity, src, src_size, ddict);
+    ZSTD_freeDCtx(ctx);
+    check_zstd_error(decompressed_size, "DDict decompression failed");
+
+    rb_str_set_len(result, decompressed_size);
+    return result;
+}
+
+static VALUE zstd_dict_id_from_cdict(VALUE self, VALUE cdict_val) {
+    ZSTD_CDict *cdict;
+    TypedData_Get_Struct(cdict_val, ZSTD_CDict, &cdict_type, cdict);
+    return UINT2NUM(ZSTD_getDictID_fromCDict(cdict));
+}
+
+static VALUE zstd_dict_id_from_ddict(VALUE self, VALUE ddict_val) {
+    ZSTD_DDict *ddict;
+    TypedData_Get_Struct(ddict_val, ZSTD_DDict, &ddict_type, ddict);
+    return UINT2NUM(ZSTD_getDictID_fromDDict(ddict));
+}
+
+static VALUE zstd_dict_id_from_frame(VALUE self, VALUE data) {
+    Check_Type(data, T_STRING);
+    const char *src = RSTRING_PTR(data);
+    size_t src_size = RSTRING_LEN(data);
+    return UINT2NUM(ZSTD_getDictID_fromFrame(src, src_size));
+}
+
+/* Module initialization */
+
+void Init_zstd_native(void) {
+    mZstdNative = rb_define_module("ZstdNative");
+    eZstdError = rb_define_class_under(mZstdNative, "Error", rb_eStandardError);
+
+    /* Module methods */
+    rb_define_module_function(mZstdNative, "version_number", zstd_version_number, 0);
+    rb_define_module_function(mZstdNative, "version_string", zstd_version_string, 0);
+    rb_define_module_function(mZstdNative, "compress", zstd_compress, -1);
+    rb_define_module_function(mZstdNative, "decompress", zstd_decompress, 1);
+    rb_define_module_function(mZstdNative, "compress_bound", zstd_compress_bound, 1);
+    rb_define_module_function(mZstdNative, "frame_content_size", zstd_frame_content_size, 1);
+    rb_define_module_function(mZstdNative, "find_frame_compressed_size", zstd_find_frame_compressed_size, 1);
+    rb_define_module_function(mZstdNative, "min_clevel", zstd_min_clevel, 0);
+    rb_define_module_function(mZstdNative, "max_clevel", zstd_max_clevel, 0);
+    rb_define_module_function(mZstdNative, "default_clevel", zstd_default_clevel, 0);
+
+    /* Dictionary functions */
+    rb_define_module_function(mZstdNative, "compress_using_dict", zstd_compress_using_dict, -1);
+    rb_define_module_function(mZstdNative, "decompress_using_dict", zstd_decompress_using_dict, 2);
+    rb_define_module_function(mZstdNative, "compress_using_cdict", zstd_compress_using_cdict, 2);
+    rb_define_module_function(mZstdNative, "decompress_using_ddict", zstd_decompress_using_ddict, 2);
+    rb_define_module_function(mZstdNative, "dict_id_from_cdict", zstd_dict_id_from_cdict, 1);
+    rb_define_module_function(mZstdNative, "dict_id_from_ddict", zstd_dict_id_from_ddict, 1);
+    rb_define_module_function(mZstdNative, "dict_id_from_frame", zstd_dict_id_from_frame, 1);
+
+    /* CCtx class */
+    cCCtx = rb_define_class_under(mZstdNative, "CCtx", rb_cObject);
+    rb_define_alloc_func(cCCtx, cctx_alloc);
+    rb_define_method(cCCtx, "compress", cctx_compress, 2);
+    rb_define_method(cCCtx, "reset", cctx_reset, 0);
+    rb_define_method(cCCtx, "load_dictionary", cctx_load_dictionary, 1);
+    rb_define_method(cCCtx, "ref_cdict", cctx_ref_cdict, 1);
+    rb_define_method(cCCtx, "ref_prefix", cctx_ref_prefix, 1);
+    rb_define_method(cCCtx, "sizeof", cctx_sizeof, 0);
+
+    /* DCtx class */
+    cDCtx = rb_define_class_under(mZstdNative, "DCtx", rb_cObject);
+    rb_define_alloc_func(cDCtx, dctx_alloc);
+    rb_define_method(cDCtx, "decompress", dctx_decompress, 1);
+    rb_define_method(cDCtx, "reset", dctx_reset, 0);
+    rb_define_method(cDCtx, "load_dictionary", dctx_load_dictionary, 1);
+    rb_define_method(cDCtx, "ref_ddict", dctx_ref_ddict, 1);
+    rb_define_method(cDCtx, "ref_prefix", dctx_ref_prefix, 1);
+    rb_define_method(cDCtx, "sizeof", dctx_sizeof, 0);
+
+    /* CStream class */
+    cCStream = rb_define_class_under(mZstdNative, "CStream", rb_cObject);
+    rb_define_alloc_func(cCStream, cstream_alloc);
+    rb_define_method(cCStream, "initialize", cstream_initialize, -1);
+    rb_define_method(cCStream, "compress", cstream_compress, 1);
+    rb_define_method(cCStream, "flush", cstream_flush, 0);
+    rb_define_method(cCStream, "finish", cstream_finish, 0);
+    rb_define_singleton_method(cCStream, "in_size", cstream_in_size, 0);
+    rb_define_singleton_method(cCStream, "out_size", cstream_out_size, 0);
+
+    /* DStream class */
+    cDStream = rb_define_class_under(mZstdNative, "DStream", rb_cObject);
+    rb_define_alloc_func(cDStream, dstream_alloc);
+    rb_define_method(cDStream, "initialize", dstream_initialize, 0);
+    rb_define_method(cDStream, "decompress", dstream_decompress, 1);
+    rb_define_singleton_method(cDStream, "in_size", dstream_in_size, 0);
+    rb_define_singleton_method(cDStream, "out_size", dstream_out_size, 0);
+
+    /* CDict class */
+    cCDict = rb_define_class_under(mZstdNative, "CDict", rb_cObject);
+    rb_define_alloc_func(cCDict, cdict_alloc);
+    rb_define_method(cCDict, "initialize", cdict_initialize, -1);
+    rb_define_method(cCDict, "sizeof", cdict_sizeof, 0);
+
+    /* DDict class */
+    cDDict = rb_define_class_under(mZstdNative, "DDict", rb_cObject);
+    rb_define_alloc_func(cDDict, ddict_alloc);
+    rb_define_method(cDDict, "initialize", ddict_initialize, 1);
+    rb_define_method(cDDict, "sizeof", ddict_sizeof, 0);
+}