ruby-brs 1.1.4 → 1.3.0

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,21 @@
 
 #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 +42,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 +56,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 +86,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 +112,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 +124,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 +163,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 +182,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 +205,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 +263,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 +278,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 +336,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 +351,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 +371,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 +394,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 +420,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 +428,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 +450,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 +526,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 +546,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 +562,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 +588,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 +596,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 +618,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);

data/ext/brs_ext/main.c

@@ -7,7 +7,6 @@
 #include "brs_ext/stream/compressor.h"
 #include "brs_ext/stream/decompressor.h"
 #include "brs_ext/string.h"
-#include "ruby.h"
 
 void Init_brs_ext()
 {
@@ -19,4 +18,8 @@ void Init_brs_ext()
   brs_ext_compressor_exports(root_module);
   brs_ext_decompressor_exports(root_module);
   brs_ext_string_exports(root_module);
+
+  VALUE version_arguments[] = {INT2FIX(16)};
+  VALUE version = rb_block_call(UINT2NUM(BrotliEncoderVersion()), rb_intern("to_s"), 1, version_arguments, 0, 0);
+  rb_define_const(root_module, "LIBRARY_VERSION", rb_obj_freeze(version));
 }