ruby-brs 1.1.4 → 1.3.0

data/ext/brs_ext/stream/decompressor.c

@@ -3,12 +3,12 @@
 
 #include "brs_ext/stream/decompressor.h"
 
-#include <brotli/decode.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_decompressor(brs_ext_decompressor_t* decompressor_ptr)
 {
@@ -28,7 +28,6 @@ static void free_decompressor(brs_ext_decompressor_t* decompressor_ptr)
 VALUE brs_ext_allocate_decompressor(VALUE klass)
 {
   brs_ext_decompressor_t* decompressor_ptr;
-
   VALUE self = Data_Make_Struct(klass, brs_ext_decompressor_t, NULL, free_decompressor, decompressor_ptr);
 
   decompressor_ptr->state_ptr                           = NULL;
@@ -48,8 +47,9 @@ VALUE brs_ext_initialize_decompressor(VALUE self, VALUE options)
 {
   GET_DECOMPRESSOR(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_DECOMPRESSOR_OPTIONS(options);
-  BRS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   BrotliDecoderState* state_ptr = BrotliDecoderCreateInstance(NULL, NULL, NULL);
   if (state_ptr == NULL) {
@@ -77,49 +77,75 @@ VALUE brs_ext_initialize_decompressor(VALUE self, VALUE options)
   decompressor_ptr->destination_buffer_length           = destination_buffer_length;
   decompressor_ptr->remaining_destination_buffer        = destination_buffer;
   decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+  decompressor_ptr->gvl                                 = gvl;
 
   return Qnil;
 }
 
+// -- decompress --
+
 #define DO_NOT_USE_AFTER_CLOSE(decompressor_ptr)                                             \
   if (decompressor_ptr->state_ptr == NULL || decompressor_ptr->destination_buffer == NULL) { \
     brs_ext_raise_error(BRS_EXT_ERROR_USED_AFTER_CLOSE);                                     \
   }
 
-#define GET_SOURCE_DATA(source_value)                                            \
-  Check_Type(source_value, T_STRING);                                            \
-                                                                                 \
-  const char*           source                  = RSTRING_PTR(source_value);     \
-  size_t                source_length           = RSTRING_LEN(source_value);     \
-  const brs_ext_byte_t* remaining_source        = (const brs_ext_byte_t*)source; \
-  size_t                remaining_source_length = source_length;
+typedef struct
+{
+  brs_ext_decompressor_t* decompressor_ptr;
+  const brs_ext_byte_t*   remaining_source;
+  size_t*                 remaining_source_length_ptr;
+  BrotliDecoderResult     result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t*      args             = data;
+  brs_ext_decompressor_t* decompressor_ptr = args->decompressor_ptr;
+
+  args->result = BrotliDecoderDecompressStream(
+    decompressor_ptr->state_ptr,
+    args->remaining_source_length_ptr,
+    &args->remaining_source,
+    &decompressor_ptr->remaining_destination_buffer_length,
+    &decompressor_ptr->remaining_destination_buffer,
+    NULL);
+
+  return NULL;
+}
 
 VALUE brs_ext_decompress(VALUE self, VALUE source_value)
 {
   GET_DECOMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
 
-  BrotliDecoderResult result = BrotliDecoderDecompressStream(
-    decompressor_ptr->state_ptr,
-    &remaining_source_length, &remaining_source,
-    &decompressor_ptr->remaining_destination_buffer_length, &decompressor_ptr->remaining_destination_buffer,
-    NULL);
+  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;
+
+  decompress_args_t args = {
+    .decompressor_ptr            = decompressor_ptr,
+    .remaining_source            = remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
+
+  BRS_EXT_GVL_WRAP(decompressor_ptr->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(decompressor_ptr->state_ptr);
     brs_ext_raise_error(brs_ext_get_decompressor_error(error_code));
   }
 
   VALUE bytes_read             = SIZET2NUM(source_length - remaining_source_length);
-  VALUE needs_more_destination = result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT ? Qtrue : Qfalse;
+  VALUE needs_more_destination = args.result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT ? Qtrue : Qfalse;
 
   return rb_ary_new_from_args(2, bytes_read, needs_more_destination);
 }
 
+// -- other --
+
 VALUE brs_ext_decompressor_read_result(VALUE self)
 {
   GET_DECOMPRESSOR(self);
@@ -129,10 +155,9 @@ VALUE brs_ext_decompressor_read_result(VALUE self)
   size_t          destination_buffer_length           = decompressor_ptr->destination_buffer_length;
   size_t          remaining_destination_buffer_length = decompressor_ptr->remaining_destination_buffer_length;
 
-  const char* result        = (const char*)destination_buffer;
+  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);
 
   decompressor_ptr->remaining_destination_buffer        = destination_buffer;
   decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
@@ -140,6 +165,8 @@ VALUE brs_ext_decompressor_read_result(VALUE self)
   return result_value;
 }
 
+// -- cleanup --
+
 VALUE brs_ext_decompressor_close(VALUE self)
 {
   GET_DECOMPRESSOR(self);
@@ -165,6 +192,8 @@ VALUE brs_ext_decompressor_close(VALUE self)
   return Qnil;
 }
 
+// -- exports --
+
 void brs_ext_decompressor_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Stream");

data/ext/brs_ext/stream/decompressor.h

@@ -5,17 +5,20 @@
 #define BRS_EXT_STREAM_DECOMPRESSOR_H
 
 #include <brotli/decode.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include "brs_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   BrotliDecoderState* 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_decompressor_t;
 
 VALUE brs_ext_allocate_decompressor(VALUE klass);

data/ext/brs_ext/string.c

@@ -10,15 +10,17 @@
 
 #include "brs_ext/buffer.h"
 #include "brs_ext/error.h"
+#include "brs_ext/gvl.h"
 #include "brs_ext/macro.h"
 #include "brs_ext/option.h"
-#include "ruby.h"
 
 // -- buffer --
 
 static inline brs_ext_result_t increase_destination_buffer(
-  VALUE destination_value, size_t destination_length,
-  size_t* remaining_destination_buffer_length_ptr, size_t destination_buffer_length)
+  VALUE   destination_value,
+  size_t  destination_length,
+  size_t* remaining_destination_buffer_length_ptr,
+  size_t  destination_buffer_length)
 {
   if (*remaining_destination_buffer_length_ptr == destination_buffer_length) {
     // We want to write more data at once, than buffer has.
@@ -37,42 +39,63 @@ static inline brs_ext_result_t increase_destination_buffer(
   return 0;
 }
 
-// -- utils --
-
-#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);
-
 // -- compress --
 
+typedef struct
+{
+  BrotliEncoderState*    state_ptr;
+  const brs_ext_byte_t** remaining_source_ptr;
+  size_t*                remaining_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_FINISH,
+    args->remaining_source_length_ptr,
+    args->remaining_source_ptr,
+    args->remaining_destination_buffer_length_ptr,
+    &args->remaining_destination_buffer,
+    NULL);
+
+  return NULL;
+}
+
 static inline brs_ext_result_t compress(
   BrotliEncoderState* state_ptr,
-  const char* source, size_t source_length,
-  VALUE destination_value, size_t destination_buffer_length)
+  const char*         source,
+  size_t              source_length,
+  VALUE               destination_value,
+  size_t              destination_buffer_length,
+  bool                gvl)
 {
-  BROTLI_BOOL      result;
-  brs_ext_result_t ext_result;
-
-  const brs_ext_byte_t* remaining_source        = (const brs_ext_byte_t*)source;
-  size_t                remaining_source_length = source_length;
+  brs_ext_result_t      ext_result;
+  const brs_ext_byte_t* remaining_source                    = (const brs_ext_byte_t*) source;
+  size_t                remaining_source_length             = source_length;
+  size_t                destination_length                  = 0;
+  size_t                remaining_destination_buffer_length = destination_buffer_length;
 
-  size_t destination_length                  = 0;
-  size_t remaining_destination_buffer_length = destination_buffer_length;
+  compress_args_t args = {
+    .state_ptr                   = state_ptr,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
 
   while (true) {
-    brs_ext_byte_t* remaining_destination_buffer             = (brs_ext_byte_t*)RSTRING_PTR(destination_value) + destination_length;
-    size_t          prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+    brs_ext_byte_t* remaining_destination_buffer =
+      (brs_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
-    result = BrotliEncoderCompressStream(
-      state_ptr,
-      BROTLI_OPERATION_FINISH,
-      &remaining_source_length, &remaining_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, compress_wrapper, &args);
+    if (!args.result) {
       return BRS_EXT_ERROR_UNEXPECTED;
     }
 
@@ -80,8 +103,7 @@ static inline brs_ext_result_t compress(
 
     if (BrotliEncoderHasMoreOutput(state_ptr) || !BrotliEncoderIsFinished(state_ptr)) {
       ext_result = increase_destination_buffer(
-        destination_value, destination_length,
-        &remaining_destination_buffer_length, destination_buffer_length);
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -105,10 +127,11 @@ static inline brs_ext_result_t compress(
 
 VALUE brs_ext_compress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
   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) {
@@ -133,10 +156,10 @@ VALUE brs_ext_compress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VA
     brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  ext_result = compress(
-    state_ptr,
-    source, source_length,
-    destination_value, destination_buffer_length);
+  const char* source        = RSTRING_PTR(source_value);
+  size_t      source_length = RSTRING_LEN(source_value);
+
+  ext_result = compress(state_ptr, source, source_length, destination_value, destination_buffer_length, gvl);
 
   BrotliEncoderDestroyInstance(state_ptr);
 
@@ -149,44 +172,71 @@ VALUE brs_ext_compress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VA
 
 // -- decompress --
 
+typedef struct
+{
+  BrotliDecoderState*    state_ptr;
+  const brs_ext_byte_t** remaining_source_ptr;
+  size_t*                remaining_source_length_ptr;
+  brs_ext_byte_t*        remaining_destination_buffer;
+  size_t*                remaining_destination_buffer_length_ptr;
+  brs_ext_result_t       result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->result = BrotliDecoderDecompressStream(
+    args->state_ptr,
+    args->remaining_source_length_ptr,
+    args->remaining_source_ptr,
+    args->remaining_destination_buffer_length_ptr,
+    &args->remaining_destination_buffer,
+    NULL);
+
+  return NULL;
+}
+
 static inline brs_ext_result_t decompress(
   BrotliDecoderState* state_ptr,
-  const char* source, size_t source_length,
-  VALUE destination_value, size_t destination_buffer_length)
+  const char*         source,
+  size_t              source_length,
+  VALUE               destination_value,
+  size_t              destination_buffer_length,
+  bool                gvl)
 {
-  BrotliDecoderResult result;
-  brs_ext_result_t    ext_result;
-
-  const brs_ext_byte_t* remaining_source        = (const brs_ext_byte_t*)source;
-  size_t                remaining_source_length = source_length;
+  brs_ext_result_t      ext_result;
+  const brs_ext_byte_t* remaining_source                    = (const brs_ext_byte_t*) source;
+  size_t                remaining_source_length             = source_length;
+  size_t                destination_length                  = 0;
+  size_t                remaining_destination_buffer_length = destination_buffer_length;
 
-  size_t destination_length                  = 0;
-  size_t remaining_destination_buffer_length = destination_buffer_length;
+  decompress_args_t args = {
+    .state_ptr                   = state_ptr,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
 
   while (true) {
-    brs_ext_byte_t* remaining_destination_buffer             = (brs_ext_byte_t*)RSTRING_PTR(destination_value) + destination_length;
-    size_t          prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+    brs_ext_byte_t* remaining_destination_buffer =
+      (brs_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
-    result = BrotliDecoderDecompressStream(
-      state_ptr,
-      &remaining_source_length, &remaining_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;
 
+    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 += 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 = increase_destination_buffer(
-        destination_value, destination_length,
-        &remaining_destination_buffer_length, destination_buffer_length);
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -210,10 +260,11 @@ static inline brs_ext_result_t decompress(
 
 VALUE brs_ext_decompress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
   Check_Type(options, T_HASH);
+  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, destination_buffer_length);
 
   BrotliDecoderState* state_ptr = BrotliDecoderCreateInstance(NULL, NULL, NULL);
   if (state_ptr == NULL) {
@@ -238,10 +289,10 @@ VALUE brs_ext_decompress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value,
     brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  ext_result = decompress(
-    state_ptr,
-    source, source_length,
-    destination_value, destination_buffer_length);
+  const char* source        = RSTRING_PTR(source_value);
+  size_t      source_length = RSTRING_LEN(source_value);
+
+  ext_result = decompress(state_ptr, source, source_length, destination_value, destination_buffer_length, gvl);
 
   BrotliDecoderDestroyInstance(state_ptr);
 
@@ -252,6 +303,8 @@ VALUE brs_ext_decompress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value,
   return destination_value;
 }
 
+// -- exports --
+
 void brs_ext_string_exports(VALUE root_module)
 {
   rb_define_module_function(root_module, "_native_compress_string", RUBY_METHOD_FUNC(brs_ext_compress_string), 2);

data/ext/extconf.rb

@@ -3,17 +3,95 @@
 
 require "mkmf"
 
-def require_header(name, types = [])
+have_func "rb_thread_call_without_gvl", "ruby/thread.h"
+
+def require_header(name, constants: [], macroses: [], types: [])
   abort "Can't find #{name} header" unless find_header name
 
+  constants.each do |constant|
+    abort "Can't find #{constant} constant in #{name} header" unless have_const constant, name
+  end
+
+  macroses.each do |macro|
+    abort "Can't find #{macro} macro in #{name} header" unless have_macro macro, name
+  end
+
   types.each do |type|
     abort "Can't find #{type} type in #{name} header" unless find_type type, nil, name
   end
 end
 
-require_header "brotli/types.h", %w[BROTLI_BOOL]
-require_header "brotli/encode.h", ["BrotliEncoderState *", "BrotliEncoderMode"]
-require_header "brotli/decode.h", ["BrotliDecoderState *", "BrotliDecoderResult", "BrotliDecoderErrorCode"]
+require_header(
+  "brotli/decode.h",
+  :constants => %w[
+    BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES
+    BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP
+    BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES
+    BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1
+    BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2
+    BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS
+    BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1
+    BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2
+    BROTLI_DECODER_ERROR_FORMAT_CL_SPACE
+    BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT
+    BROTLI_DECODER_ERROR_FORMAT_DICTIONARY
+    BROTLI_DECODER_ERROR_FORMAT_DISTANCE
+    BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE
+    BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE
+    BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE
+    BROTLI_DECODER_ERROR_FORMAT_PADDING_1
+    BROTLI_DECODER_ERROR_FORMAT_PADDING_2
+    BROTLI_DECODER_ERROR_FORMAT_RESERVED
+    BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET
+    BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME
+    BROTLI_DECODER_ERROR_FORMAT_TRANSFORM
+    BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS
+    BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION
+    BROTLI_DECODER_PARAM_LARGE_WINDOW
+    BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT
+    BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT
+    BROTLI_DECODER_RESULT_SUCCESS
+  ],
+  :types     => [
+    "BrotliDecoderErrorCode",
+    "BrotliDecoderResult",
+    "BrotliDecoderState *"
+  ]
+)
+require_header(
+  "brotli/encode.h",
+  :constants => %w[
+    BROTLI_MAX_INPUT_BLOCK_BITS
+    BROTLI_MAX_QUALITY
+    BROTLI_MAX_WINDOW_BITS
+    BROTLI_MIN_INPUT_BLOCK_BITS
+    BROTLI_MIN_QUALITY
+    BROTLI_MIN_WINDOW_BITS
+    BROTLI_MODE_FONT
+    BROTLI_MODE_GENERIC
+    BROTLI_MODE_TEXT
+    BROTLI_OPERATION_FINISH
+    BROTLI_OPERATION_FLUSH
+    BROTLI_OPERATION_PROCESS
+    BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING
+    BROTLI_PARAM_LARGE_WINDOW
+    BROTLI_PARAM_LGBLOCK
+    BROTLI_PARAM_LGWIN
+    BROTLI_PARAM_NDIRECT
+    BROTLI_PARAM_NPOSTFIX
+    BROTLI_PARAM_MODE
+    BROTLI_PARAM_QUALITY
+    BROTLI_PARAM_SIZE_HINT
+  ],
+  :types     => [
+    "BrotliEncoderMode",
+    "BrotliEncoderState *"
+  ]
+)
+require_header(
+  "brotli/types.h",
+  :macroses => %w[BROTLI_BOOL]
+)
 
 def require_library(name, functions)
   functions.each do |function|
@@ -24,12 +102,13 @@ end
 require_library(
   "brotlienc",
   %w[
-    BrotliEncoderCreateInstance
-    BrotliEncoderSetParameter
     BrotliEncoderCompressStream
+    BrotliEncoderCreateInstance
+    BrotliEncoderDestroyInstance
     BrotliEncoderHasMoreOutput
     BrotliEncoderIsFinished
-    BrotliEncoderDestroyInstance
+    BrotliEncoderSetParameter
+    BrotliEncoderVersion
   ]
 )
 
@@ -37,10 +116,11 @@ require_library(
   "brotlidec",
   %w[
     BrotliDecoderCreateInstance
-    BrotliDecoderSetParameter
     BrotliDecoderDecompressStream
-    BrotliDecoderGetErrorCode
     BrotliDecoderDestroyInstance
+    BrotliDecoderGetErrorCode
+    BrotliDecoderSetParameter
+    BrotliDecoderVersion
   ]
 )
 
@@ -68,7 +148,7 @@ $libs = $libs.split(%r{\s})
   .uniq
   .join " "
 
-if ENV["CI"] || ENV["COVERAGE"]
+if ENV["CI"]
   $CFLAGS << " --coverage"
   $LDFLAGS << " --coverage"
 end

data/lib/brs/file.rb

@@ -19,7 +19,7 @@ module BRS
 
       options[:size_hint] = ::File.size source
 
-      open_files(source, destination) do |source_io, destination_io|
+      open_files source, destination do |source_io, destination_io|
         BRS._native_compress_io source_io, destination_io, options
       end
 
@@ -32,7 +32,7 @@ module BRS
 
       options = Option.get_decompressor_options options, BUFFER_LENGTH_NAMES
 
-      open_files(source, destination) do |source_io, destination_io|
+      open_files source, destination do |source_io, destination_io|
         BRS._native_decompress_io source_io, destination_io, options
       end