ruby-zstds 1.0.0

data/ext/zstds_ext/stream/compressor.c

@@ -0,0 +1,241 @@
+// Ruby bindings for zstd library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "zstds_ext/stream/compressor.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <zstd.h>
+
+#include "ruby.h"
+#include "zstds_ext/common.h"
+#include "zstds_ext/error.h"
+#include "zstds_ext/option.h"
+
+static void free_compressor(zstds_ext_compressor_t* compressor_ptr)
+{
+  ZSTD_CCtx* ctx = compressor_ptr->ctx;
+  if (ctx != NULL) {
+    ZSTD_freeCCtx(ctx);
+  }
+
+  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+  }
+
+  free(compressor_ptr);
+}
+
+VALUE zstds_ext_allocate_compressor(VALUE klass)
+{
+  zstds_ext_compressor_t* compressor_ptr;
+
+  VALUE self = Data_Make_Struct(klass, zstds_ext_compressor_t, NULL, free_compressor, compressor_ptr);
+
+  compressor_ptr->ctx                                 = NULL;
+  compressor_ptr->destination_buffer                  = NULL;
+  compressor_ptr->destination_buffer_length           = 0;
+  compressor_ptr->remaining_destination_buffer        = NULL;
+  compressor_ptr->remaining_destination_buffer_length = 0;
+
+  return self;
+}
+
+#define GET_COMPRESSOR(self)              \
+  zstds_ext_compressor_t* compressor_ptr; \
+  Data_Get_Struct(self, zstds_ext_compressor_t, compressor_ptr);
+
+VALUE zstds_ext_initialize_compressor(VALUE self, VALUE options)
+{
+  GET_COMPRESSOR(self);
+  Check_Type(options, T_HASH);
+  ZSTDS_EXT_GET_COMPRESSOR_OPTIONS(options);
+  ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
+
+  ZSTD_CCtx* ctx = ZSTD_createCCtx();
+  if (ctx == NULL) {
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  zstds_ext_result_t ext_result = zstds_ext_set_compressor_options(ctx, &compressor_options);
+  if (ext_result != 0) {
+    ZSTD_freeCCtx(ctx);
+    zstds_ext_raise_error(ext_result);
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = ZSTD_CStreamOutSize();
+  }
+
+  uint8_t* destination_buffer = malloc(destination_buffer_length);
+  if (destination_buffer == NULL) {
+    ZSTD_freeCCtx(ctx);
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  compressor_ptr->ctx                                 = ctx;
+  compressor_ptr->destination_buffer                  = destination_buffer;
+  compressor_ptr->destination_buffer_length           = destination_buffer_length;
+  compressor_ptr->remaining_destination_buffer        = destination_buffer;
+  compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return Qnil;
+}
+
+#define DO_NOT_USE_AFTER_CLOSE(compressor_ptr)                                     \
+  if (compressor_ptr->ctx == NULL || compressor_ptr->destination_buffer == NULL) { \
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_USED_AFTER_CLOSE);                       \
+  }
+
+#define GET_SOURCE_DATA(source_value)                    \
+  Check_Type(source_value, T_STRING);                    \
+                                                         \
+  const char* source        = RSTRING_PTR(source_value); \
+  size_t      source_length = RSTRING_LEN(source_value);
+
+VALUE zstds_ext_compress(VALUE self, VALUE source_value)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+  GET_SOURCE_DATA(source_value);
+
+  ZSTD_inBuffer in_buffer;
+  in_buffer.src  = source;
+  in_buffer.size = source_length;
+  in_buffer.pos  = 0;
+
+  ZSTD_outBuffer out_buffer;
+  out_buffer.dst  = compressor_ptr->remaining_destination_buffer;
+  out_buffer.size = compressor_ptr->remaining_destination_buffer_length;
+  out_buffer.pos  = 0;
+
+  zstds_result_t result = ZSTD_compressStream2(compressor_ptr->ctx, &out_buffer, &in_buffer, ZSTD_e_continue);
+  if (ZSTD_isError(result)) {
+    zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
+  }
+
+  compressor_ptr->remaining_destination_buffer += out_buffer.pos;
+  compressor_ptr->remaining_destination_buffer_length -= out_buffer.pos;
+
+  VALUE bytes_written          = SIZET2NUM(in_buffer.pos);
+  VALUE needs_more_destination = compressor_ptr->remaining_destination_buffer_length == 0 ? Qtrue : Qfalse;
+
+  return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
+}
+
+VALUE zstds_ext_flush_compressor(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  ZSTD_inBuffer in_buffer;
+  in_buffer.src  = NULL;
+  in_buffer.size = 0;
+  in_buffer.pos  = 0;
+
+  ZSTD_outBuffer out_buffer;
+  out_buffer.dst  = compressor_ptr->remaining_destination_buffer;
+  out_buffer.size = compressor_ptr->remaining_destination_buffer_length;
+  out_buffer.pos  = 0;
+
+  zstds_result_t result = ZSTD_compressStream2(compressor_ptr->ctx, &out_buffer, &in_buffer, ZSTD_e_flush);
+  if (ZSTD_isError(result)) {
+    zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
+  }
+
+  compressor_ptr->remaining_destination_buffer += out_buffer.pos;
+  compressor_ptr->remaining_destination_buffer_length -= out_buffer.pos;
+
+  VALUE needs_more_destination = result != 0 ? Qtrue : Qfalse;
+
+  return needs_more_destination;
+}
+
+VALUE zstds_ext_finish_compressor(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  ZSTD_inBuffer in_buffer;
+  in_buffer.src  = NULL;
+  in_buffer.size = 0;
+  in_buffer.pos  = 0;
+
+  ZSTD_outBuffer out_buffer;
+  out_buffer.dst  = compressor_ptr->remaining_destination_buffer;
+  out_buffer.size = compressor_ptr->remaining_destination_buffer_length;
+  out_buffer.pos  = 0;
+
+  zstds_result_t result = ZSTD_compressStream2(compressor_ptr->ctx, &out_buffer, &in_buffer, ZSTD_e_end);
+  if (ZSTD_isError(result)) {
+    zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
+  }
+
+  compressor_ptr->remaining_destination_buffer += out_buffer.pos;
+  compressor_ptr->remaining_destination_buffer_length -= out_buffer.pos;
+
+  VALUE needs_more_destination = result != 0 ? Qtrue : Qfalse;
+
+  return needs_more_destination;
+}
+
+VALUE zstds_ext_compressor_read_result(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  uint8_t* destination_buffer                  = compressor_ptr->destination_buffer;
+  size_t   destination_buffer_length           = compressor_ptr->destination_buffer_length;
+  size_t   remaining_destination_buffer_length = compressor_ptr->remaining_destination_buffer_length;
+
+  const char* result        = (const char*)destination_buffer;
+  size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
+
+  VALUE result_value = rb_str_new(result, result_length);
+
+  compressor_ptr->remaining_destination_buffer        = destination_buffer;
+  compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return result_value;
+}
+
+VALUE zstds_ext_compressor_close(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  ZSTD_CCtx* ctx = compressor_ptr->ctx;
+  if (ctx != NULL) {
+    ZSTD_freeCCtx(ctx);
+
+    compressor_ptr->ctx = NULL;
+  }
+
+  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+
+    compressor_ptr->destination_buffer = NULL;
+  }
+
+  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer"
+  //   and "remaining_destination_buffer_length" as is.
+
+  return Qnil;
+}
+
+void zstds_ext_compressor_exports(VALUE root_module)
+{
+  VALUE module = rb_define_module_under(root_module, "Stream");
+
+  VALUE compressor = rb_define_class_under(module, "NativeCompressor", rb_cObject);
+
+  rb_define_alloc_func(compressor, zstds_ext_allocate_compressor);
+  rb_define_method(compressor, "initialize", zstds_ext_initialize_compressor, 1);
+  rb_define_method(compressor, "write", zstds_ext_compress, 1);
+  rb_define_method(compressor, "flush", zstds_ext_flush_compressor, 0);
+  rb_define_method(compressor, "finish", zstds_ext_finish_compressor, 0);
+  rb_define_method(compressor, "read_result", zstds_ext_compressor_read_result, 0);
+  rb_define_method(compressor, "close", zstds_ext_compressor_close, 0);
+}

data/ext/zstds_ext/stream/compressor.h

@@ -0,0 +1,31 @@
+// Ruby bindings for zstd library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(ZSTDS_EXT_STREAM_COMPRESSOR_H)
+#define ZSTDS_EXT_STREAM_COMPRESSOR_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <zstd.h>
+
+#include "ruby.h"
+
+typedef struct {
+  ZSTD_CCtx* ctx;
+  uint8_t*   destination_buffer;
+  size_t     destination_buffer_length;
+  uint8_t*   remaining_destination_buffer;
+  size_t     remaining_destination_buffer_length;
+} zstds_ext_compressor_t;
+
+VALUE zstds_ext_allocate_compressor(VALUE klass);
+VALUE zstds_ext_initialize_compressor(VALUE self, VALUE options);
+VALUE zstds_ext_compress(VALUE self, VALUE source);
+VALUE zstds_ext_flush_compressor(VALUE self);
+VALUE zstds_ext_finish_compressor(VALUE self);
+VALUE zstds_ext_compressor_read_result(VALUE self);
+VALUE zstds_ext_compressor_close(VALUE self);
+
+void zstds_ext_compressor_exports(VALUE root_module);
+
+#endif // ZSTDS_EXT_STREAM_COMPRESSOR_H

data/ext/zstds_ext/stream/decompressor.c

@@ -0,0 +1,183 @@
+// Ruby bindings for zstd library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "zstds_ext/stream/decompressor.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <zstd.h>
+
+#include "ruby.h"
+#include "zstds_ext/common.h"
+#include "zstds_ext/error.h"
+#include "zstds_ext/option.h"
+
+static void free_decompressor(zstds_ext_decompressor_t* decompressor_ptr)
+{
+  ZSTD_DCtx* ctx = decompressor_ptr->ctx;
+  if (ctx != NULL) {
+    ZSTD_freeDCtx(ctx);
+  }
+
+  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+  }
+
+  free(decompressor_ptr);
+}
+
+VALUE zstds_ext_allocate_decompressor(VALUE klass)
+{
+  zstds_ext_decompressor_t* decompressor_ptr;
+
+  VALUE self = Data_Make_Struct(klass, zstds_ext_decompressor_t, NULL, free_decompressor, decompressor_ptr);
+
+  decompressor_ptr->ctx                                 = NULL;
+  decompressor_ptr->destination_buffer                  = NULL;
+  decompressor_ptr->destination_buffer_length           = 0;
+  decompressor_ptr->remaining_destination_buffer        = NULL;
+  decompressor_ptr->remaining_destination_buffer_length = 0;
+
+  return self;
+}
+
+#define GET_DECOMPRESSOR(self)                \
+  zstds_ext_decompressor_t* decompressor_ptr; \
+  Data_Get_Struct(self, zstds_ext_decompressor_t, decompressor_ptr);
+
+VALUE zstds_ext_initialize_decompressor(VALUE self, VALUE options)
+{
+  GET_DECOMPRESSOR(self);
+  Check_Type(options, T_HASH);
+  ZSTDS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+  ZSTDS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
+
+  ZSTD_DCtx* ctx = ZSTD_createDCtx();
+  if (ctx == NULL) {
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  zstds_ext_result_t ext_result = zstds_ext_set_decompressor_options(ctx, &decompressor_options);
+  if (ext_result != 0) {
+    ZSTD_freeDCtx(ctx);
+    zstds_ext_raise_error(ext_result);
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = ZSTD_DStreamOutSize();
+  }
+
+  uint8_t* destination_buffer = malloc(destination_buffer_length);
+  if (destination_buffer == NULL) {
+    ZSTD_freeDCtx(ctx);
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  decompressor_ptr->ctx                                 = ctx;
+  decompressor_ptr->destination_buffer                  = destination_buffer;
+  decompressor_ptr->destination_buffer_length           = destination_buffer_length;
+  decompressor_ptr->remaining_destination_buffer        = destination_buffer;
+  decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return Qnil;
+}
+
+#define DO_NOT_USE_AFTER_CLOSE(decompressor_ptr)                                       \
+  if (decompressor_ptr->ctx == NULL || decompressor_ptr->destination_buffer == NULL) { \
+    zstds_ext_raise_error(ZSTDS_EXT_ERROR_USED_AFTER_CLOSE);                           \
+  }
+
+#define GET_SOURCE_DATA(source_value)                    \
+  Check_Type(source_value, T_STRING);                    \
+                                                         \
+  const char* source        = RSTRING_PTR(source_value); \
+  size_t      source_length = RSTRING_LEN(source_value);
+
+VALUE zstds_ext_decompress(VALUE self, VALUE source_value)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+  GET_SOURCE_DATA(source_value);
+
+  ZSTD_inBuffer in_buffer;
+  in_buffer.src  = source;
+  in_buffer.size = source_length;
+  in_buffer.pos  = 0;
+
+  ZSTD_outBuffer out_buffer;
+  out_buffer.dst  = decompressor_ptr->remaining_destination_buffer;
+  out_buffer.size = decompressor_ptr->remaining_destination_buffer_length;
+  out_buffer.pos  = 0;
+
+  zstds_result_t result = ZSTD_decompressStream(decompressor_ptr->ctx, &out_buffer, &in_buffer);
+  if (ZSTD_isError(result)) {
+    zstds_ext_raise_error(zstds_ext_get_error(ZSTD_getErrorCode(result)));
+  }
+
+  decompressor_ptr->remaining_destination_buffer += out_buffer.pos;
+  decompressor_ptr->remaining_destination_buffer_length -= out_buffer.pos;
+
+  VALUE bytes_read             = SIZET2NUM(in_buffer.pos);
+  VALUE needs_more_destination = decompressor_ptr->remaining_destination_buffer_length == 0 ? Qtrue : Qfalse;
+
+  return rb_ary_new_from_args(2, bytes_read, needs_more_destination);
+}
+
+VALUE zstds_ext_decompressor_read_result(VALUE self)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+
+  uint8_t* destination_buffer                  = decompressor_ptr->destination_buffer;
+  size_t   destination_buffer_length           = decompressor_ptr->destination_buffer_length;
+  size_t   remaining_destination_buffer_length = decompressor_ptr->remaining_destination_buffer_length;
+
+  const char* result        = (const char*)destination_buffer;
+  size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
+
+  VALUE result_value = rb_str_new(result, result_length);
+
+  decompressor_ptr->remaining_destination_buffer        = destination_buffer;
+  decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return result_value;
+}
+
+VALUE zstds_ext_decompressor_close(VALUE self)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+
+  ZSTD_DCtx* ctx = decompressor_ptr->ctx;
+  if (ctx != NULL) {
+    ZSTD_freeDCtx(ctx);
+
+    decompressor_ptr->ctx = NULL;
+  }
+
+  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+
+    decompressor_ptr->destination_buffer = NULL;
+  }
+
+  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer"
+  //   and "remaining_destination_buffer_length" as is.
+
+  return Qnil;
+}
+
+void zstds_ext_decompressor_exports(VALUE root_module)
+{
+  VALUE module = rb_define_module_under(root_module, "Stream");
+
+  VALUE decompressor = rb_define_class_under(module, "NativeDecompressor", rb_cObject);
+
+  rb_define_alloc_func(decompressor, zstds_ext_allocate_decompressor);
+  rb_define_method(decompressor, "initialize", zstds_ext_initialize_decompressor, 1);
+  rb_define_method(decompressor, "read", zstds_ext_decompress, 1);
+  rb_define_method(decompressor, "read_result", zstds_ext_decompressor_read_result, 0);
+  rb_define_method(decompressor, "close", zstds_ext_decompressor_close, 0);
+}