Module: MultiCompress

Defined in:

lib/multi_compress.rb,
lib/multi_compress/version.rb,
ext/multi_compress/multi_compress.c

Defined Under Namespace

Modules: Brotli, LZ4, Zstd Classes: DataError, Deflater, Dictionary, Error, Inflater, LevelError, MemError, Reader, StreamError, UnsupportedError, Writer

Constant Summary

FASTEST =

:fastest

DEFAULT =

:default

BEST =

:best

VERSION =

"0.1.2"

Class Method Summary

• .adler32(*args) ⇒ Object
• .algo_from_ext(path) ⇒ Object
• .algorithms ⇒ Object
• .available?(algo_sym) ⇒ Boolean
• .brotli(data, level: nil) ⇒ Object
• .brotli_decompress(data) ⇒ Object
• .compress(*args) ⇒ Object
• .crc32(*args) ⇒ Object
• .decompress(*args) ⇒ Object
• .lz4(data, level: nil) ⇒ Object
• .lz4_decompress(data) ⇒ Object
• .version(algo_sym) ⇒ Object
• .zstd(data, level: nil) ⇒ Object
• .zstd_decompress(data) ⇒ Object

Class Method Details

.adler32(*args) ⇒ Object

# File 'ext/multi_compress/multi_compress.c', line 946

static VALUE compress_adler32(int argc, VALUE *argv, VALUE self) {
    VALUE data, prev;
    rb_scan_args(argc, argv, "11", &data, &prev);
    StringValue(data);

    const uint8_t *src = (const uint8_t *)RSTRING_PTR(data);
    size_t len = RSTRING_LEN(data);
    uint32_t adler = NIL_P(prev) ? 1 : NUM2UINT(prev);

    uint32_t s1 = adler & 0xFFFF;
    uint32_t s2 = (adler >> 16) & 0xFFFF;
    const uint32_t BASE = 65521;

    while (len > 0) {
        size_t chunk = len > 5552 ? 5552 : len;
        len -= chunk;
        for (size_t i = 0; i < chunk; i++) {
            s1 += src[i];
            s2 += s1;
        }
        s1 %= BASE;
        s2 %= BASE;
        src += chunk;
    }

    return UINT2NUM((s2 << 16) | s1);
}

.algo_from_ext(path) ⇒ Object

# File 'lib/multi_compress.rb', line 57

def self.algo_from_ext(path)
  EXTENSION_MAP[File.extname(path).downcase]
end

.algorithms ⇒ Object

# File 'ext/multi_compress/multi_compress.c', line 974

static VALUE compress_algorithms(VALUE self) {
    VALUE ary = rb_ary_new_capa(3);
    rb_ary_push(ary, ID2SYM(rb_intern("zstd")));
    rb_ary_push(ary, ID2SYM(rb_intern("lz4")));
    rb_ary_push(ary, ID2SYM(rb_intern("brotli")));
    return ary;
}

.available?(algo_sym) ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/multi_compress/multi_compress.c', line 982

static VALUE compress_available_p(VALUE self, VALUE algo_sym) {
    sym_to_algo(algo_sym);
    return Qtrue;
}

.brotli(data, level: nil) ⇒ Object

# File 'lib/multi_compress.rb', line 41

def self.brotli(data, level: nil)
  compress(data, algo: :brotli, **level_opts(level))
end

.brotli_decompress(data) ⇒ Object

# File 'lib/multi_compress.rb', line 53

def self.brotli_decompress(data)
  decompress(data, algo: :brotli)
end

.compress(*args) ⇒ Object

# File 'ext/multi_compress/multi_compress.c', line 390

static VALUE compress_compress(int argc, VALUE *argv, VALUE self) {
    VALUE data, opts;
    rb_scan_args(argc, argv, "1:", &data, &opts);
    StringValue(data);

    VALUE algo_sym = Qnil, level_val = Qnil, dict_val = Qnil;
    if (!NIL_P(opts)) {
        algo_sym = rb_hash_aref(opts, ID2SYM(rb_intern("algo")));
        level_val = rb_hash_aref(opts, ID2SYM(rb_intern("level")));
        dict_val = rb_hash_aref(opts, ID2SYM(rb_intern("dictionary")));
    }

    compress_algo_t algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
    int level = resolve_level(algo, level_val);

    dictionary_t *dict = NULL;
    if (!NIL_P(dict_val)) {
        if (algo == ALGO_LZ4) {
            rb_raise(eUnsupportedError, "LZ4 does not support dictionaries");
        }
        TypedData_Get_Struct(dict_val, dictionary_t, &dictionary_type, dict);
    }

    const char *src = RSTRING_PTR(data);
    size_t slen = RSTRING_LEN(data);

    switch (algo) {
    case ALGO_ZSTD: {
        size_t bound = ZSTD_compressBound(slen);

        size_t csize;
        if (slen >= GVL_UNLOCK_THRESHOLD) {
            VALUE dst = rb_binary_str_buf_reserve(bound);

            ZSTD_CDict *cdict = NULL;
            if (dict) {
                cdict = dict_get_cdict(dict, level);
                if (!cdict)
                    rb_raise(eMemError, "zstd: failed to create/get cdict");
            }

            zstd_compress_args_t args = {
                .src = src,
                .src_len = slen,
                .dst = RSTRING_PTR(dst),
                .dst_cap = bound,
                .level = level,
                .cdict = cdict,
            };
            run_without_gvl(zstd_compress_nogvl, &args);

            if (args.error)
                rb_raise(eMemError, "zstd: failed to create context");
            csize = args.result;
            if (ZSTD_isError(csize))
                rb_raise(eError, "zstd compress: %s", ZSTD_getErrorName(csize));

            rb_str_set_len(dst, (long)csize);
            RB_GC_GUARD(data);
            return dst;
        } else {
            VALUE dst = rb_binary_str_buf_reserve(bound);

            if (dict) {
                ZSTD_CDict *cdict = dict_get_cdict(dict, level);
                if (!cdict)
                    rb_raise(eMemError, "zstd: failed to create/get cdict");
                ZSTD_CCtx *cctx = ZSTD_createCCtx();
                if (!cctx)
                    rb_raise(eMemError, "zstd: failed to create context");
                csize = ZSTD_compress_usingCDict(cctx, RSTRING_PTR(dst), bound, src, slen, cdict);
                ZSTD_freeCCtx(cctx);
            } else {
                csize = ZSTD_compress(RSTRING_PTR(dst), bound, src, slen, level);
            }

            if (ZSTD_isError(csize)) {
                rb_raise(eError, "zstd compress: %s", ZSTD_getErrorName(csize));
            }
            rb_str_set_len(dst, csize);
            RB_GC_GUARD(data);
            return dst;
        }
    }
    case ALGO_LZ4: {
        if (slen > (size_t)INT_MAX)
            rb_raise(eError, "lz4: input too large (max 2GB)");
        int bound = LZ4_compressBound((int)slen);

        int csize;
        if (slen >= GVL_UNLOCK_THRESHOLD) {
            VALUE dst = rb_binary_str_buf_reserve(8 + (size_t)bound + 4);
            char *out = RSTRING_PTR(dst);

            out[0] = (slen >> 0) & 0xFF;
            out[1] = (slen >> 8) & 0xFF;
            out[2] = (slen >> 16) & 0xFF;
            out[3] = (slen >> 24) & 0xFF;

            lz4_compress_args_t args = {
                .src = src,
                .src_len = (int)slen,
                .dst = out + 8,
                .dst_cap = bound,
                .level = level,
            };
            run_without_gvl(lz4_compress_nogvl, &args);
            csize = args.result;

            if (csize <= 0)
                rb_raise(eError, "lz4 compress failed");

            out[4] = (csize >> 0) & 0xFF;
            out[5] = (csize >> 8) & 0xFF;
            out[6] = (csize >> 16) & 0xFF;
            out[7] = (csize >> 24) & 0xFF;

            size_t total = 8 + (size_t)csize;
            out[total] = 0;
            out[total + 1] = 0;
            out[total + 2] = 0;
            out[total + 3] = 0;

            rb_str_set_len(dst, (long)(total + 4));
            RB_GC_GUARD(data);
            return dst;
        } else {
            VALUE dst = rb_binary_str_buf_reserve(8 + bound + 4);
            char *out = RSTRING_PTR(dst);

            out[0] = (slen >> 0) & 0xFF;
            out[1] = (slen >> 8) & 0xFF;
            out[2] = (slen >> 16) & 0xFF;
            out[3] = (slen >> 24) & 0xFF;

            if (level > 1) {
                csize = LZ4_compress_HC(src, out + 8, (int)slen, bound, level);
            } else {
                csize = LZ4_compress_default(src, out + 8, (int)slen, bound);
            }
            if (csize <= 0)
                rb_raise(eError, "lz4 compress failed");

            out[4] = (csize >> 0) & 0xFF;
            out[5] = (csize >> 8) & 0xFF;
            out[6] = (csize >> 16) & 0xFF;
            out[7] = (csize >> 24) & 0xFF;

            size_t total = 8 + csize;
            out[total] = 0;
            out[total + 1] = 0;
            out[total + 2] = 0;
            out[total + 3] = 0;

            rb_str_set_len(dst, total + 4);
            RB_GC_GUARD(data);
            return dst;
        }
    }
    case ALGO_BROTLI: {
        size_t out_len = BrotliEncoderMaxCompressedSize(slen);
        if (out_len == 0)
            out_len = slen + (slen >> 2) + 1024;

        if (dict) {
            VALUE dst = rb_binary_str_buf_reserve(out_len);
            BrotliEncoderState *enc = BrotliEncoderCreateInstance(NULL, NULL, NULL);
            if (!enc)
                rb_raise(eMemError, "brotli: failed to create encoder");

            BrotliEncoderPreparedDictionary *pd =
                BrotliEncoderPrepareDictionary(BROTLI_SHARED_DICTIONARY_RAW, dict->size, dict->data,
                                               BROTLI_MAX_QUALITY, NULL, NULL, NULL);
            if (!pd) {
                BrotliEncoderDestroyInstance(enc);
                rb_raise(eMemError, "brotli: failed to prepare dictionary");
            }

            if (!BrotliEncoderSetParameter(enc, BROTLI_PARAM_QUALITY, level) ||
                !BrotliEncoderAttachPreparedDictionary(enc, pd)) {
                BrotliEncoderDestroyPreparedDictionary(pd);
                BrotliEncoderDestroyInstance(enc);
                rb_raise(eError, "brotli: failed to attach dictionary");
            }

            size_t available_in = slen;
            const uint8_t *next_in = (const uint8_t *)src;
            size_t available_out = out_len;
            uint8_t *next_out = (uint8_t *)RSTRING_PTR(dst);
            size_t initial_out = available_out;

            BROTLI_BOOL ok =
                BrotliEncoderCompressStream(enc, BROTLI_OPERATION_FINISH, &available_in, &next_in,
                                            &available_out, &next_out, NULL);

            BrotliEncoderDestroyPreparedDictionary(pd);
            BrotliEncoderDestroyInstance(enc);
            if (!ok)
                rb_raise(eError, "brotli compress with dict failed");

            rb_str_set_len(dst, initial_out - available_out);
            RB_GC_GUARD(data);
            return dst;
        } else if (slen >= GVL_UNLOCK_THRESHOLD) {
            VALUE dst = rb_binary_str_buf_reserve(out_len);
            size_t actual_out_len = out_len;

            brotli_compress_args_t args = {
                .level = level,
                .src_len = slen,
                .src = (const uint8_t *)src,
                .out_len = &actual_out_len,
                .dst = (uint8_t *)RSTRING_PTR(dst),
            };
            run_without_gvl(brotli_compress_nogvl, &args);

            if (!args.result)
                rb_raise(eError, "brotli compress failed");

            rb_str_set_len(dst, (long)actual_out_len);
            RB_GC_GUARD(data);
            return dst;
        } else {
            VALUE dst = rb_binary_str_buf_reserve(out_len);
            BROTLI_BOOL ok =
                BrotliEncoderCompress(level, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE, slen,
                                      (const uint8_t *)src, &out_len, (uint8_t *)RSTRING_PTR(dst));
            if (!ok)
                rb_raise(eError, "brotli compress failed");
            rb_str_set_len(dst, out_len);
            RB_GC_GUARD(data);
            return dst;
        }
    }
    }

    return Qnil;
}

.crc32(*args) ⇒ Object

# File 'ext/multi_compress/multi_compress.c', line 934

static VALUE compress_crc32(int argc, VALUE *argv, VALUE self) {
    VALUE data, prev;
    rb_scan_args(argc, argv, "11", &data, &prev);
    StringValue(data);

    const uint8_t *src = (const uint8_t *)RSTRING_PTR(data);
    size_t len = RSTRING_LEN(data);
    uint32_t crc = NIL_P(prev) ? 0 : NUM2UINT(prev);

    return UINT2NUM(crc32_compute(src, len, crc));
}

.decompress(*args) ⇒ Object

# File 'ext/multi_compress/multi_compress.c', line 629

static VALUE compress_decompress(int argc, VALUE *argv, VALUE self) {
    VALUE data, opts;
    rb_scan_args(argc, argv, "1:", &data, &opts);
    StringValue(data);

    VALUE algo_sym = Qnil, dict_val = Qnil;
    if (!NIL_P(opts)) {
        algo_sym = rb_hash_aref(opts, ID2SYM(rb_intern("algo")));
        dict_val = rb_hash_aref(opts, ID2SYM(rb_intern("dictionary")));
    }

    const uint8_t *src = (const uint8_t *)RSTRING_PTR(data);
    size_t slen = RSTRING_LEN(data);

    compress_algo_t algo;
    if (NIL_P(algo_sym)) {
        algo = detect_algo(src, slen);
    } else {
        algo = sym_to_algo(algo_sym);
    }

    dictionary_t *dict = NULL;
    if (!NIL_P(dict_val)) {
        if (algo == ALGO_LZ4) {
            rb_raise(eUnsupportedError, "LZ4 does not support dictionaries");
        }
        TypedData_Get_Struct(dict_val, dictionary_t, &dictionary_type, dict);
    }

    switch (algo) {
    case ALGO_ZSTD: {
        unsigned long long frame_size = ZSTD_getFrameContentSize(src, slen);
        if (frame_size == ZSTD_CONTENTSIZE_ERROR) {
            rb_raise(eDataError, "zstd: not valid compressed data");
        }

        if (frame_size != ZSTD_CONTENTSIZE_UNKNOWN && frame_size <= MAX_DECOMPRESS_SIZE) {
            size_t dsize;

            if (frame_size >= GVL_UNLOCK_THRESHOLD) {
                VALUE dst = rb_binary_str_buf_reserve((size_t)frame_size);

                ZSTD_DDict *ddict = NULL;
                if (dict) {
                    ddict = dict_get_ddict(dict);
                    if (!ddict)
                        rb_raise(eMemError, "zstd: failed to create ddict");
                }

                zstd_decompress_args_t args = {
                    .src = src,
                    .src_len = slen,
                    .dst = RSTRING_PTR(dst),
                    .dst_cap = (size_t)frame_size,
                    .ddict = ddict,
                };
                run_without_gvl(zstd_decompress_nogvl, &args);

                if (args.error)
                    rb_raise(eMemError, "zstd: failed to create dctx");
                dsize = args.result;
                if (ZSTD_isError(dsize))
                    rb_raise(eDataError, "zstd decompress: %s", ZSTD_getErrorName(dsize));

                rb_str_set_len(dst, (long)dsize);
                RB_GC_GUARD(data);
                return dst;
            } else {
                VALUE dst = rb_binary_str_buf_reserve((size_t)frame_size);

                if (dict) {
                    ZSTD_DDict *ddict = dict_get_ddict(dict);
                    if (!ddict)
                        rb_raise(eMemError, "zstd: failed to create ddict");
                    ZSTD_DCtx *dctx = ZSTD_createDCtx();
                    if (!dctx)
                        rb_raise(eMemError, "zstd: failed to create dctx");
                    dsize = ZSTD_decompress_usingDDict(dctx, RSTRING_PTR(dst), (size_t)frame_size,
                                                       src, slen, ddict);
                    ZSTD_freeDCtx(dctx);
                } else {
                    dsize = ZSTD_decompress(RSTRING_PTR(dst), (size_t)frame_size, src, slen);
                }

                if (ZSTD_isError(dsize))
                    rb_raise(eDataError, "zstd decompress: %s", ZSTD_getErrorName(dsize));
                rb_str_set_len(dst, dsize);
                RB_GC_GUARD(data);
                return dst;
            }
        }

        ZSTD_DCtx *dctx = ZSTD_createDCtx();
        if (!dctx)
            rb_raise(eMemError, "zstd: failed to create dctx");

        if (dict) {
            ZSTD_DDict *ddict = dict_get_ddict(dict);
            if (ddict) {
                size_t r = ZSTD_DCtx_refDDict(dctx, ddict);
                if (ZSTD_isError(r)) {
                    ZSTD_freeDCtx(dctx);
                    rb_raise(eError, "zstd dict ref: %s", ZSTD_getErrorName(r));
                }
            }
        }

        size_t alloc_size = (slen > MAX_DECOMPRESS_SIZE / 8) ? MAX_DECOMPRESS_SIZE : slen * 8;
        if (alloc_size < 4096)
            alloc_size = 4096;

        VALUE dst = rb_binary_str_buf_reserve(alloc_size);
        size_t total_out = 0;

        ZSTD_inBuffer input = {src, slen, 0};
        while (input.pos < input.size) {
            if (total_out >= alloc_size) {
                if (alloc_size >= MAX_DECOMPRESS_SIZE) {
                    ZSTD_freeDCtx(dctx);
                    rb_raise(eDataError, "zstd: decompressed size exceeds limit (%lluMB)",
                             (unsigned long long)(MAX_DECOMPRESS_SIZE / (1024 * 1024)));
                }
                alloc_size *= 2;
                if (alloc_size > MAX_DECOMPRESS_SIZE)
                    alloc_size = MAX_DECOMPRESS_SIZE;
                grow_binary_str(dst, total_out, alloc_size);
            }

            ZSTD_outBuffer output = {RSTRING_PTR(dst) + total_out, alloc_size - total_out, 0};
            size_t ret = ZSTD_decompressStream(dctx, &output, &input);
            if (ZSTD_isError(ret)) {
                ZSTD_freeDCtx(dctx);
                rb_raise(eDataError, "zstd decompress: %s", ZSTD_getErrorName(ret));
            }
            total_out += output.pos;
            if (ret == 0)
                break;
        }

        ZSTD_freeDCtx(dctx);
        rb_str_set_len(dst, total_out);
        RB_GC_GUARD(data);
        return dst;
    }
    case ALGO_LZ4: {
        if (slen < 4)
            rb_raise(eDataError, "lz4: data too short");

        size_t total_orig = 0;
        size_t scan_pos = 0;
        while (scan_pos + 4 <= slen) {
            uint32_t orig_size = (uint32_t)src[scan_pos] | ((uint32_t)src[scan_pos + 1] << 8) |
                                 ((uint32_t)src[scan_pos + 2] << 16) |
                                 ((uint32_t)src[scan_pos + 3] << 24);
            if (orig_size == 0)
                break;
            if (scan_pos + 8 > slen)
                rb_raise(eDataError, "lz4: truncated block header");
            uint32_t comp_size = (uint32_t)src[scan_pos + 4] | ((uint32_t)src[scan_pos + 5] << 8) |
                                 ((uint32_t)src[scan_pos + 6] << 16) |
                                 ((uint32_t)src[scan_pos + 7] << 24);
            if (scan_pos + 8 + comp_size > slen)
                rb_raise(eDataError, "lz4: truncated block data");
            if (orig_size > 256 * 1024 * 1024)
                rb_raise(eDataError, "lz4: block too large (%u)", orig_size);
            total_orig += orig_size;
            if (total_orig > MAX_DECOMPRESS_SIZE)
                rb_raise(eDataError, "lz4: total decompressed size exceeds limit");
            scan_pos += 8 + comp_size;
        }

        VALUE result = rb_binary_str_buf_reserve(total_orig);
        char *out_ptr = RSTRING_PTR(result);
        size_t out_offset = 0;
        size_t pos = 0;

        while (pos + 4 <= slen) {
            uint32_t orig_size = (uint32_t)src[pos] | ((uint32_t)src[pos + 1] << 8) |
                                 ((uint32_t)src[pos + 2] << 16) | ((uint32_t)src[pos + 3] << 24);
            if (orig_size == 0)
                break;
            uint32_t comp_size = (uint32_t)src[pos + 4] | ((uint32_t)src[pos + 5] << 8) |
                                 ((uint32_t)src[pos + 6] << 16) | ((uint32_t)src[pos + 7] << 24);

            int dsize = LZ4_decompress_safe((const char *)(src + pos + 8), out_ptr + out_offset,
                                            (int)comp_size, (int)orig_size);
            if (dsize < 0)
                rb_raise(eDataError, "lz4 decompress failed");

            out_offset += dsize;
            pos += 8 + comp_size;
        }

        rb_str_set_len(result, out_offset);
        RB_GC_GUARD(data);
        return result;
    }
    case ALGO_BROTLI: {
        size_t alloc_size = (slen > MAX_DECOMPRESS_SIZE / 4) ? MAX_DECOMPRESS_SIZE : slen * 4;
        if (alloc_size < 1024)
            alloc_size = 1024;

        BrotliDecoderState *dec = BrotliDecoderCreateInstance(NULL, NULL, NULL);
        if (!dec)
            rb_raise(eMemError, "brotli: failed to create decoder");

        if (dict) {
            BrotliDecoderAttachDictionary(dec, BROTLI_SHARED_DICTIONARY_RAW, dict->size,
                                          dict->data);
        }

        VALUE dst = rb_binary_str_buf_reserve(alloc_size);
        size_t total_out = 0;

        size_t available_in = slen;
        const uint8_t *next_in = src;

        BrotliDecoderResult res = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT;
        while (res == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
            size_t available_out = alloc_size - total_out;
            uint8_t *next_out = (uint8_t *)RSTRING_PTR(dst) + total_out;

            res = BrotliDecoderDecompressStream(dec, &available_in, &next_in, &available_out,
                                                &next_out, NULL);

            total_out = next_out - (uint8_t *)RSTRING_PTR(dst);

            if (res == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
                if (alloc_size >= MAX_DECOMPRESS_SIZE) {
                    BrotliDecoderDestroyInstance(dec);
                    rb_raise(eDataError, "brotli: decompressed size exceeds limit (%lluMB)",
                             (unsigned long long)(MAX_DECOMPRESS_SIZE / (1024 * 1024)));
                }
                alloc_size *= 2;
                if (alloc_size > MAX_DECOMPRESS_SIZE)
                    alloc_size = MAX_DECOMPRESS_SIZE;
                grow_binary_str(dst, total_out, alloc_size);
            }
        }

        BrotliDecoderDestroyInstance(dec);

        if (res != BROTLI_DECODER_RESULT_SUCCESS) {
            rb_raise(eDataError, "brotli decompress failed");
        }
        rb_str_set_len(dst, total_out);
        RB_GC_GUARD(data);
        return dst;
    }
    }

    return Qnil;
}

.lz4(data, level: nil) ⇒ Object

# File 'lib/multi_compress.rb', line 37

def self.lz4(data, level: nil)
  compress(data, algo: :lz4, **level_opts(level))
end

.lz4_decompress(data) ⇒ Object

# File 'lib/multi_compress.rb', line 49

def self.lz4_decompress(data)
  decompress(data, algo: :lz4)
end

.version(algo_sym) ⇒ Object

# File 'ext/multi_compress/multi_compress.c', line 987

static VALUE compress_version(VALUE self, VALUE algo_sym) {
    compress_algo_t algo = sym_to_algo(algo_sym);
    switch (algo) {
    case ALGO_ZSTD:
        return rb_str_new_cstr(ZSTD_versionString());
    case ALGO_LZ4:
        return rb_sprintf("%d.%d.%d", LZ4_VERSION_MAJOR, LZ4_VERSION_MINOR, LZ4_VERSION_RELEASE);
    case ALGO_BROTLI:
        return rb_sprintf("%d.%d.%d", BrotliEncoderVersion() >> 24,
                          (BrotliEncoderVersion() >> 12) & 0xFFF, BrotliEncoderVersion() & 0xFFF);
    }
    return Qnil;
}

.zstd(data, level: nil) ⇒ Object

# File 'lib/multi_compress.rb', line 33

def self.zstd(data, level: nil)
  compress(data, algo: :zstd, **level_opts(level))
end

.zstd_decompress(data) ⇒ Object

# File 'lib/multi_compress.rb', line 45

def self.zstd_decompress(data)
  decompress(data, algo: :zstd)
end