ruby-brs 1.1.4 → 1.3.0

data/ext/brs_ext/option.c

@@ -3,20 +3,16 @@
 
 #include "brs_ext/option.h"
 
-#include <brotli/decode.h>
-#include <brotli/encode.h>
-
 #include "brs_ext/error.h"
-#include "ruby.h"
 
 // -- values --
 
-static inline VALUE get_raw_option_value(VALUE options, const char* name)
+static inline VALUE get_raw_value(VALUE options, const char* name)
 {
   return rb_funcall(options, rb_intern("[]"), 1, ID2SYM(rb_intern(name)));
 }
 
-static inline bool get_bool_option_value(VALUE raw_value)
+static inline bool get_bool_value(VALUE raw_value)
 {
   int raw_type = TYPE(raw_value);
   if (raw_type != T_TRUE && raw_type != T_FALSE) {
@@ -26,35 +22,39 @@ static inline bool get_bool_option_value(VALUE raw_value)
   return raw_type == T_TRUE;
 }
 
-static inline unsigned int get_uint_option_value(VALUE raw_value)
+static inline unsigned int get_uint_value(VALUE raw_value)
 {
   Check_Type(raw_value, T_FIXNUM);
 
   return NUM2UINT(raw_value);
 }
 
-static inline BrotliEncoderMode get_mode_option_value(VALUE raw_value)
+static inline size_t get_size_value(VALUE raw_value)
+{
+  Check_Type(raw_value, T_FIXNUM);
+
+  return NUM2SIZET(raw_value);
+}
+
+static inline BrotliEncoderMode get_mode_value(VALUE raw_value)
 {
   Check_Type(raw_value, T_SYMBOL);
 
   ID raw_id = SYM2ID(raw_value);
   if (raw_id == rb_intern("text")) {
     return BROTLI_MODE_TEXT;
-  }
-  else if (raw_id == rb_intern("font")) {
+  } else if (raw_id == rb_intern("font")) {
     return BROTLI_MODE_FONT;
-  }
-  else if (raw_id == rb_intern("generic")) {
+  } else if (raw_id == rb_intern("generic")) {
     return BROTLI_MODE_GENERIC;
-  }
-  else {
+  } else {
     brs_ext_raise_error(BRS_EXT_ERROR_VALIDATE_FAILED);
   }
 }
 
-void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_type_t type, const char* name)
+void brs_ext_resolve_option(VALUE options, brs_ext_option_t* option, brs_ext_option_type_t type, const char* name)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
+  VALUE raw_value = get_raw_value(options, name);
 
   option->has_value = raw_value != Qnil;
   if (!option->has_value) {
@@ -65,13 +65,13 @@ void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_
 
   switch (type) {
     case BRS_EXT_OPTION_TYPE_BOOL:
-      value = get_bool_option_value(raw_value) ? 1 : 0;
+      value = get_bool_value(raw_value) ? 1 : 0;
       break;
     case BRS_EXT_OPTION_TYPE_UINT:
-      value = (brs_ext_option_value_t)get_uint_option_value(raw_value);
+      value = (brs_ext_option_value_t) get_uint_value(raw_value);
       break;
     case BRS_EXT_OPTION_TYPE_MODE:
-      value = (brs_ext_option_value_t)get_mode_option_value(raw_value);
+      value = (brs_ext_option_value_t) get_mode_value(raw_value);
       break;
     default:
       brs_ext_raise_error(BRS_EXT_ERROR_UNEXPECTED);
@@ -80,13 +80,18 @@ void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_
   option->value = value;
 }
 
-size_t brs_ext_get_size_option_value(VALUE options, const char* name)
+bool brs_ext_get_bool_option_value(VALUE options, const char* name)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
+  VALUE raw_value = get_raw_value(options, name);
 
-  Check_Type(raw_value, T_FIXNUM);
+  return get_bool_value(raw_value);
+}
 
-  return NUM2SIZET(raw_value);
+size_t brs_ext_get_size_option_value(VALUE options, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+
+  return get_size_value(raw_value);
 }
 
 // -- set params --
@@ -105,7 +110,10 @@ brs_ext_result_t brs_ext_set_compressor_options(BrotliEncoderState* state_ptr, b
   SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_QUALITY, options->quality);
   SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_LGWIN, options->lgwin);
   SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_LGBLOCK, options->lgblock);
-  SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING, options->disable_literal_context_modeling);
+  SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_NPOSTFIX, options->npostfix);
+  SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_NDIRECT, options->ndirect);
+  SET_ENCODER_PARAM(
+    state_ptr, BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING, options->disable_literal_context_modeling);
   SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_SIZE_HINT, options->size_hint);
   SET_ENCODER_PARAM(state_ptr, BROTLI_PARAM_LARGE_WINDOW, options->large_window);
 
@@ -115,9 +123,12 @@ brs_ext_result_t brs_ext_set_compressor_options(BrotliEncoderState* state_ptr, b
 #define SET_DECODER_PARAM(state_ptr, param, option) \
   SET_OPTION_VALUE(BrotliDecoderSetParameter, state_ptr, param, option);
 
-brs_ext_result_t brs_ext_set_decompressor_options(BrotliDecoderState* state_ptr, brs_ext_decompressor_options_t* options)
+brs_ext_result_t brs_ext_set_decompressor_options(
+  BrotliDecoderState*             state_ptr,
+  brs_ext_decompressor_options_t* options)
 {
-  SET_DECODER_PARAM(state_ptr, BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION, options->disable_ring_buffer_reallocation);
+  SET_DECODER_PARAM(
+    state_ptr, BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION, options->disable_ring_buffer_reallocation);
   SET_DECODER_PARAM(state_ptr, BROTLI_DECODER_PARAM_LARGE_WINDOW, options->large_window);
 
   return 0;
@@ -125,6 +136,14 @@ brs_ext_result_t brs_ext_set_decompressor_options(BrotliDecoderState* state_ptr,
 
 // -- exports --
 
+#define BROTLI_MIN_NPOSTFIX 0
+#define BROTLI_MAX_NPOSTFIX 3
+
+#define BROTLI_MIN_NDIRECT                0
+#define BROTLI_NDIRECT_NPOSTFIX_STEP_BASE 1
+#define BROTLI_NDIRECT_NPOSTFIX_MAX_BASE  0xf
+#define BROTLI_MAX_NDIRECT                (BROTLI_NDIRECT_NPOSTFIX_MAX_BASE << BROTLI_MAX_NPOSTFIX)
+
 #define EXPORT_PARAM_BOUNDS(module, param, name)                      \
   rb_define_const(module, "MIN_" name, UINT2NUM(BROTLI_MIN_##param)); \
   rb_define_const(module, "MAX_" name, UINT2NUM(BROTLI_MAX_##param));
@@ -133,15 +152,17 @@ void brs_ext_option_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Option");
 
-  VALUE modes = rb_ary_new_from_args(
-    3,
-    ID2SYM(rb_intern("text")),
-    ID2SYM(rb_intern("font")),
-    ID2SYM(rb_intern("generic")));
+  VALUE modes =
+    rb_ary_new_from_args(3, ID2SYM(rb_intern("text")), ID2SYM(rb_intern("font")), ID2SYM(rb_intern("generic")));
   rb_define_const(module, "MODES", modes);
   RB_GC_GUARD(modes);
 
-  EXPORT_PARAM_BOUNDS(module, QUALITY, "QUALITY");
-  EXPORT_PARAM_BOUNDS(module, WINDOW_BITS, "LGWIN");
   EXPORT_PARAM_BOUNDS(module, INPUT_BLOCK_BITS, "LGBLOCK");
+  EXPORT_PARAM_BOUNDS(module, WINDOW_BITS, "LGWIN");
+  EXPORT_PARAM_BOUNDS(module, QUALITY, "QUALITY");
+  EXPORT_PARAM_BOUNDS(module, NPOSTFIX, "NPOSTFIX");
+  EXPORT_PARAM_BOUNDS(module, NDIRECT, "NDIRECT");
+
+  rb_define_const(module, "NDIRECT_NPOSTFIX_STEP_BASE", UINT2NUM(BROTLI_NDIRECT_NPOSTFIX_STEP_BASE));
+  rb_define_const(module, "NDIRECT_NPOSTFIX_MAX_BASE", UINT2NUM(BROTLI_NDIRECT_NPOSTFIX_MAX_BASE));
 }

data/ext/brs_ext/option.h

@@ -15,7 +15,8 @@
 // Default option values depends on brotli library.
 // We will set only user defined values.
 
-enum {
+enum
+{
   BRS_EXT_OPTION_TYPE_BOOL = 1,
   BRS_EXT_OPTION_TYPE_UINT,
   BRS_EXT_OPTION_TYPE_MODE
@@ -24,55 +25,66 @@ enum {
 typedef brs_ext_byte_fast_t brs_ext_option_type_t;
 typedef uint32_t            brs_ext_option_value_t;
 
-typedef struct {
+typedef struct
+{
   bool                   has_value;
   brs_ext_option_value_t value;
 } brs_ext_option_t;
 
-typedef struct {
+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 npostfix;
+  brs_ext_option_t ndirect;
   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 {
+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_UINT, quality);                          \
-  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, lgwin);                            \
-  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, 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_UINT, 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);
-
+void brs_ext_resolve_option(VALUE options, brs_ext_option_t* option, brs_ext_option_type_t type, const char* name);
+
+#define BRS_EXT_RESOLVE_OPTION(options, target_options, type, name) \
+  brs_ext_resolve_option(options, &target_options.name, type, #name);
+
+#define BRS_EXT_GET_COMPRESSOR_OPTIONS(options)                                                                    \
+  brs_ext_compressor_options_t compressor_options;                                                                 \
+                                                                                                                   \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_MODE, mode);                             \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, quality);                          \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, lgwin);                            \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, lgblock);                          \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, npostfix);                         \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, ndirect);                          \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_BOOL, disable_literal_context_modeling); \
+  BRS_EXT_RESOLVE_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_UINT, size_hint);                        \
+  BRS_EXT_RESOLVE_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_RESOLVE_OPTION(options, decompressor_options, BRS_EXT_OPTION_TYPE_BOOL, disable_ring_buffer_reallocation); \
+  BRS_EXT_RESOLVE_OPTION(options, decompressor_options, BRS_EXT_OPTION_TYPE_BOOL, large_window);
+
+bool   brs_ext_get_bool_option_value(VALUE options, const char* name);
 size_t brs_ext_get_size_option_value(VALUE options, const char* name);
 
-#define BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) \
-  size_t name = brs_ext_get_size_option_value(options, #name);
+#define BRS_EXT_GET_BOOL_OPTION(options, name) size_t name = brs_ext_get_bool_option_value(options, #name);
+#define BRS_EXT_GET_SIZE_OPTION(options, name) size_t name = brs_ext_get_size_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);
+
+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);
 

data/ext/brs_ext/stream/compressor.c

@@ -3,13 +3,14 @@
 
 #include "brs_ext/stream/compressor.h"
 
-#include <brotli/encode.h>
 #include <brotli/types.h>
 
 #include "brs_ext/buffer.h"
 #include "brs_ext/error.h"
+#include "brs_ext/gvl.h"
 #include "brs_ext/option.h"
-#include "ruby.h"
+
+// -- initialization --
 
 static void free_compressor(brs_ext_compressor_t* compressor_ptr)
 {
@@ -29,14 +30,14 @@ static void free_compressor(brs_ext_compressor_t* 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);
+  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;
+  compressor_ptr->gvl                                 = false;
 
   return self;
 }
@@ -49,8 +50,9 @@ VALUE brs_ext_initialize_compressor(VALUE self, VALUE options)
 {
   GET_COMPRESSOR(self);
   Check_Type(options, T_HASH);
+  BRS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  BRS_EXT_GET_BOOL_OPTION(options, gvl);
   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) {
@@ -78,72 +80,137 @@ VALUE brs_ext_initialize_compressor(VALUE self, VALUE options)
   compressor_ptr->destination_buffer_length           = destination_buffer_length;
   compressor_ptr->remaining_destination_buffer        = destination_buffer;
   compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+  compressor_ptr->gvl                                 = gvl;
 
   return Qnil;
 }
 
+// -- compress --
+
 #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 brs_ext_byte_t* remaining_source        = (const brs_ext_byte_t*)source; \
-  size_t                remaining_source_length = source_length;
+typedef struct
+{
+  brs_ext_compressor_t* compressor_ptr;
+  const brs_ext_byte_t* remaining_source;
+  size_t*               remaining_source_length_ptr;
+  BROTLI_BOOL           result;
+} compress_args_t;
+
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t*      args           = data;
+  brs_ext_compressor_t* compressor_ptr = args->compressor_ptr;
+
+  args->result = BrotliEncoderCompressStream(
+    compressor_ptr->state_ptr,
+    BROTLI_OPERATION_PROCESS,
+    args->remaining_source_length_ptr,
+    &args->remaining_source,
+    &compressor_ptr->remaining_destination_buffer_length,
+    &compressor_ptr->remaining_destination_buffer,
+    NULL);
+
+  return NULL;
+}
 
 VALUE brs_ext_compress(VALUE self, VALUE source_value)
 {
   GET_COMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
 
-  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+  const char*           source                  = RSTRING_PTR(source_value);
+  size_t                source_length           = RSTRING_LEN(source_value);
+  const brs_ext_byte_t* remaining_source        = (const brs_ext_byte_t*) source;
+  size_t                remaining_source_length = source_length;
 
-  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);
+  compress_args_t args = {
+    .compressor_ptr              = compressor_ptr,
+    .remaining_source            = remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
 
-  if (!result) {
+  BRS_EXT_GVL_WRAP(compressor_ptr->gvl, compress_wrapper, &args);
+  if (!args.result) {
     brs_ext_raise_error(BRS_EXT_ERROR_UNEXPECTED);
   }
 
   VALUE bytes_written          = SIZET2NUM(source_length - remaining_source_length);
-  VALUE needs_more_destination = BrotliEncoderHasMoreOutput(state_ptr) ? Qtrue : Qfalse;
+  VALUE needs_more_destination = BrotliEncoderHasMoreOutput(compressor_ptr->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);
+// -- compressor flush --
 
-  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+typedef struct
+{
+  brs_ext_compressor_t* compressor_ptr;
+  BROTLI_BOOL           result;
+} compressor_flush_args_t;
 
-  const brs_ext_byte_t* remaining_source        = NULL;
-  size_t                remaining_source_length = 0;
+static inline void* compressor_flush_wrapper(void* data)
+{
+  compressor_flush_args_t* args                    = data;
+  brs_ext_compressor_t*    compressor_ptr          = args->compressor_ptr;
+  const brs_ext_byte_t*    remaining_source        = NULL;
+  size_t                   remaining_source_length = 0;
 
-  BROTLI_BOOL result = BrotliEncoderCompressStream(
-    state_ptr,
+  args->result = BrotliEncoderCompressStream(
+    compressor_ptr->state_ptr,
     BROTLI_OPERATION_FLUSH,
-    &remaining_source_length, &remaining_source,
-    &compressor_ptr->remaining_destination_buffer_length, &compressor_ptr->remaining_destination_buffer,
+    &remaining_source_length,
+    &remaining_source,
+    &compressor_ptr->remaining_destination_buffer_length,
+    &compressor_ptr->remaining_destination_buffer,
     NULL);
 
-  if (!result) {
+  return NULL;
+}
+
+VALUE brs_ext_flush_compressor(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  compressor_flush_args_t args = {.compressor_ptr = compressor_ptr};
+
+  BRS_EXT_GVL_WRAP(compressor_ptr->gvl, compressor_flush_wrapper, &args);
+  if (!args.result) {
     brs_ext_raise_error(BRS_EXT_ERROR_UNEXPECTED);
   }
 
-  VALUE needs_more_destination = BrotliEncoderHasMoreOutput(state_ptr) ? Qtrue : Qfalse;
+  return BrotliEncoderHasMoreOutput(compressor_ptr->state_ptr) ? Qtrue : Qfalse;
+}
+
+// -- compressor finish --
+
+typedef struct
+{
+  brs_ext_compressor_t* compressor_ptr;
+  BROTLI_BOOL           result;
+} compressor_finish_args_t;
+
+static inline void* compressor_finish_wrapper(void* data)
+{
+  compressor_finish_args_t* args                    = data;
+  brs_ext_compressor_t*     compressor_ptr          = args->compressor_ptr;
+  const brs_ext_byte_t*     remaining_source        = NULL;
+  size_t                    remaining_source_length = 0;
+
+  args->result = BrotliEncoderCompressStream(
+    compressor_ptr->state_ptr,
+    BROTLI_OPERATION_FINISH,
+    &remaining_source_length,
+    &remaining_source,
+    &compressor_ptr->remaining_destination_buffer_length,
+    &compressor_ptr->remaining_destination_buffer,
+    NULL);
 
-  return needs_more_destination;
+  return NULL;
 }
 
 VALUE brs_ext_finish_compressor(VALUE self)
@@ -151,27 +218,21 @@ VALUE brs_ext_finish_compressor(VALUE self)
   GET_COMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
 
-  BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
+  compressor_finish_args_t args = {.compressor_ptr = compressor_ptr};
 
-  const brs_ext_byte_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_GVL_WRAP(compressor_ptr->gvl, compressor_finish_wrapper, &args);
+  if (!args.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;
+  return (BrotliEncoderHasMoreOutput(compressor_ptr->state_ptr) ||
+          !BrotliEncoderIsFinished(compressor_ptr->state_ptr)) ?
+           Qtrue :
+           Qfalse;
 }
 
+// -- other --
+
 VALUE brs_ext_compressor_read_result(VALUE self)
 {
   GET_COMPRESSOR(self);
@@ -181,10 +242,9 @@ VALUE brs_ext_compressor_read_result(VALUE self)
   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;
+  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);
+  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;
@@ -192,6 +252,8 @@ VALUE brs_ext_compressor_read_result(VALUE self)
   return result_value;
 }
 
+// -- cleanup --
+
 VALUE brs_ext_compressor_close(VALUE self)
 {
   GET_COMPRESSOR(self);
@@ -217,6 +279,8 @@ VALUE brs_ext_compressor_close(VALUE self)
   return Qnil;
 }
 
+// -- exports --
+
 void brs_ext_compressor_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Stream");

data/ext/brs_ext/stream/compressor.h

@@ -5,17 +5,20 @@
 #define BRS_EXT_STREAM_COMPRESSOR_H
 
 #include <brotli/encode.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include "brs_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   BrotliEncoderState* state_ptr;
   brs_ext_byte_t*     destination_buffer;
   size_t              destination_buffer_length;
   brs_ext_byte_t*     remaining_destination_buffer;
   size_t              remaining_destination_buffer_length;
+  bool                gvl;
 } brs_ext_compressor_t;
 
 VALUE brs_ext_allocate_compressor(VALUE klass);