ruby-brs 1.0.1

data/ext/brs_ext/option.h

@@ -0,0 +1,80 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(BRS_EXT_OPTIONS_H)
+#define BRS_EXT_OPTIONS_H
+
+#include <brotli/decode.h>
+#include <brotli/encode.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "brs_ext/common.h"
+#include "ruby.h"
+
+// Default option values depends on brotli library.
+// We will set only user defined values.
+
+enum {
+  BRS_EXT_OPTION_TYPE_BOOL = 1,
+  BRS_EXT_OPTION_TYPE_FIXNUM,
+  BRS_EXT_OPTION_TYPE_MODE
+};
+
+typedef uint_fast8_t brs_ext_option_type_t;
+typedef uint32_t     brs_ext_option_value_t;
+
+typedef struct {
+  bool                   has_value;
+  brs_ext_option_value_t value;
+} brs_ext_option_t;
+
+typedef struct {
+  brs_ext_option_t mode;
+  brs_ext_option_t quality;
+  brs_ext_option_t lgwin;
+  brs_ext_option_t lgblock;
+  brs_ext_option_t disable_literal_context_modeling;
+  brs_ext_option_t size_hint;
+  brs_ext_option_t large_window;
+} brs_ext_compressor_options_t;
+
+typedef struct {
+  brs_ext_option_t disable_ring_buffer_reallocation;
+  brs_ext_option_t large_window;
+} brs_ext_decompressor_options_t;
+
+void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_type_t type, const char* name);
+
+#define BRS_EXT_GET_OPTION(options, target_options, type, name) \
+  brs_ext_get_option(options, &target_options.name, type, #name);
+
+#define BRS_EXT_GET_COMPRESSOR_OPTIONS(options)                                                                \
+  brs_ext_compressor_options_t compressor_options;                                                             \
+                                                                                                               \
+  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_MODE, mode);                             \
+  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_FIXNUM, quality);                        \
+  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_FIXNUM, lgwin);                          \
+  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_FIXNUM, lgblock);                        \
+  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_BOOL, disable_literal_context_modeling); \
+  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_FIXNUM, size_hint);                      \
+  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_BOOL, large_window);
+
+#define BRS_EXT_GET_DECOMPRESSOR_OPTIONS(options)                                                                \
+  brs_ext_decompressor_options_t decompressor_options;                                                           \
+                                                                                                                 \
+  BRS_EXT_GET_OPTION(options, decompressor_options, BRS_EXT_OPTION_TYPE_BOOL, disable_ring_buffer_reallocation); \
+  BRS_EXT_GET_OPTION(options, decompressor_options, BRS_EXT_OPTION_TYPE_BOOL, large_window);
+
+unsigned long brs_ext_get_fixnum_option_value(VALUE options, const char* name);
+
+#define BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) \
+  size_t name = brs_ext_get_fixnum_option_value(options, #name);
+
+brs_ext_result_t brs_ext_set_compressor_options(BrotliEncoderState* state_ptr, brs_ext_compressor_options_t* options);
+brs_ext_result_t brs_ext_set_decompressor_options(BrotliDecoderState* state_ptr, brs_ext_decompressor_options_t* options);
+
+void brs_ext_option_exports(VALUE root_module);
+
+#endif // BRS_EXT_OPTIONS_H

data/ext/brs_ext/stream/compressor.c

@@ -0,0 +1,234 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "brs_ext/stream/compressor.h"
+
+#include <brotli/encode.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "brs_ext/buffer.h"
+#include "brs_ext/common.h"
+#include "brs_ext/error.h"
+#include "brs_ext/option.h"
+#include "ruby.h"
+
+static void free_compressor(brs_ext_compressor_t* compressor_ptr)
+{
+  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    BrotliEncoderDestroyInstance(state_ptr);
+  }
+
+  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+  }
+
+  free(compressor_ptr);
+}
+
+VALUE brs_ext_allocate_compressor(VALUE klass)
+{
+  brs_ext_compressor_t* compressor_ptr;
+
+  VALUE self = Data_Make_Struct(klass, brs_ext_compressor_t, NULL, free_compressor, compressor_ptr);
+
+  compressor_ptr->state_ptr                           = 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)            \
+  brs_ext_compressor_t* compressor_ptr; \
+  Data_Get_Struct(self, brs_ext_compressor_t, compressor_ptr);
+
+VALUE brs_ext_initialize_compressor(VALUE self, VALUE options)
+{
+  GET_COMPRESSOR(self);
+  Check_Type(options, T_HASH);
+  BRS_EXT_GET_COMPRESSOR_OPTIONS(options);
+  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
+
+  BrotliEncoderState* state_ptr = BrotliEncoderCreateInstance(NULL, NULL, NULL);
+  if (state_ptr == NULL) {
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  brs_ext_result_t ext_result = brs_ext_set_compressor_options(state_ptr, &compressor_options);
+  if (ext_result != 0) {
+    BrotliEncoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(ext_result);
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR;
+  }
+
+  uint8_t* destination_buffer = malloc(destination_buffer_length);
+  if (destination_buffer == NULL) {
+    BrotliEncoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  compressor_ptr->state_ptr                           = state_ptr;
+  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->state_ptr == NULL || compressor_ptr->destination_buffer == NULL) { \
+    brs_ext_raise_error(BRS_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); \
+  const uint8_t* remaining_source        = (const uint8_t*)source;    \
+  size_t         remaining_source_length = source_length;
+
+VALUE brs_ext_compress(VALUE self, VALUE source_value)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+  GET_SOURCE_DATA(source_value);
+
+  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+
+  BROTLI_BOOL result = BrotliEncoderCompressStream(
+    state_ptr,
+    BROTLI_OPERATION_PROCESS,
+    &remaining_source_length, &remaining_source,
+    &compressor_ptr->remaining_destination_buffer_length, &compressor_ptr->remaining_destination_buffer,
+    NULL);
+
+  if (!result) {
+    brs_ext_raise_error(BRS_EXT_ERROR_UNEXPECTED);
+  }
+
+  VALUE bytes_written          = UINT2NUM(source_length - remaining_source_length);
+  VALUE needs_more_destination = BrotliEncoderHasMoreOutput(state_ptr) ? Qtrue : Qfalse;
+
+  return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
+}
+
+VALUE brs_ext_flush_compressor(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+
+  const uint8_t* remaining_source        = NULL;
+  size_t         remaining_source_length = 0;
+
+  BROTLI_BOOL result = BrotliEncoderCompressStream(
+    state_ptr,
+    BROTLI_OPERATION_FLUSH,
+    &remaining_source_length, &remaining_source,
+    &compressor_ptr->remaining_destination_buffer_length, &compressor_ptr->remaining_destination_buffer,
+    NULL);
+
+  if (!result) {
+    brs_ext_raise_error(BRS_EXT_ERROR_UNEXPECTED);
+  }
+
+  VALUE needs_more_destination = BrotliEncoderHasMoreOutput(state_ptr) ? Qtrue : Qfalse;
+
+  return needs_more_destination;
+}
+
+VALUE brs_ext_finish_compressor(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+
+  const uint8_t* remaining_source        = NULL;
+  size_t         remaining_source_length = 0;
+
+  BROTLI_BOOL result = BrotliEncoderCompressStream(
+    state_ptr,
+    BROTLI_OPERATION_FINISH,
+    &remaining_source_length, &remaining_source,
+    &compressor_ptr->remaining_destination_buffer_length, &compressor_ptr->remaining_destination_buffer,
+    NULL);
+
+  if (!result) {
+    brs_ext_raise_error(BRS_EXT_ERROR_UNEXPECTED);
+  }
+
+  VALUE needs_more_destination = (BrotliEncoderHasMoreOutput(state_ptr) || !BrotliEncoderIsFinished(state_ptr)) ? Qtrue : Qfalse;
+
+  return needs_more_destination;
+}
+
+VALUE brs_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 brs_ext_compressor_close(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    BrotliEncoderDestroyInstance(state_ptr);
+
+    compressor_ptr->state_ptr = 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 brs_ext_compressor_exports(VALUE root_module)
+{
+  VALUE stream = rb_define_module_under(root_module, "Stream");
+
+  VALUE compressor = rb_define_class_under(stream, "NativeCompressor", rb_cObject);
+  rb_define_alloc_func(compressor, brs_ext_allocate_compressor);
+  rb_define_method(compressor, "initialize", brs_ext_initialize_compressor, 1);
+  rb_define_method(compressor, "write", brs_ext_compress, 1);
+  rb_define_method(compressor, "flush", brs_ext_flush_compressor, 0);
+  rb_define_method(compressor, "finish", brs_ext_finish_compressor, 0);
+  rb_define_method(compressor, "read_result", brs_ext_compressor_read_result, 0);
+  rb_define_method(compressor, "close", brs_ext_compressor_close, 0);
+}

data/ext/brs_ext/stream/compressor.h

@@ -0,0 +1,31 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(BRS_EXT_STREAM_COMPRESSOR_H)
+#define BRS_EXT_STREAM_COMPRESSOR_H
+
+#include <brotli/encode.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "ruby.h"
+
+typedef struct {
+  BrotliEncoderState* state_ptr;
+  uint8_t*            destination_buffer;
+  size_t              destination_buffer_length;
+  uint8_t*            remaining_destination_buffer;
+  size_t              remaining_destination_buffer_length;
+} brs_ext_compressor_t;
+
+VALUE brs_ext_allocate_compressor(VALUE klass);
+VALUE brs_ext_initialize_compressor(VALUE self, VALUE options);
+VALUE brs_ext_compress(VALUE self, VALUE source);
+VALUE brs_ext_flush_compressor(VALUE self);
+VALUE brs_ext_finish_compressor(VALUE self);
+VALUE brs_ext_compressor_read_result(VALUE self);
+VALUE brs_ext_compressor_close(VALUE self);
+
+void brs_ext_compressor_exports(VALUE root_module);
+
+#endif // BRS_EXT_STREAM_COMPRESSOR_H

data/ext/brs_ext/stream/decompressor.c

@@ -0,0 +1,181 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "brs_ext/stream/decompressor.h"
+
+#include <brotli/decode.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "brs_ext/buffer.h"
+#include "brs_ext/common.h"
+#include "brs_ext/error.h"
+#include "brs_ext/option.h"
+#include "ruby.h"
+
+static void free_decompressor(brs_ext_decompressor_t* decompressor_ptr)
+{
+  BrotliDecoderState* state_ptr = decompressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    BrotliDecoderDestroyInstance(state_ptr);
+  }
+
+  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+  }
+
+  free(decompressor_ptr);
+}
+
+VALUE brs_ext_allocate_decompressor(VALUE klass)
+{
+  brs_ext_decompressor_t* decompressor_ptr;
+
+  VALUE self = Data_Make_Struct(klass, brs_ext_decompressor_t, NULL, free_decompressor, decompressor_ptr);
+
+  decompressor_ptr->state_ptr                           = 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)              \
+  brs_ext_decompressor_t* decompressor_ptr; \
+  Data_Get_Struct(self, brs_ext_decompressor_t, decompressor_ptr);
+
+VALUE brs_ext_initialize_decompressor(VALUE self, VALUE options)
+{
+  GET_DECOMPRESSOR(self);
+  Check_Type(options, T_HASH);
+  BRS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
+
+  BrotliDecoderState* state_ptr = BrotliDecoderCreateInstance(NULL, NULL, NULL);
+  if (state_ptr == NULL) {
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  brs_ext_result_t ext_result = brs_ext_set_decompressor_options(state_ptr, &decompressor_options);
+  if (ext_result != 0) {
+    BrotliDecoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(ext_result);
+  }
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR;
+  }
+
+  uint8_t* destination_buffer = malloc(destination_buffer_length);
+  if (destination_buffer == NULL) {
+    BrotliDecoderDestroyInstance(state_ptr);
+    brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  decompressor_ptr->state_ptr                           = state_ptr;
+  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->state_ptr == NULL || decompressor_ptr->destination_buffer == NULL) { \
+    brs_ext_raise_error(BRS_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); \
+  const uint8_t* remaining_source        = (const uint8_t*)source;    \
+  size_t         remaining_source_length = source_length;
+
+VALUE brs_ext_decompress(VALUE self, VALUE source_value)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+  GET_SOURCE_DATA(source_value);
+
+  BrotliDecoderResult result = BrotliDecoderDecompressStream(
+    decompressor_ptr->state_ptr,
+    &remaining_source_length, &remaining_source,
+    &decompressor_ptr->remaining_destination_buffer_length, &decompressor_ptr->remaining_destination_buffer,
+    NULL);
+
+  if (
+    result != BROTLI_DECODER_RESULT_SUCCESS &&
+    result != BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT &&
+    result != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+    BrotliDecoderErrorCode error_code = BrotliDecoderGetErrorCode(decompressor_ptr->state_ptr);
+    brs_ext_raise_error(brs_ext_get_decompressor_error(error_code));
+  }
+
+  VALUE bytes_written          = UINT2NUM(source_length - remaining_source_length);
+  VALUE needs_more_destination = result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT ? Qtrue : Qfalse;
+
+  return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
+}
+
+VALUE brs_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 brs_ext_decompressor_close(VALUE self)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+
+  BrotliDecoderState* state_ptr = decompressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    BrotliDecoderDestroyInstance(state_ptr);
+
+    decompressor_ptr->state_ptr = 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 brs_ext_decompressor_exports(VALUE root_module)
+{
+  VALUE stream = rb_define_module_under(root_module, "Stream");
+
+  VALUE decompressor = rb_define_class_under(stream, "NativeDecompressor", rb_cObject);
+  rb_define_alloc_func(decompressor, brs_ext_allocate_decompressor);
+  rb_define_method(decompressor, "initialize", brs_ext_initialize_decompressor, 1);
+  rb_define_method(decompressor, "read", brs_ext_decompress, 1);
+  rb_define_method(decompressor, "read_result", brs_ext_decompressor_read_result, 0);
+  rb_define_method(decompressor, "close", brs_ext_decompressor_close, 0);
+}

data/ext/brs_ext/stream/decompressor.h

@@ -0,0 +1,29 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(BRS_EXT_STREAM_DECOMPRESSOR_H)
+#define BRS_EXT_STREAM_DECOMPRESSOR_H
+
+#include <brotli/decode.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "ruby.h"
+
+typedef struct {
+  BrotliDecoderState* state_ptr;
+  uint8_t*            destination_buffer;
+  size_t              destination_buffer_length;
+  uint8_t*            remaining_destination_buffer;
+  size_t              remaining_destination_buffer_length;
+} brs_ext_decompressor_t;
+
+VALUE brs_ext_allocate_decompressor(VALUE klass);
+VALUE brs_ext_initialize_decompressor(VALUE self, VALUE options);
+VALUE brs_ext_decompress(VALUE self, VALUE source);
+VALUE brs_ext_decompressor_read_result(VALUE self);
+VALUE brs_ext_decompressor_close(VALUE self);
+
+void brs_ext_decompressor_exports(VALUE root_module);
+
+#endif // BRS_EXT_STREAM_DECOMPRESSOR_H