Module: Zstd
- Defined in:
- lib/zstd-ruby.rb,
lib/zstd-ruby/version.rb,
lib/zstd-ruby/stream_reader.rb,
lib/zstd-ruby/stream_writer.rb,
ext/zstdruby/main.c
Defined Under Namespace
Classes: StreamReader, StreamWriter, StreamingCompress, StreamingDecompress
Constant Summary collapse
- VERSION =
"1.5.6.6"
Class Method Summary collapse
- .compress(*args) ⇒ Object
- .compress_using_dict(*args) ⇒ Object
- .decompress(*args) ⇒ Object
- .decompress_using_dict(*args) ⇒ Object
- .read_skippable_frame(input_value) ⇒ Object
- .write_skippable_frame(*args) ⇒ Object
- .zstd_version ⇒ Object
Class Method Details
.compress(*args) ⇒ Object
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
# File 'ext/zstdruby/zstdruby.c', line 11
static VALUE rb_compress(int argc, VALUE *argv, VALUE self)
{
VALUE input_value;
VALUE compression_level_value;
VALUE kwargs;
rb_scan_args(argc, argv, "11:", &input_value, &compression_level_value, &kwargs);
ZSTD_CCtx* const ctx = ZSTD_createCCtx();
if (ctx == NULL) {
rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCCtx error");
}
set_compress_params(ctx, compression_level_value, kwargs);
StringValue(input_value);
char* input_data = RSTRING_PTR(input_value);
size_t input_size = RSTRING_LEN(input_value);
size_t max_compressed_size = ZSTD_compressBound(input_size);
VALUE output = rb_str_new(NULL, max_compressed_size);
char* output_data = RSTRING_PTR(output);
size_t const ret = zstd_compress(ctx, output_data, max_compressed_size, input_data, input_size, false);
if (ZSTD_isError(ret)) {
rb_raise(rb_eRuntimeError, "compress error error code: %s", ZSTD_getErrorName(ret));
}
rb_str_resize(output, ret);
ZSTD_freeCCtx(ctx);
return output;
}
|
.compress_using_dict(*args) ⇒ Object
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
# File 'ext/zstdruby/zstdruby.c', line 43
static VALUE rb_compress_using_dict(int argc, VALUE *argv, VALUE self)
{
rb_warn("Zstd.compress_using_dict is deprecated; use Zstd.compress with `dict:` instead.");
VALUE input_value;
VALUE dict;
VALUE compression_level_value;
rb_scan_args(argc, argv, "21", &input_value, &dict, &compression_level_value);
int compression_level = convert_compression_level(compression_level_value);
StringValue(input_value);
char* input_data = RSTRING_PTR(input_value);
size_t input_size = RSTRING_LEN(input_value);
size_t max_compressed_size = ZSTD_compressBound(input_size);
char* dict_buffer = RSTRING_PTR(dict);
size_t dict_size = RSTRING_LEN(dict);
ZSTD_CDict* const cdict = ZSTD_createCDict(dict_buffer, dict_size, compression_level);
if (cdict == NULL) {
rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCDict failed");
}
ZSTD_CCtx* const ctx = ZSTD_createCCtx();
if (ctx == NULL) {
ZSTD_freeCDict(cdict);
rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCCtx failed");
}
VALUE output = rb_str_new(NULL, max_compressed_size);
char* output_data = RSTRING_PTR(output);
size_t const compressed_size = ZSTD_compress_usingCDict(ctx, (void*)output_data, max_compressed_size,
(void*)input_data, input_size, cdict);
if (ZSTD_isError(compressed_size)) {
ZSTD_freeCDict(cdict);
ZSTD_freeCCtx(ctx);
rb_raise(rb_eRuntimeError, "%s: %s", "compress failed", ZSTD_getErrorName(compressed_size));
}
rb_str_resize(output, compressed_size);
ZSTD_freeCDict(cdict);
ZSTD_freeCCtx(ctx);
return output;
}
|
.decompress(*args) ⇒ Object
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 |
# File 'ext/zstdruby/zstdruby.c', line 110
static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
{
VALUE input_value;
VALUE kwargs;
rb_scan_args(argc, argv, "10:", &input_value, &kwargs);
StringValue(input_value);
char* input_data = RSTRING_PTR(input_value);
size_t input_size = RSTRING_LEN(input_value);
ZSTD_DCtx* const dctx = ZSTD_createDCtx();
if (dctx == NULL) {
rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx failed");
}
set_decompress_params(dctx, kwargs);
unsigned long long const uncompressed_size = ZSTD_getFrameContentSize(input_data, input_size);
if (uncompressed_size == ZSTD_CONTENTSIZE_ERROR) {
rb_raise(rb_eRuntimeError, "%s: %s", "not compressed by zstd", ZSTD_getErrorName(uncompressed_size));
}
// ZSTD_decompressStream may be called multiple times when ZSTD_CONTENTSIZE_UNKNOWN, causing slowness.
// Therefore, we will not standardize on ZSTD_decompressStream
if (uncompressed_size == ZSTD_CONTENTSIZE_UNKNOWN) {
return decompress_buffered(dctx, input_data, input_size);
}
VALUE output = rb_str_new(NULL, uncompressed_size);
char* output_data = RSTRING_PTR(output);
size_t const decompress_size = zstd_decompress(dctx, output_data, uncompressed_size, input_data, input_size, false);
if (ZSTD_isError(decompress_size)) {
rb_raise(rb_eRuntimeError, "%s: %s", "decompress error", ZSTD_getErrorName(decompress_size));
}
ZSTD_freeDCtx(dctx);
return output;
}
|
.decompress_using_dict(*args) ⇒ Object
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
# File 'ext/zstdruby/zstdruby.c', line 145
static VALUE rb_decompress_using_dict(int argc, VALUE *argv, VALUE self)
{
rb_warn("Zstd.decompress_using_dict is deprecated; use Zstd.decompress with `dict:` instead.");
VALUE input_value;
VALUE dict;
rb_scan_args(argc, argv, "20", &input_value, &dict);
StringValue(input_value);
char* input_data = RSTRING_PTR(input_value);
size_t input_size = RSTRING_LEN(input_value);
char* dict_buffer = RSTRING_PTR(dict);
size_t dict_size = RSTRING_LEN(dict);
ZSTD_DDict* const ddict = ZSTD_createDDict(dict_buffer, dict_size);
if (ddict == NULL) {
rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDDict failed");
}
unsigned const expected_dict_id = ZSTD_getDictID_fromDDict(ddict);
unsigned const actual_dict_id = ZSTD_getDictID_fromFrame(input_data, input_size);
if (expected_dict_id != actual_dict_id) {
ZSTD_freeDDict(ddict);
rb_raise(rb_eRuntimeError, "DictID mismatch");
}
ZSTD_DCtx* const ctx = ZSTD_createDCtx();
if (ctx == NULL) {
ZSTD_freeDDict(ddict);
rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx failed");
}
unsigned long long const uncompressed_size = ZSTD_getFrameContentSize(input_data, input_size);
if (uncompressed_size == ZSTD_CONTENTSIZE_ERROR) {
ZSTD_freeDDict(ddict);
ZSTD_freeDCtx(ctx);
rb_raise(rb_eRuntimeError, "%s: %s", "not compressed by zstd", ZSTD_getErrorName(uncompressed_size));
}
if (uncompressed_size == ZSTD_CONTENTSIZE_UNKNOWN) {
return decompress_buffered(ctx, input_data, input_size);
}
VALUE output = rb_str_new(NULL, uncompressed_size);
char* output_data = RSTRING_PTR(output);
size_t const decompress_size = ZSTD_decompress_usingDDict(ctx, output_data, uncompressed_size, input_data, input_size, ddict);
if (ZSTD_isError(decompress_size)) {
ZSTD_freeDDict(ddict);
ZSTD_freeDCtx(ctx);
rb_raise(rb_eRuntimeError, "%s: %s", "decompress error", ZSTD_getErrorName(decompress_size));
}
ZSTD_freeDDict(ddict);
ZSTD_freeDCtx(ctx);
return output;
}
|
.read_skippable_frame(input_value) ⇒ Object
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
# File 'ext/zstdruby/skippable_frame.c', line 37
static VALUE rb_read_skippable_frame(VALUE self, VALUE input_value)
{
char* input_data = RSTRING_PTR(input_value);
size_t input_size = RSTRING_LEN(input_value);
if (ZSTD_isSkippableFrame(input_data, input_size) == 0) {
return Qnil;
}
// ref https://github.com/facebook/zstd/blob/321490cd5b9863433b3d44816d04012874e5ecdb/tests/fuzzer.c#L2096
size_t const skipLen = 129 * 1024;
VALUE output = rb_str_new(NULL, skipLen);
char* output_data = RSTRING_PTR(output);
unsigned readMagic;
size_t output_size = ZSTD_readSkippableFrame((void*)output_data, skipLen, &readMagic, (const void*)input_data, input_size);
if (ZSTD_isError(output_size)) {
rb_raise(rb_eRuntimeError, "%s: %s", "read skippable frame failed", ZSTD_getErrorName(output_size));
}
rb_str_resize(output, output_size);
return output;
}
|
.write_skippable_frame(*args) ⇒ Object
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
# File 'ext/zstdruby/skippable_frame.c', line 5
static VALUE rb_write_skippable_frame(int argc, VALUE *argv, VALUE self)
{
VALUE input_value;
VALUE skip_value;
VALUE kwargs;
rb_scan_args(argc, argv, "2:", &input_value, &skip_value, &kwargs);
ID kwargs_keys[1];
kwargs_keys[0] = rb_intern("magic_variant");
VALUE kwargs_values[1];
rb_get_kwargs(kwargs, kwargs_keys, 0, 1, kwargs_values);
unsigned magic_variant = (kwargs_values[0] != Qundef) ? (NUM2INT(kwargs_values[0])) : 0;
StringValue(input_value);
StringValue(skip_value);
char* input_data = RSTRING_PTR(input_value);
size_t input_size = RSTRING_LEN(input_value);
char* skip_data = RSTRING_PTR(skip_value);
size_t skip_size = RSTRING_LEN(skip_value);
size_t dst_size = input_size + ZSTD_SKIPPABLEHEADERSIZE + skip_size;
VALUE output = rb_str_new(input_data, dst_size);
char* output_data = RSTRING_PTR(output);
size_t output_size = ZSTD_writeSkippableFrame((void*)output_data, dst_size, (const void*)skip_data, skip_size, magic_variant);
if (ZSTD_isError(output_size)) {
rb_raise(rb_eRuntimeError, "%s: %s", "write skippable frame failed", ZSTD_getErrorName(output_size));
}
rb_str_resize(output, output_size);
return output;
}
|
.zstd_version ⇒ Object
5 6 7 8 9 |
# File 'ext/zstdruby/zstdruby.c', line 5
static VALUE zstdVersion(VALUE self)
{
unsigned version = ZSTD_versionNumber();
return INT2NUM(version);
}
|