ruby-brs 1.0.1 → 1.1.4

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,13 +5,12 @@
 
 #include <brotli/decode.h>
 #include <brotli/encode.h>
-#include <stdbool.h>
-#include <stdint.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)
 {
   return rb_funcall(options, rb_intern("[]"), 1, ID2SYM(rb_intern(name)));
@@ -27,14 +26,14 @@ static inline bool get_bool_option_value(VALUE raw_value)
   return raw_type == T_TRUE;
 }
 
-static inline unsigned long get_fixnum_option_value(VALUE raw_value)
+static inline unsigned int get_uint_option_value(VALUE raw_value)
 {
   Check_Type(raw_value, T_FIXNUM);
 
   return NUM2UINT(raw_value);
 }
 
-static inline uint_fast8_t get_mode_option_value(VALUE raw_value)
+static inline BrotliEncoderMode get_mode_option_value(VALUE raw_value)
 {
   Check_Type(raw_value, T_SYMBOL);
 
@@ -68,8 +67,8 @@ void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_
     case BRS_EXT_OPTION_TYPE_BOOL:
       value = get_bool_option_value(raw_value) ? 1 : 0;
       break;
-    case BRS_EXT_OPTION_TYPE_FIXNUM:
-      value = (brs_ext_option_value_t)get_fixnum_option_value(raw_value);
+    case BRS_EXT_OPTION_TYPE_UINT:
+      value = (brs_ext_option_value_t)get_uint_option_value(raw_value);
       break;
     case BRS_EXT_OPTION_TYPE_MODE:
       value = (brs_ext_option_value_t)get_mode_option_value(raw_value);
@@ -81,13 +80,17 @@ void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_
   option->value = value;
 }
 
-unsigned long brs_ext_get_fixnum_option_value(VALUE options, const char* name)
+size_t brs_ext_get_size_option_value(VALUE options, const char* name)
 {
   VALUE raw_value = get_raw_option_value(options, name);
 
-  return get_fixnum_option_value(raw_value);
+  Check_Type(raw_value, T_FIXNUM);
+
+  return NUM2SIZET(raw_value);
 }
 
+// -- set params --
+
 #define SET_OPTION_VALUE(function, state_ptr, param, option)           \
   if (option.has_value && !function(state_ptr, param, option.value)) { \
     return BRS_EXT_ERROR_VALIDATE_FAILED;                              \
@@ -120,24 +123,25 @@ brs_ext_result_t brs_ext_set_decompressor_options(BrotliDecoderState* state_ptr,
   return 0;
 }
 
+// -- exports --
+
+#define EXPORT_PARAM_BOUNDS(module, param, name)                      \
+  rb_define_const(module, "MIN_" name, UINT2NUM(BROTLI_MIN_##param)); \
+  rb_define_const(module, "MAX_" name, UINT2NUM(BROTLI_MAX_##param));
+
 void brs_ext_option_exports(VALUE root_module)
 {
-  VALUE option = rb_define_module_under(root_module, "Option");
+  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")));
-  rb_define_const(option, "MODES", modes);
+  rb_define_const(module, "MODES", modes);
   RB_GC_GUARD(modes);
 
-  rb_define_const(option, "MIN_QUALITY", UINT2NUM(BROTLI_MIN_QUALITY));
-  rb_define_const(option, "MAX_QUALITY", UINT2NUM(BROTLI_MAX_QUALITY));
-
-  rb_define_const(option, "MIN_LGWIN", UINT2NUM(BROTLI_MIN_WINDOW_BITS));
-  rb_define_const(option, "MAX_LGWIN", UINT2NUM(BROTLI_MAX_WINDOW_BITS));
-
-  rb_define_const(option, "MIN_LGBLOCK", UINT2NUM(BROTLI_MIN_INPUT_BLOCK_BITS));
-  rb_define_const(option, "MAX_LGBLOCK", UINT2NUM(BROTLI_MAX_INPUT_BLOCK_BITS));
+  EXPORT_PARAM_BOUNDS(module, QUALITY, "QUALITY");
+  EXPORT_PARAM_BOUNDS(module, WINDOW_BITS, "LGWIN");
+  EXPORT_PARAM_BOUNDS(module, INPUT_BLOCK_BITS, "LGBLOCK");
 }

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"
@@ -18,12 +17,12 @@
 
 enum {
   BRS_EXT_OPTION_TYPE_BOOL = 1,
-  BRS_EXT_OPTION_TYPE_FIXNUM,
+  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 {
   bool                   has_value;
@@ -54,11 +53,11 @@ void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_
   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_FIXNUM, quality);                        \
-  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_FIXNUM, lgwin);                          \
-  BRS_EXT_GET_OPTION(options, compressor_options, BRS_EXT_OPTION_TYPE_FIXNUM, lgblock);                        \
+  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_FIXNUM, size_hint);                      \
+  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)                                                                \
@@ -67,10 +66,10 @@ void brs_ext_get_option(VALUE options, brs_ext_option_t* option, brs_ext_option_
   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);
 
-unsigned long brs_ext_get_fixnum_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_fixnum_option_value(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);

data/ext/brs_ext/stream/compressor.c

@@ -4,11 +4,9 @@
 #include "brs_ext/stream/compressor.h"
 
 #include <brotli/encode.h>
-#include <stdint.h>
-#include <stdlib.h>
+#include <brotli/types.h>
 
 #include "brs_ext/buffer.h"
-#include "brs_ext/common.h"
 #include "brs_ext/error.h"
 #include "brs_ext/option.h"
 #include "ruby.h"
@@ -20,7 +18,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);
   }
@@ -69,7 +67,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);
@@ -89,13 +87,13 @@ VALUE brs_ext_initialize_compressor(VALUE self, VALUE options)
     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;
+#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;
 
 VALUE brs_ext_compress(VALUE self, VALUE source_value)
 {
@@ -116,7 +114,7 @@ VALUE brs_ext_compress(VALUE self, VALUE source_value)
     brs_ext_raise_error(BRS_EXT_ERROR_UNEXPECTED);
   }
 
-  VALUE bytes_written          = UINT2NUM(source_length - remaining_source_length);
+  VALUE bytes_written          = SIZET2NUM(source_length - remaining_source_length);
   VALUE needs_more_destination = BrotliEncoderHasMoreOutput(state_ptr) ? Qtrue : Qfalse;
 
   return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
@@ -129,8 +127,8 @@ VALUE brs_ext_flush_compressor(VALUE self)
 
   BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
 
-  const uint8_t* remaining_source        = NULL;
-  size_t         remaining_source_length = 0;
+  const brs_ext_byte_t* remaining_source        = NULL;
+  size_t                remaining_source_length = 0;
 
   BROTLI_BOOL result = BrotliEncoderCompressStream(
     state_ptr,
@@ -155,8 +153,8 @@ VALUE brs_ext_finish_compressor(VALUE self)
 
   BrotliEncoderState* state_ptr = compressor_ptr->state_ptr;
 
-  const uint8_t* remaining_source        = NULL;
-  size_t         remaining_source_length = 0;
+  const brs_ext_byte_t* remaining_source        = NULL;
+  size_t                remaining_source_length = 0;
 
   BROTLI_BOOL result = BrotliEncoderCompressStream(
     state_ptr,
@@ -179,9 +177,9 @@ 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;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
@@ -206,7 +204,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);
 
@@ -221,9 +219,10 @@ VALUE brs_ext_compressor_close(VALUE self)
 
 void brs_ext_compressor_exports(VALUE root_module)
 {
-  VALUE stream = rb_define_module_under(root_module, "Stream");
+  VALUE module = rb_define_module_under(root_module, "Stream");
+
+  VALUE compressor = rb_define_class_under(module, "NativeCompressor", rb_cObject);
 
-  VALUE compressor = rb_define_class_under(stream, "NativeCompressor", rb_cObject);
   rb_define_alloc_func(compressor, brs_ext_allocate_compressor);
   rb_define_method(compressor, "initialize", brs_ext_initialize_compressor, 1);
   rb_define_method(compressor, "write", brs_ext_compress, 1);

data/ext/brs_ext/stream/compressor.h

@@ -5,16 +5,16 @@
 #define BRS_EXT_STREAM_COMPRESSOR_H
 
 #include <brotli/encode.h>
-#include <stdint.h>
 #include <stdlib.h>
 
+#include "brs_ext/common.h"
 #include "ruby.h"
 
 typedef struct {
   BrotliEncoderState* state_ptr;
-  uint8_t*            destination_buffer;
+  brs_ext_byte_t*     destination_buffer;
   size_t              destination_buffer_length;
-  uint8_t*            remaining_destination_buffer;
+  brs_ext_byte_t*     remaining_destination_buffer;
   size_t              remaining_destination_buffer_length;
 } brs_ext_compressor_t;
 

data/ext/brs_ext/stream/decompressor.c

@@ -4,11 +4,8 @@
 #include "brs_ext/stream/decompressor.h"
 
 #include <brotli/decode.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/option.h"
 #include "ruby.h"
@@ -20,7 +17,7 @@ static void free_decompressor(brs_ext_decompressor_t* decompressor_ptr)
     BrotliDecoderDestroyInstance(state_ptr);
   }
 
-  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  brs_ext_byte_t* destination_buffer = decompressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
   }
@@ -69,7 +66,7 @@ VALUE brs_ext_initialize_decompressor(VALUE self, VALUE options)
     destination_buffer_length = BRS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR;
   }
 
-  uint8_t* destination_buffer = malloc(destination_buffer_length);
+  brs_ext_byte_t* destination_buffer = malloc(destination_buffer_length);
   if (destination_buffer == NULL) {
     BrotliDecoderDestroyInstance(state_ptr);
     brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
@@ -89,13 +86,13 @@ VALUE brs_ext_initialize_decompressor(VALUE self, VALUE options)
     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;
+#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;
 
 VALUE brs_ext_decompress(VALUE self, VALUE source_value)
 {
@@ -117,10 +114,10 @@ VALUE brs_ext_decompress(VALUE self, VALUE source_value)
     brs_ext_raise_error(brs_ext_get_decompressor_error(error_code));
   }
 
-  VALUE bytes_written          = UINT2NUM(source_length - remaining_source_length);
+  VALUE bytes_read             = SIZET2NUM(source_length - remaining_source_length);
   VALUE needs_more_destination = result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT ? Qtrue : Qfalse;
 
-  return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
+  return rb_ary_new_from_args(2, bytes_read, needs_more_destination);
 }
 
 VALUE brs_ext_decompressor_read_result(VALUE self)
@@ -128,9 +125,9 @@ VALUE brs_ext_decompressor_read_result(VALUE self)
   GET_DECOMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
 
-  uint8_t* destination_buffer                  = decompressor_ptr->destination_buffer;
-  size_t   destination_buffer_length           = decompressor_ptr->destination_buffer_length;
-  size_t   remaining_destination_buffer_length = decompressor_ptr->remaining_destination_buffer_length;
+  brs_ext_byte_t* destination_buffer                  = decompressor_ptr->destination_buffer;
+  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;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
@@ -155,7 +152,7 @@ VALUE brs_ext_decompressor_close(VALUE self)
     decompressor_ptr->state_ptr = NULL;
   }
 
-  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  brs_ext_byte_t* destination_buffer = decompressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
 
@@ -170,9 +167,10 @@ VALUE brs_ext_decompressor_close(VALUE self)
 
 void brs_ext_decompressor_exports(VALUE root_module)
 {
-  VALUE stream = rb_define_module_under(root_module, "Stream");
+  VALUE module = rb_define_module_under(root_module, "Stream");
+
+  VALUE decompressor = rb_define_class_under(module, "NativeDecompressor", rb_cObject);
 
-  VALUE decompressor = rb_define_class_under(stream, "NativeDecompressor", rb_cObject);
   rb_define_alloc_func(decompressor, brs_ext_allocate_decompressor);
   rb_define_method(decompressor, "initialize", brs_ext_initialize_decompressor, 1);
   rb_define_method(decompressor, "read", brs_ext_decompress, 1);

data/ext/brs_ext/stream/decompressor.h

@@ -5,16 +5,16 @@
 #define BRS_EXT_STREAM_DECOMPRESSOR_H
 
 #include <brotli/decode.h>
-#include <stdint.h>
 #include <stdlib.h>
 
+#include "brs_ext/common.h"
 #include "ruby.h"
 
 typedef struct {
   BrotliDecoderState* state_ptr;
-  uint8_t*            destination_buffer;
+  brs_ext_byte_t*     destination_buffer;
   size_t              destination_buffer_length;
-  uint8_t*            remaining_destination_buffer;
+  brs_ext_byte_t*     remaining_destination_buffer;
   size_t              remaining_destination_buffer_length;
 } brs_ext_decompressor_t;
 

data/ext/brs_ext/string.c

@@ -5,11 +5,10 @@
 
 #include <brotli/decode.h>
 #include <brotli/encode.h>
-#include <stdint.h>
+#include <brotli/types.h>
 #include <stdlib.h>
 
 #include "brs_ext/buffer.h"
-#include "brs_ext/common.h"
 #include "brs_ext/error.h"
 #include "brs_ext/macro.h"
 #include "brs_ext/option.h"
@@ -17,26 +16,6 @@
 
 // -- buffer --
 
-static inline VALUE create_buffer(VALUE length)
-{
-  return rb_str_new(NULL, NUM2UINT(length));
-}
-
-#define CREATE_BUFFER(buffer, length, exception) \
-  VALUE buffer = rb_protect(create_buffer, UINT2NUM(length), &exception);
-
-static inline VALUE resize_buffer(VALUE args)
-{
-  VALUE buffer = rb_ary_entry(args, 0);
-  VALUE length = rb_ary_entry(args, 1);
-  return rb_str_resize(buffer, NUM2UINT(length));
-}
-
-#define RESIZE_BUFFER(buffer, length, exception)                                        \
-  VALUE resize_buffer_args = rb_ary_new_from_args(2, buffer, UINT2NUM(length));         \
-  buffer                   = rb_protect(resize_buffer, resize_buffer_args, &exception); \
-  RB_GC_GUARD(resize_buffer_args);
-
 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)
@@ -48,7 +27,7 @@ static inline brs_ext_result_t increase_destination_buffer(
 
   int exception;
 
-  RESIZE_BUFFER(destination_value, destination_length + destination_buffer_length, exception);
+  BRS_EXT_RESIZE_STRING_BUFFER(destination_value, destination_length + destination_buffer_length, exception);
   if (exception != 0) {
     return BRS_EXT_ERROR_ALLOCATE_FAILED;
   }
@@ -60,31 +39,33 @@ static inline brs_ext_result_t increase_destination_buffer(
 
 // -- 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); \
-  const uint8_t* remaining_source        = (const uint8_t*)source;    \
-  size_t         remaining_source_length = source_length;
+#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 --
 
 static inline brs_ext_result_t compress(
   BrotliEncoderState* state_ptr,
-  const uint8_t* remaining_source, size_t remaining_source_length,
+  const char* source, size_t source_length,
   VALUE destination_value, size_t destination_buffer_length)
 {
+  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;
+
   size_t destination_length                  = 0;
   size_t remaining_destination_buffer_length = destination_buffer_length;
 
   while (true) {
-    uint8_t* remaining_destination_buffer             = (uint8_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;
 
-    BROTLI_BOOL result = BrotliEncoderCompressStream(
+    result = BrotliEncoderCompressStream(
       state_ptr,
       BROTLI_OPERATION_FINISH,
       &remaining_source_length, &remaining_source,
@@ -114,7 +95,7 @@ static inline brs_ext_result_t compress(
 
   int exception;
 
-  RESIZE_BUFFER(destination_value, destination_length, exception);
+  BRS_EXT_RESIZE_STRING_BUFFER(destination_value, destination_length, exception);
   if (exception != 0) {
     return BRS_EXT_ERROR_ALLOCATE_FAILED;
   }
@@ -146,7 +127,7 @@ VALUE brs_ext_compress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VA
 
   int exception;
 
-  CREATE_BUFFER(destination_value, destination_buffer_length, exception);
+  BRS_EXT_CREATE_STRING_BUFFER(destination_value, destination_buffer_length, exception);
   if (exception != 0) {
     BrotliEncoderDestroyInstance(state_ptr);
     brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
@@ -154,7 +135,7 @@ VALUE brs_ext_compress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VA
 
   ext_result = compress(
     state_ptr,
-    remaining_source, remaining_source_length,
+    source, source_length,
     destination_value, destination_buffer_length);
 
   BrotliEncoderDestroyInstance(state_ptr);
@@ -170,19 +151,23 @@ VALUE brs_ext_compress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value, VA
 
 static inline brs_ext_result_t decompress(
   BrotliDecoderState* state_ptr,
-  const uint8_t* remaining_source, size_t remaining_source_length,
+  const char* source, size_t source_length,
   VALUE destination_value, size_t destination_buffer_length)
 {
-  brs_ext_result_t ext_result;
+  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;
 
   size_t destination_length                  = 0;
   size_t remaining_destination_buffer_length = destination_buffer_length;
 
   while (true) {
-    uint8_t* remaining_destination_buffer             = (uint8_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;
 
-    BrotliDecoderResult result = BrotliDecoderDecompressStream(
+    result = BrotliDecoderDecompressStream(
       state_ptr,
       &remaining_source_length, &remaining_source,
       &remaining_destination_buffer_length, &remaining_destination_buffer,
@@ -215,7 +200,7 @@ static inline brs_ext_result_t decompress(
 
   int exception;
 
-  RESIZE_BUFFER(destination_value, destination_length, exception);
+  BRS_EXT_RESIZE_STRING_BUFFER(destination_value, destination_length, exception);
   if (exception != 0) {
     brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
   }
@@ -247,7 +232,7 @@ VALUE brs_ext_decompress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value,
 
   int exception;
 
-  CREATE_BUFFER(destination_value, destination_buffer_length, exception);
+  BRS_EXT_CREATE_STRING_BUFFER(destination_value, destination_buffer_length, exception);
   if (exception != 0) {
     BrotliDecoderDestroyInstance(state_ptr);
     brs_ext_raise_error(BRS_EXT_ERROR_ALLOCATE_FAILED);
@@ -255,7 +240,7 @@ VALUE brs_ext_decompress_string(VALUE BRS_EXT_UNUSED(self), VALUE source_value,
 
   ext_result = decompress(
     state_ptr,
-    remaining_source, remaining_source_length,
+    source, source_length,
     destination_value, destination_buffer_length);
 
   BrotliDecoderDestroyInstance(state_ptr);