ruby-brs 1.1.5 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a66abcbdc6c29138075e622a75c3af830c333b3534429d97c57d08f568e0c6ae
-  data.tar.gz: 1326fc334ec25dcfef28777cbe9defa15ffde9d84df48773bfd5199d140510a1
+  metadata.gz: 239de67878a08e54f6b89af1381711ad94c70c1f29d99c8dca22ced06ebd850a
+  data.tar.gz: 2601159e2ede572b8bcdc8ce0ee7ca738f06f42cb0d6e59a159eb525e2f70420
 SHA512:
-  metadata.gz: 690e7ac3f938f10028ea88d50933a5f6b59f7ad8040966356655760bc5dc3deaaa27a89fc3b98e85565edf373015075ca1424a6c894557c6d6dc7c52bee83a9f
-  data.tar.gz: 2daa6c5c07566869cdb1f5826a8ab9584ff7c1371140edfba33dcd1bdbaf1ea02dcbebb2c0ee405c44692658bdbbaad326482c4069d761d05e86a4dfc8dcdb9d
+  metadata.gz: d12cfbf9280a63ad850ce4198e1bdaa044afc4502bccdeadeef8af746f1806182fb560bd580dd0bafafeaff93fd8e2e40435d7ac12079bad89a79b9cb22ef088
+  data.tar.gz: 13cb28b02d174fe3c448f291b85a80625cabb3f07ab32f5a5233a244425299ed04f248737be934d9f3171c6bc93c31062cbb1e7daf9f146e46a617163298a678

data/README.md

@@ -1,8 +1,8 @@
 # Ruby bindings for brotli library
 
-| Travis | AppVeyor | Circle | Codecov |
-| :---:  | :---:    | :---:  | :---:   |
-| [![Travis test status](https://travis-ci.com/andrew-aladev/ruby-brs.svg?branch=master)](https://travis-ci.com/andrew-aladev/ruby-brs) | [![AppVeyor test status](https://ci.appveyor.com/api/projects/status/github/andrew-aladev/ruby-brs?branch=master&svg=true)](https://ci.appveyor.com/project/andrew-aladev/ruby-brs/branch/master) | [![Circle test status](https://circleci.com/gh/andrew-aladev/ruby-brs/tree/master.svg?style=shield)](https://circleci.com/gh/andrew-aladev/ruby-brs/tree/master) | [![Codecov](https://codecov.io/gh/andrew-aladev/ruby-brs/branch/master/graph/badge.svg)](https://codecov.io/gh/andrew-aladev/ruby-brs) |
+| Travis | AppVeyor | Circle | Codecov | Gem   |
+| :---:  | :---:    | :---:  | :---:   | :---: |
+| [![Travis test status](https://travis-ci.com/andrew-aladev/ruby-brs.svg?branch=master)](https://travis-ci.com/andrew-aladev/ruby-brs) | [![AppVeyor test status](https://ci.appveyor.com/api/projects/status/github/andrew-aladev/ruby-brs?branch=master&svg=true)](https://ci.appveyor.com/project/andrew-aladev/ruby-brs/branch/master) | [![Circle test status](https://circleci.com/gh/andrew-aladev/ruby-brs/tree/master.svg?style=shield)](https://circleci.com/gh/andrew-aladev/ruby-brs/tree/master) | [![Codecov](https://codecov.io/gh/andrew-aladev/ruby-brs/branch/master/graph/badge.svg)](https://codecov.io/gh/andrew-aladev/ruby-brs) | [![Gem](https://img.shields.io/gem/v/ruby-brs.svg)](https://rubygems.org/gems/ruby-brs) |
 
 See [brotli library](https://github.com/google/brotli).
 
@@ -61,7 +61,7 @@ ensure
 end
 ```
 
-You can create and read `tar.br` archives with `minitar` for example.
+You can create and read `tar.br` archives with [minitar](https://github.com/halostatue/minitar) for example.
 
 ```ruby
 require "brs"
@@ -83,12 +83,25 @@ BRS::Stream::Reader.open "file.tar.br" do |reader|
 end
 ```
 
+You can also use `Content-Encoding: br` with [sinatra](http://sinatrarb.com):
+
+```ruby
+require "brs"
+require "sinatra"
+
+get "/" do
+  headers["Content-Encoding"] = "br"
+  BRS::String.compress "sample string"
+end
+```
+
 ## Options
 
 | Option                             | Values     | Default    | Description |
 |------------------------------------|------------|------------|-------------|
 | `source_buffer_length`             | 0 - inf    | 0 (auto)   | internal buffer length for source data |
 | `destination_buffer_length`        | 0 - inf    | 0 (auto)   | internal buffer length for description data |
+| `gvl`                              | true/false | false      | enables global VM lock where possible |
 | `mode`                             | `MODES`    | `:generic` | compressor mode |
 | `quality`                          | 0 - 11     | 11         | compression level |
 | `lgwin`                            | 10 - 24    | 22         | compressor window size |
@@ -102,6 +115,10 @@ There are internal buffers for compressed and decompressed data.
 For example you want to use 1 KB as `source_buffer_length` for compressor - please use 256 B as `destination_buffer_length`.
 You want to use 256 B as `source_buffer_length` for decompressor - please use 1 KB as `destination_buffer_length`.
 
+`gvl` is disabled by default, this mode allows running multiple compressors/decompressors in different threads simultaneously.
+Please consider enabling `gvl` if you don't want to launch processors in separate threads.
+If `gvl` is enabled ruby won't waste time on acquiring/releasing VM lock.
+
 `String` and `File` will set `:size_hint` automaticaly.
 
 You can also read brotli docs for more info about options.
@@ -117,6 +134,7 @@ Possible compressor options:
 ```
 :source_buffer_length
 :destination_buffer_length
+:gvl
 :mode
 :quality
 :lgwin
@@ -130,6 +148,7 @@ Possible decompressor options:
 ```
 :source_buffer_length
 :destination_buffer_length
+:gvl
 :disable_ring_buffer_reallocation
 :large_window
 ```
@@ -143,18 +162,6 @@ data = BRS::String.compress "sample string", :quality => 5
 puts BRS::String.decompress(data, :disable_ring_buffer_reallocation => true)
 ```
 
-HTTP encoding (`Content-Encoding: br`) using default options:
-
-```ruby
-require "brs"
-require "sinatra"
-
-get "/" do
-  headers["Content-Encoding"] = "br"
-  BRS::String.compress "sample string"
-end
-```
-
 ## String
 
 String maintains destination buffer only, so it accepts `destination_buffer_length` option only.
@@ -330,12 +337,18 @@ See [`IO`](https://ruby-doc.org/core-2.7.0/IO.html) docs.
 
 Typical helpers, see [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.7.0/libdoc/zlib/rdoc/Zlib/GzipReader.html) docs.
 
+## Thread safety
+
+`:gvl` option is disabled by default, you can use bindings effectively in multiple threads.
+Please be careful: bindings are not thread safe.
+You should lock all shared data between threads.
+
 ## CI
 
-See universal test script [scripts/ci_test.sh](scripts/ci_test.sh) for CI.
 Please visit [scripts/test-images](scripts/test-images).
-You can run this test script using many native and cross images.
+See universal test script [scripts/ci_test.sh](scripts/ci_test.sh) for CI.
+You can run this script using many native and cross images.
 
 ## License
 
-MIT license, see LICENSE and AUTHORS.
+MIT license, see [LICENSE](LICENSE) and [AUTHORS](AUTHORS).

data/ext/brs_ext/buffer.c

@@ -10,10 +10,11 @@ VALUE brs_ext_create_string_buffer(VALUE length)
   return rb_str_new(NULL, NUM2SIZET(length));
 }
 
-VALUE brs_ext_resize_string_buffer(VALUE args)
+VALUE brs_ext_resize_string_buffer(VALUE buffer_args)
 {
-  VALUE buffer = rb_ary_entry(args, 0);
-  VALUE length = rb_ary_entry(args, 1);
+  VALUE buffer = rb_ary_entry(buffer_args, 0);
+  VALUE length = rb_ary_entry(buffer_args, 1);
+
   return rb_str_resize(buffer, NUM2SIZET(length));
 }
 
@@ -21,8 +22,21 @@ void brs_ext_buffer_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Buffer");
 
-  rb_define_const(module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR));
-  rb_define_const(module, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR));
-  rb_define_const(module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR", SIZET2NUM(BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR));
-  rb_define_const(module, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR", SIZET2NUM(BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+  rb_define_const(
+    module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR));
+
+  rb_define_const(
+    module,
+    "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR",
+    SIZET2NUM(BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR));
+
+  rb_define_const(
+    module,
+    "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR",
+    SIZET2NUM(BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+
+  rb_define_const(
+    module,
+    "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR",
+    SIZET2NUM(BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR));
 }

data/ext/brs_ext/buffer.h

@@ -6,10 +6,10 @@
 
 #include "ruby.h"
 
-#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR (1 << 18)      // 256 KB
+#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR      (1 << 18) // 256 KB
 #define BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR (1 << 16) // 64 KB
 
-#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR (1 << 16)      // 64 KB
+#define BRS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR      (1 << 16) // 64 KB
 #define BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR (1 << 18) // 256 KB
 
 VALUE brs_ext_create_string_buffer(VALUE length);
@@ -17,12 +17,12 @@ VALUE brs_ext_create_string_buffer(VALUE length);
 #define BRS_EXT_CREATE_STRING_BUFFER(buffer, length, exception) \
   VALUE buffer = rb_protect(brs_ext_create_string_buffer, SIZET2NUM(length), &exception);
 
-VALUE brs_ext_resize_string_buffer(VALUE args);
+VALUE brs_ext_resize_string_buffer(VALUE buffer_args);
 
-#define BRS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)            \
-  VALUE args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length));         \
-  buffer     = rb_protect(brs_ext_resize_string_buffer, args, &exception); \
-  RB_GC_GUARD(args);
+#define BRS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)                          \
+  VALUE buffer_args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length));                \
+  buffer            = rb_protect(brs_ext_resize_string_buffer, buffer_args, &exception); \
+  RB_GC_GUARD(buffer_args);
 
 void brs_ext_buffer_exports(VALUE root_module);
 

data/ext/brs_ext/error.h

@@ -11,7 +11,8 @@
 
 // Results for errors listed in "lib/brs/error" used in c extension.
 
-enum {
+enum
+{
   BRS_EXT_ERROR_ALLOCATE_FAILED = 1,
   BRS_EXT_ERROR_VALIDATE_FAILED,
 

data/ext/brs_ext/gvl.h

@@ -0,0 +1,24 @@
+// Ruby bindings for brotli library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(BRS_EXT_GVL_H)
+#define BRS_EXT_GVL_H
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+
+#include "ruby/thread.h"
+
+#define BRS_EXT_GVL_WRAP(gvl, function, data)                              \
+  if (gvl) {                                                               \
+    function((void*) data);                                                \
+  } else {                                                                 \
+    rb_thread_call_without_gvl(function, (void*) data, RUBY_UBF_IO, NULL); \
+  }
+
+#else
+
+#define BRS_EXT_GVL_WRAP(_gvl, function, data) function((void*) data);
+
+#endif
+
+#endif // BRS_EXT_GVL_H

data/ext/brs_ext/io.c

@@ -1,7 +1,7 @@
 // Ruby bindings for brotli library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby/io.h"
+#include "brs_ext/io.h"
 
 #include <brotli/decode.h>
 #include <brotli/encode.h>
@@ -12,19 +12,22 @@
 
 #include "brs_ext/buffer.h"
 #include "brs_ext/error.h"
-#include "brs_ext/io.h"
+#include "brs_ext/gvl.h"
 #include "brs_ext/macro.h"
 #include "brs_ext/option.h"
 #include "ruby.h"
+#include "ruby/io.h"
 
 // Additional possible results:
-enum {
+enum
+{
   BRS_EXT_FILE_READ_FINISHED = 128
 };
 
 // -- file --
 
-static inline brs_ext_result_t read_file(FILE* source_file, brs_ext_byte_t* source_buffer, size_t* source_length_ptr, size_t source_buffer_length)
+static inline brs_ext_result_t
+  read_file(FILE* source_file, brs_ext_byte_t* source_buffer, size_t* source_length_ptr, size_t source_buffer_length)
 {
   size_t read_length = fread(source_buffer, 1, source_buffer_length, source_file);
   if (read_length == 0 && feof(source_file)) {
@@ -40,7 +43,8 @@ static inline brs_ext_result_t read_file(FILE* source_file, brs_ext_byte_t* sour
   return 0;
 }
 
-static inline brs_ext_result_t write_file(FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_length)
+static inline brs_ext_result_t
+  write_file(FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_length)
 {
   size_t written_length = fwrite(destination_buffer, 1, destination_length, destination_file);
   if (written_length != destination_length) {
@@ -53,8 +57,10 @@ static inline brs_ext_result_t write_file(FILE* destination_file, brs_ext_byte_t
 // -- buffer --
 
 static inline brs_ext_result_t create_buffers(
-  brs_ext_byte_t** source_buffer_ptr, size_t source_buffer_length,
-  brs_ext_byte_t** destination_buffer_ptr, size_t destination_buffer_length)
+  brs_ext_byte_t** source_buffer_ptr,
+  size_t           source_buffer_length,
+  brs_ext_byte_t** destination_buffer_ptr,
+  size_t           destination_buffer_length)
 {
   brs_ext_byte_t* source_buffer = malloc(source_buffer_length);
   if (source_buffer == NULL) {
@@ -81,8 +87,10 @@ static inline brs_ext_result_t create_buffers(
 
 static inline brs_ext_result_t read_more_source(
   FILE*                  source_file,
-  const brs_ext_byte_t** source_ptr, size_t* source_length_ptr,
-  brs_ext_byte_t* source_buffer, size_t source_buffer_length)
+  const brs_ext_byte_t** source_ptr,
+  size_t*                source_length_ptr,
+  brs_ext_byte_t*        source_buffer,
+  size_t                 source_buffer_length)
 {
   const brs_ext_byte_t* source        = *source_ptr;
   size_t                source_length = *source_length_ptr;
@@ -105,7 +113,9 @@ static inline brs_ext_result_t read_more_source(
   brs_ext_byte_t* remaining_source_buffer = source_buffer + source_length;
   size_t          new_source_length;
 
-  brs_ext_result_t ext_result = read_file(source_file, remaining_source_buffer, &new_source_length, remaining_source_buffer_length);
+  brs_ext_result_t ext_result =
+    read_file(source_file, remaining_source_buffer, &new_source_length, remaining_source_buffer_length);
+
   if (ext_result != 0) {
     return ext_result;
   }
@@ -115,42 +125,37 @@ static inline brs_ext_result_t read_more_source(
   return 0;
 }
 
-#define BUFFERED_READ_SOURCE(function, ...)                   \
-  do {                                                        \
-    bool is_function_called = false;                          \
-                                                              \
-    while (true) {                                            \
-      ext_result = read_more_source(                          \
-        source_file,                                          \
-        &source, &source_length,                              \
-        source_buffer, source_buffer_length);                 \
-                                                              \
-      if (ext_result == BRS_EXT_FILE_READ_FINISHED) {         \
-        if (source_length != 0) {                             \
-          /* Brotli won't provide any remainder by design. */ \
-          return BRS_EXT_ERROR_READ_IO;                       \
-        }                                                     \
-        break;                                                \
-      }                                                       \
-      else if (ext_result != 0) {                             \
-        return ext_result;                                    \
-      }                                                       \
-                                                              \
-      ext_result = function(__VA_ARGS__);                     \
-      if (ext_result != 0) {                                  \
-        return ext_result;                                    \
-      }                                                       \
-                                                              \
-      is_function_called = true;                              \
-    }                                                         \
-                                                              \
-    if (!is_function_called) {                                \
-      /* Function should be called at least once. */          \
-      ext_result = function(__VA_ARGS__);                     \
-      if (ext_result != 0) {                                  \
-        return ext_result;                                    \
-      }                                                       \
-    }                                                         \
+#define BUFFERED_READ_SOURCE(function, ...)                                                                     \
+  do {                                                                                                          \
+    bool is_function_called = false;                                                                            \
+                                                                                                                \
+    while (true) {                                                                                              \
+      ext_result = read_more_source(source_file, &source, &source_length, source_buffer, source_buffer_length); \
+      if (ext_result == BRS_EXT_FILE_READ_FINISHED) {                                                           \
+        if (source_length != 0) {                                                                               \
+          /* Brotli won't provide any remainder by design. */                                                   \
+          return BRS_EXT_ERROR_READ_IO;                                                                         \
+        }                                                                                                       \
+        break;                                                                                                  \
+      } else if (ext_result != 0) {                                                                             \
+        return ext_result;                                                                                      \
+      }                                                                                                         \
+                                                                                                                \
+      ext_result = function(__VA_ARGS__);                                                                       \
+      if (ext_result != 0) {                                                                                    \
+        return ext_result;                                                                                      \
+      }                                                                                                         \
+                                                                                                                \
+      is_function_called = true;                                                                                \
+    }                                                                                                           \
+                                                                                                                \
+    if (!is_function_called) {                                                                                  \
+      /* Function should be called at least once. */                                                            \
+      ext_result = function(__VA_ARGS__);                                                                       \
+      if (ext_result != 0) {                                                                                    \
+        return ext_result;                                                                                      \
+      }                                                                                                         \
+    }                                                                                                           \
   } while (false);
 
 // Algorithm has written data into destination buffer.
@@ -159,7 +164,9 @@ static inline brs_ext_result_t read_more_source(
 
 static inline brs_ext_result_t flush_destination_buffer(
   FILE*           destination_file,
-  brs_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+  brs_ext_byte_t* destination_buffer,
+  size_t*         destination_length_ptr,
+  size_t          destination_buffer_length)
 {
   if (*destination_length_ptr == 0) {
     // We want to write more data at once, than buffer has.
@@ -176,7 +183,8 @@ static inline brs_ext_result_t flush_destination_buffer(
   return 0;
 }
 
-static inline brs_ext_result_t write_remaining_destination(FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_length)
+static inline brs_ext_result_t
+  write_remaining_destination(FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_length)
 {
   if (destination_length == 0) {
     return 0;
@@ -198,29 +206,57 @@ static inline brs_ext_result_t write_remaining_destination(FILE* destination_fil
     brs_ext_raise_error(BRS_EXT_ERROR_ACCESS_IO);      \
   }
 
-// -- compress --
+// -- buffered compress --
+
+typedef struct
+{
+  BrotliEncoderState*    state_ptr;
+  const brs_ext_byte_t** source_ptr;
+  size_t*                source_length_ptr;
+  brs_ext_byte_t*        remaining_destination_buffer;
+  size_t*                remaining_destination_buffer_length_ptr;
+  BROTLI_BOOL            result;
+} compress_args_t;
+
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t* args = data;
+
+  args->result = BrotliEncoderCompressStream(
+    args->state_ptr,
+    BROTLI_OPERATION_PROCESS,
+    args->source_length_ptr,
+    args->source_ptr,
+    args->remaining_destination_buffer_length_ptr,
+    &args->remaining_destination_buffer,
+    NULL);
+
+  return NULL;
+}
 
 static inline brs_ext_result_t buffered_compress(
   BrotliEncoderState*    state_ptr,
-  const brs_ext_byte_t** source_ptr, size_t* source_length_ptr,
-  FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+  const brs_ext_byte_t** source_ptr,
+  size_t*                source_length_ptr,
+  FILE*                  destination_file,
+  brs_ext_byte_t*        destination_buffer,
+  size_t*                destination_length_ptr,
+  size_t                 destination_buffer_length,
+  bool                   gvl)
 {
-  BROTLI_BOOL      result;
   brs_ext_result_t ext_result;
+  compress_args_t  args = {.state_ptr = state_ptr, .source_ptr = source_ptr, .source_length_ptr = source_length_ptr};
 
   while (true) {
     brs_ext_byte_t* remaining_destination_buffer             = destination_buffer + *destination_length_ptr;
     size_t          remaining_destination_buffer_length      = destination_buffer_length - *destination_length_ptr;
     size_t          prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
-    result = BrotliEncoderCompressStream(
-      state_ptr,
-      BROTLI_OPERATION_PROCESS,
-      source_length_ptr, source_ptr,
-      &remaining_destination_buffer_length, &remaining_destination_buffer,
-      NULL);
+    args.remaining_destination_buffer            = remaining_destination_buffer;
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
 
-    if (!result) {
+    BRS_EXT_GVL_WRAP(gvl, compress_wrapper, &args);
+    if (!args.result) {
       return BRS_EXT_ERROR_UNEXPECTED;
     }
 
@@ -228,8 +264,7 @@ static inline brs_ext_result_t buffered_compress(
 
     if (BrotliEncoderHasMoreOutput(state_ptr)) {
       ext_result = flush_destination_buffer(
-        destination_file,
-        destination_buffer, destination_length_ptr, destination_buffer_length);
+        destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -244,29 +279,57 @@ static inline brs_ext_result_t buffered_compress(
   return 0;
 }
 
+// -- buffered compressor finish --
+
+typedef struct
+{
+  BrotliEncoderState*    state_ptr;
+  const brs_ext_byte_t** source_ptr;
+  size_t*                source_length_ptr;
+  brs_ext_byte_t*        remaining_destination_buffer;
+  size_t*                remaining_destination_buffer_length_ptr;
+  BROTLI_BOOL            result;
+} compressor_finish_args_t;
+
+static inline void* compressor_finish_wrapper(void* data)
+{
+  compressor_finish_args_t* args = data;
+
+  args->result = BrotliEncoderCompressStream(
+    args->state_ptr,
+    BROTLI_OPERATION_FINISH,
+    args->source_length_ptr,
+    args->source_ptr,
+    args->remaining_destination_buffer_length_ptr,
+    &args->remaining_destination_buffer,
+    NULL);
+
+  return NULL;
+}
+
 static inline brs_ext_result_t buffered_compressor_finish(
   BrotliEncoderState* state_ptr,
-  FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+  FILE*               destination_file,
+  brs_ext_byte_t*     destination_buffer,
+  size_t*             destination_length_ptr,
+  size_t              destination_buffer_length,
+  bool                gvl)
 {
-  BROTLI_BOOL      result;
-  brs_ext_result_t ext_result;
-
-  const brs_ext_byte_t* source        = NULL;
-  size_t                source_length = 0;
+  brs_ext_result_t         ext_result;
+  const brs_ext_byte_t*    source        = NULL;
+  size_t                   source_length = 0;
+  compressor_finish_args_t args = {.state_ptr = state_ptr, .source_ptr = &source, .source_length_ptr = &source_length};
 
   while (true) {
     brs_ext_byte_t* remaining_destination_buffer             = destination_buffer + *destination_length_ptr;
     size_t          remaining_destination_buffer_length      = destination_buffer_length - *destination_length_ptr;
     size_t          prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
-    result = BrotliEncoderCompressStream(
-      state_ptr,
-      BROTLI_OPERATION_FINISH,
-      &source_length, &source,
-      &remaining_destination_buffer_length, &remaining_destination_buffer,
-      NULL);
+    args.remaining_destination_buffer            = remaining_destination_buffer;
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
 
-    if (!result) {
+    BRS_EXT_GVL_WRAP(gvl, compressor_finish_wrapper, &args);
+    if (!args.result) {
       return BRS_EXT_ERROR_UNEXPECTED;
     }
 
@@ -274,8 +337,7 @@ static inline brs_ext_result_t buffered_compressor_finish(
 
     if (BrotliEncoderHasMoreOutput(state_ptr) || !BrotliEncoderIsFinished(state_ptr)) {
       ext_result = flush_destination_buffer(
-        destination_file,
-        destination_buffer, destination_length_ptr, destination_buffer_length);
+        destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -290,13 +352,19 @@ static inline brs_ext_result_t buffered_compressor_finish(
   return 0;
 }
 
+// -- compress --
+
 static inline brs_ext_result_t compress(
   BrotliEncoderState* state_ptr,
-  FILE* source_file, brs_ext_byte_t* source_buffer, size_t source_buffer_length,
-  FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_buffer_length)
+  FILE*               source_file,
+  brs_ext_byte_t*     source_buffer,
+  size_t              source_buffer_length,
+  FILE*               destination_file,
+  brs_ext_byte_t*     destination_buffer,
+  size_t              destination_buffer_length,
+  bool                gvl)
 {
-  brs_ext_result_t ext_result;
-
+  brs_ext_result_t      ext_result;
   const brs_ext_byte_t* source             = source_buffer;
   size_t                source_length      = 0;
   size_t                destination_length = 0;
@@ -304,12 +372,16 @@ static inline brs_ext_result_t compress(
   BUFFERED_READ_SOURCE(
     buffered_compress,
     state_ptr,
-    &source, &source_length,
-    destination_file, destination_buffer, &destination_length, destination_buffer_length);
+    &source,
+    &source_length,
+    destination_file,
+    destination_buffer,
+    &destination_length,
+    destination_buffer_length,
+    gvl);
 
   ext_result = buffered_compressor_finish(
-    state_ptr,
-    destination_file, destination_buffer, &destination_length, destination_buffer_length);
+    state_ptr, destination_file, destination_buffer, &destination_length, destination_buffer_length, gvl);
 
   if (ext_result != 0) {
     return ext_result;
@@ -323,9 +395,10 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  BRS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  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, source_buffer_length);
-  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   BrotliEncoderState* state_ptr = BrotliEncoderCreateInstance(NULL, NULL, NULL);
   if (state_ptr == NULL) {
@@ -348,10 +421,7 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
   brs_ext_byte_t* source_buffer;
   brs_ext_byte_t* destination_buffer;
 
-  ext_result = create_buffers(
-    &source_buffer, source_buffer_length,
-    &destination_buffer, destination_buffer_length);
-
+  ext_result = create_buffers(&source_buffer, source_buffer_length, &destination_buffer, destination_buffer_length);
   if (ext_result != 0) {
     BrotliEncoderDestroyInstance(state_ptr);
     brs_ext_raise_error(ext_result);
@@ -359,8 +429,13 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
 
   ext_result = compress(
     state_ptr,
-    source_file, source_buffer, source_buffer_length,
-    destination_file, destination_buffer, destination_buffer_length);
+    source_file,
+    source_buffer,
+    source_buffer_length,
+    destination_file,
+    destination_buffer,
+    destination_buffer_length,
+    gvl);
 
   free(source_buffer);
   free(destination_buffer);
@@ -376,41 +451,68 @@ VALUE brs_ext_compress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE destin
   return Qnil;
 }
 
-// -- decompress --
+// -- buffered decompress --
+
+typedef struct
+{
+  BrotliDecoderState*    state_ptr;
+  const brs_ext_byte_t** source_ptr;
+  size_t*                source_length_ptr;
+  brs_ext_byte_t*        remaining_destination_buffer;
+  size_t*                remaining_destination_buffer_length_ptr;
+  BrotliDecoderResult    result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->result = BrotliDecoderDecompressStream(
+    args->state_ptr,
+    args->source_length_ptr,
+    args->source_ptr,
+    args->remaining_destination_buffer_length_ptr,
+    &args->remaining_destination_buffer,
+    NULL);
+
+  return NULL;
+}
 
 static inline brs_ext_result_t buffered_decompress(
   BrotliDecoderState*    state_ptr,
-  const brs_ext_byte_t** source_ptr, size_t* source_length_ptr,
-  FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t* destination_length_ptr, size_t destination_buffer_length)
+  const brs_ext_byte_t** source_ptr,
+  size_t*                source_length_ptr,
+  FILE*                  destination_file,
+  brs_ext_byte_t*        destination_buffer,
+  size_t*                destination_length_ptr,
+  size_t                 destination_buffer_length,
+  bool                   gvl)
 {
-  BrotliDecoderResult result;
-  brs_ext_result_t    ext_result;
+  brs_ext_result_t  ext_result;
+  decompress_args_t args = {.state_ptr = state_ptr, .source_ptr = source_ptr, .source_length_ptr = source_length_ptr};
 
   while (true) {
     brs_ext_byte_t* remaining_destination_buffer             = destination_buffer + *destination_length_ptr;
     size_t          remaining_destination_buffer_length      = destination_buffer_length - *destination_length_ptr;
     size_t          prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
-    result = BrotliDecoderDecompressStream(
-      state_ptr,
-      source_length_ptr, source_ptr,
-      &remaining_destination_buffer_length, &remaining_destination_buffer,
-      NULL);
+    args.remaining_destination_buffer            = remaining_destination_buffer;
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
+
+    BRS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
 
     if (
-      result != BROTLI_DECODER_RESULT_SUCCESS &&
-      result != BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT &&
-      result != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+      args.result != BROTLI_DECODER_RESULT_SUCCESS && args.result != BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT &&
+      args.result != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
       BrotliDecoderErrorCode error_code = BrotliDecoderGetErrorCode(state_ptr);
       return brs_ext_get_decompressor_error(error_code);
     }
 
     *destination_length_ptr += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
 
-    if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+    if (args.result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
       ext_result = flush_destination_buffer(
-        destination_file,
-        destination_buffer, destination_length_ptr, destination_buffer_length);
+        destination_file, destination_buffer, destination_length_ptr, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -425,13 +527,19 @@ static inline brs_ext_result_t buffered_decompress(
   return 0;
 }
 
+// -- decompress --
+
 static inline brs_ext_result_t decompress(
   BrotliDecoderState* state_ptr,
-  FILE* source_file, brs_ext_byte_t* source_buffer, size_t source_buffer_length,
-  FILE* destination_file, brs_ext_byte_t* destination_buffer, size_t destination_buffer_length)
+  FILE*               source_file,
+  brs_ext_byte_t*     source_buffer,
+  size_t              source_buffer_length,
+  FILE*               destination_file,
+  brs_ext_byte_t*     destination_buffer,
+  size_t              destination_buffer_length,
+  bool                gvl)
 {
-  brs_ext_result_t ext_result;
-
+  brs_ext_result_t      ext_result;
   const brs_ext_byte_t* source             = source_buffer;
   size_t                source_length      = 0;
   size_t                destination_length = 0;
@@ -439,8 +547,13 @@ static inline brs_ext_result_t decompress(
   BUFFERED_READ_SOURCE(
     buffered_decompress,
     state_ptr,
-    &source, &source_length,
-    destination_file, destination_buffer, &destination_length, destination_buffer_length);
+    &source,
+    &source_length,
+    destination_file,
+    destination_buffer,
+    &destination_length,
+    destination_buffer_length,
+    gvl);
 
   return write_remaining_destination(destination_file, destination_buffer, destination_length);
 }
@@ -450,9 +563,10 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  BRS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  BRS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  BRS_EXT_GET_BOOL_OPTION(options, gvl);
   BRS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
-  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   BrotliDecoderState* state_ptr = BrotliDecoderCreateInstance(NULL, NULL, NULL);
   if (state_ptr == NULL) {
@@ -475,10 +589,7 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
   brs_ext_byte_t* source_buffer;
   brs_ext_byte_t* destination_buffer;
 
-  ext_result = create_buffers(
-    &source_buffer, source_buffer_length,
-    &destination_buffer, destination_buffer_length);
-
+  ext_result = create_buffers(&source_buffer, source_buffer_length, &destination_buffer, destination_buffer_length);
   if (ext_result != 0) {
     BrotliDecoderDestroyInstance(state_ptr);
     brs_ext_raise_error(ext_result);
@@ -486,8 +597,13 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
 
   ext_result = decompress(
     state_ptr,
-    source_file, source_buffer, source_buffer_length,
-    destination_file, destination_buffer, destination_buffer_length);
+    source_file,
+    source_buffer,
+    source_buffer_length,
+    destination_file,
+    destination_buffer,
+    destination_buffer_length,
+    gvl);
 
   free(source_buffer);
   free(destination_buffer);
@@ -503,6 +619,8 @@ VALUE brs_ext_decompress_io(VALUE BRS_EXT_UNUSED(self), VALUE source, VALUE dest
   return Qnil;
 }
 
+// -- exports --
+
 void brs_ext_io_exports(VALUE root_module)
 {
   rb_define_module_function(root_module, "_native_compress_io", RUBY_METHOD_FUNC(brs_ext_compress_io), 3);