ruby-brs 1.1.1 → 1.2.0

data/ext/brs_ext/main.c

@@ -2,7 +2,6 @@
 // Copyright (c) 2019 AUTHORS, MIT License.
 
 #include "brs_ext/buffer.h"
-#include "brs_ext/common.h"
 #include "brs_ext/io.h"
 #include "brs_ext/option.h"
 #include "brs_ext/stream/compressor.h"

data/ext/brs_ext/option.c

@@ -5,21 +5,18 @@
 
 #include <brotli/decode.h>
 #include <brotli/encode.h>
-#include <stdbool.h>
-#include <stdlib.h>
 
-#include "brs_ext/common.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) {
@@ -29,35 +26,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) {
@@ -68,13 +69,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);
@@ -83,13 +84,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 --
@@ -108,7 +114,8 @@ 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_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);
 
@@ -118,9 +125,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;
@@ -136,11 +146,8 @@ 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);
 

data/ext/brs_ext/option.h

@@ -7,7 +7,6 @@
 #include <brotli/decode.h>
 #include <brotli/encode.h>
 #include <stdbool.h>
-#include <stdint.h>
 #include <stdlib.h>
 
 #include "brs_ext/common.h"
@@ -16,21 +15,24 @@
 // 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
 };
 
-typedef uint_fast8_t brs_ext_option_type_t;
-typedef uint32_t     brs_ext_option_value_t;
+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;
@@ -40,40 +42,45 @@ typedef struct {
   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_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

@@ -5,15 +5,15 @@
 
 #include <brotli/encode.h>
 #include <brotli/types.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/gvl.h"
 #include "brs_ext/option.h"
 #include "ruby.h"
 
+// -- initialization --
+
 static void free_compressor(brs_ext_compressor_t* compressor_ptr)
 {
   BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
@@ -21,7 +21,7 @@ static void free_compressor(brs_ext_compressor_t* compressor_ptr)
     BrotliEncoderDestroyInstance(state_ptr);
   }
 
-  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  brs_ext_byte_t* destination_buffer = compressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
   }
@@ -32,14 +32,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;
 }
@@ -52,8 +52,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) {
@@ -70,7 +71,7 @@ VALUE brs_ext_initialize_compressor(VALUE self, VALUE options)
     destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR;
   }
 
-  uint8_t* destination_buffer = malloc(destination_buffer_length);
+  brs_ext_byte_t* destination_buffer = malloc(destination_buffer_length);
   if (destination_buffer == NULL) {
     BrotliEncoderDestroyInstance(state_ptr);
     brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
@@ -81,72 +82,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 uint8_t* remaining_source        = (const uint8_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 uint8_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 --
 
-  return needs_more_destination;
+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 NULL;
 }
 
 VALUE brs_ext_finish_compressor(VALUE self)
@@ -154,40 +220,33 @@ 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);
+  compressor_finish_args_t args = {.compressor_ptr = compressor_ptr};
 
-  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);
   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;
+  brs_ext_byte_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;
+  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;
@@ -195,6 +254,8 @@ VALUE brs_ext_compressor_read_result(VALUE self)
   return result_value;
 }
 
+// -- cleanup --
+
 VALUE brs_ext_compressor_close(VALUE self)
 {
   GET_COMPRESSOR(self);
@@ -207,7 +268,7 @@ VALUE brs_ext_compressor_close(VALUE self)
     compressor_ptr->state_ptr = NULL;
   }
 
-  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  brs_ext_byte_t* destination_buffer = compressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
 
@@ -220,6 +281,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");