ruby-lzws 1.1.4 → 1.3.0

data/ext/lzws_ext/stream/decompressor.h

@@ -5,17 +5,20 @@
 #define LZWS_EXT_STREAM_DECOMPRESSOR_H
 
 #include <lzws/decompressor/state.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include "lzws_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   lzws_decompressor_state_t* state_ptr;
   lzws_ext_byte_t*           destination_buffer;
   size_t                     destination_buffer_length;
   lzws_ext_byte_t*           remaining_destination_buffer;
   size_t                     remaining_destination_buffer_length;
+  bool                       gvl;
 } lzws_ext_decompressor_t;
 
 VALUE lzws_ext_allocate_decompressor(VALUE klass);

data/ext/lzws_ext/string.c

@@ -4,17 +4,15 @@
 #include "lzws_ext/string.h"
 
 #include <lzws/buffer.h>
-#include <lzws/common.h>
-#include <lzws/compressor/common.h>
 #include <lzws/compressor/main.h>
 #include <lzws/compressor/state.h>
-#include <lzws/decompressor/common.h>
 #include <lzws/decompressor/main.h>
 #include <lzws/decompressor/state.h>
 #include <stdlib.h>
 
 #include "lzws_ext/buffer.h"
 #include "lzws_ext/error.h"
+#include "lzws_ext/gvl.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
 #include "ruby.h"
@@ -22,8 +20,10 @@
 // -- buffer --
 
 static inline lzws_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.
@@ -42,62 +42,103 @@ static inline lzws_ext_result_t increase_destination_buffer(
   return 0;
 }
 
-// -- utils --
+// -- compress --
 
-#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);
+typedef struct
+{
+  lzws_compressor_state_t* state_ptr;
+  lzws_ext_byte_t**        remaining_source_ptr;
+  size_t*                  remaining_source_length_ptr;
+  lzws_ext_byte_t*         remaining_destination_buffer;
+  size_t*                  remaining_destination_buffer_length_ptr;
+  lzws_result_t            result;
+} compress_args_t;
+
+typedef struct
+{
+  lzws_compressor_state_t* state_ptr;
+  lzws_ext_byte_t*         remaining_destination_buffer;
+  size_t*                  remaining_destination_buffer_length_ptr;
+  lzws_result_t            result;
+} compressor_finish_args_t;
 
-// -- compress --
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t* args = data;
+
+  args->result = lzws_compress(
+    args->state_ptr,
+    args->remaining_source_ptr,
+    args->remaining_source_length_ptr,
+    &args->remaining_destination_buffer,
+    args->remaining_destination_buffer_length_ptr);
 
-#define BUFFERED_COMPRESS(function, ...)                                                                                               \
-  while (true) {                                                                                                                       \
-    lzws_ext_byte_t* remaining_destination_buffer             = (lzws_ext_byte_t*)RSTRING_PTR(destination_value) + destination_length; \
-    size_t           prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                                   \
-                                                                                                                                       \
-    result = function(__VA_ARGS__, &remaining_destination_buffer, &remaining_destination_buffer_length);                               \
-                                                                                                                                       \
-    if (                                                                                                                               \
-      result != 0 &&                                                                                                                   \
-      result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                                              \
-      return LZWS_EXT_ERROR_UNEXPECTED;                                                                                                \
-    }                                                                                                                                  \
-                                                                                                                                       \
-    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;                              \
-                                                                                                                                       \
-    if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                                            \
-      ext_result = increase_destination_buffer(                                                                                        \
-        destination_value, destination_length,                                                                                         \
-        &remaining_destination_buffer_length, destination_buffer_length);                                                              \
-                                                                                                                                       \
-      if (ext_result != 0) {                                                                                                           \
-        return ext_result;                                                                                                             \
-      }                                                                                                                                \
-                                                                                                                                       \
-      continue;                                                                                                                        \
-    }                                                                                                                                  \
-                                                                                                                                       \
-    break;                                                                                                                             \
+  return NULL;
+}
+
+static inline void* compressor_finish_wrapper(void* data)
+{
+  compressor_finish_args_t* args = data;
+
+  args->result = lzws_compressor_finish(
+    args->state_ptr, &args->remaining_destination_buffer, args->remaining_destination_buffer_length_ptr);
+
+  return NULL;
+}
+
+#define BUFFERED_COMPRESS(gvl, wrapper, args)                                                                    \
+  while (true) {                                                                                                 \
+    lzws_ext_byte_t* remaining_destination_buffer =                                                              \
+      (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;                                    \
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                       \
+                                                                                                                 \
+    args.remaining_destination_buffer            = remaining_destination_buffer;                                 \
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;                         \
+                                                                                                                 \
+    LZWS_EXT_GVL_WRAP(gvl, wrapper, &args);                                                                      \
+    if (args.result != 0 && args.result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                             \
+      return LZWS_EXT_ERROR_UNEXPECTED;                                                                          \
+    }                                                                                                            \
+                                                                                                                 \
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;        \
+                                                                                                                 \
+    if (args.result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                 \
+      ext_result = increase_destination_buffer(                                                                  \
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length); \
+                                                                                                                 \
+      if (ext_result != 0) {                                                                                     \
+        return ext_result;                                                                                       \
+      }                                                                                                          \
+                                                                                                                 \
+      continue;                                                                                                  \
+    }                                                                                                            \
+                                                                                                                 \
+    break;                                                                                                       \
   }
 
 static inline lzws_ext_result_t compress(
   lzws_compressor_state_t* 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)
 {
-  lzws_result_t     result;
   lzws_ext_result_t ext_result;
+  lzws_ext_byte_t*  remaining_source                    = (lzws_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;
 
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*)source;
-  size_t           remaining_source_length = source_length;
+  compress_args_t args = {
+    .state_ptr                   = state_ptr,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
 
-  size_t destination_length                  = 0;
-  size_t remaining_destination_buffer_length = destination_buffer_length;
+  BUFFERED_COMPRESS(gvl, compress_wrapper, args);
 
-  BUFFERED_COMPRESS(lzws_compress, state_ptr, &remaining_source, &remaining_source_length);
-  BUFFERED_COMPRESS(lzws_compressor_finish, state_ptr);
+  compressor_finish_args_t finish_args = {.state_ptr = state_ptr};
+  BUFFERED_COMPRESS(gvl, compressor_finish_wrapper, finish_args);
 
   int exception;
 
@@ -111,17 +152,15 @@ static inline lzws_ext_result_t compress(
 
 VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_compressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_compressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_compressor_get_initial_state(&state_ptr, &compressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_COMPRESSOR_ALLOCATE_FAILED:
@@ -145,10 +184,11 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  lzws_ext_result_t 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);
+
+  lzws_ext_result_t ext_result =
+    compress(state_ptr, source, source_length, destination_value, destination_buffer_length, gvl);
 
   lzws_compressor_free_state(state_ptr);
 
@@ -161,33 +201,60 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
 
 // -- decompress --
 
+typedef struct
+{
+  lzws_decompressor_state_t* state_ptr;
+  lzws_ext_byte_t**          remaining_source_ptr;
+  size_t*                    remaining_source_length_ptr;
+  lzws_ext_byte_t*           remaining_destination_buffer;
+  size_t*                    remaining_destination_buffer_length_ptr;
+  lzws_result_t              result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->result = lzws_decompress(
+    args->state_ptr,
+    args->remaining_source_ptr,
+    args->remaining_source_length_ptr,
+    &args->remaining_destination_buffer,
+    args->remaining_destination_buffer_length_ptr);
+
+  return NULL;
+}
+
 static inline lzws_ext_result_t decompress(
   lzws_decompressor_state_t* 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)
 {
-  lzws_result_t     result;
   lzws_ext_result_t ext_result;
+  lzws_ext_byte_t*  remaining_source                    = (lzws_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;
 
-  lzws_ext_byte_t* remaining_source        = (lzws_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;
+  decompress_args_t args = {
+    .state_ptr                   = state_ptr,
+    .remaining_source_ptr        = &remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
 
   while (true) {
-    lzws_ext_byte_t* remaining_destination_buffer             = (lzws_ext_byte_t*)RSTRING_PTR(destination_value) + destination_length;
-    size_t           prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
-
-    result = lzws_decompress(
-      state_ptr,
-      &remaining_source, &remaining_source_length,
-      &remaining_destination_buffer, &remaining_destination_buffer_length);
-
-    if (
-      result != 0 &&
-      result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
-      switch (result) {
+    lzws_ext_byte_t* remaining_destination_buffer =
+      (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+
+    args.remaining_destination_buffer            = remaining_destination_buffer;
+    args.remaining_destination_buffer_length_ptr = &remaining_destination_buffer_length;
+
+    LZWS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
+    if (args.result != 0 && args.result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+      switch (args.result) {
         case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
         case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
           return LZWS_EXT_ERROR_VALIDATE_FAILED;
@@ -200,10 +267,9 @@ static inline lzws_ext_result_t decompress(
 
     destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
 
-    if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+    if (args.result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
       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;
@@ -227,17 +293,15 @@ static inline lzws_ext_result_t decompress(
 
 VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_decompressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_decompressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_decompressor_get_initial_state(&state_ptr, &decompressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_DECOMPRESSOR_ALLOCATE_FAILED:
@@ -259,10 +323,11 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  lzws_ext_result_t 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);
+
+  lzws_ext_result_t ext_result =
+    decompress(state_ptr, source, source_length, destination_value, destination_buffer_length, gvl);
 
   lzws_decompressor_free_state(state_ptr);
 
@@ -273,6 +338,8 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
   return destination_value;
 }
 
+// -- exports --
+
 void lzws_ext_string_exports(VALUE root_module)
 {
   rb_define_module_function(root_module, "_native_compress_string", RUBY_METHOD_FUNC(lzws_ext_compress_string), 2);

data/lib/lzws/file.rb

@@ -20,6 +20,8 @@ module LZWS
       open_files(source, destination) do |source_io, destination_io|
         LZWS._native_compress_io source_io, destination_io, options
       end
+
+      nil
     end
 
     def self.decompress(source, destination, options = {})
@@ -31,6 +33,8 @@ module LZWS
       open_files(source, destination) do |source_io, destination_io|
         LZWS._native_decompress_io source_io, destination_io, options
       end
+
+      nil
     end
 
     private_class_method def self.open_files(source, destination, &_block)

data/lib/lzws/option.rb

@@ -8,24 +8,26 @@ require_relative "validation"
 
 module LZWS
   module Option
-    # Default options will be compatible with UNIX compress.
-
-    DEFAULT_BUFFER_LENGTH       = 0
-    LOWEST_MAX_CODE_BIT_LENGTH  = 9
-    BIGGEST_MAX_CODE_BIT_LENGTH = 16
-
-    DECOMPRESSOR_DEFAULTS = {
-      :without_magic_header => false,
-      :msb                  => false,
-      :unaligned_bit_groups => false,
-      :quiet                => false
+    DEFAULT_BUFFER_LENGTH = 0
+
+    COMPRESSOR_DEFAULTS = {
+      :gvl                  => false,
+      :max_code_bit_length  => nil,
+      :without_magic_header => nil,
+      :block_mode           => nil,
+      :msb                  => nil,
+      :unaligned_bit_groups => nil,
+      :quiet                => nil
     }
     .freeze
 
-    COMPRESSOR_DEFAULTS = DECOMPRESSOR_DEFAULTS.merge(
-      :max_code_bit_length => BIGGEST_MAX_CODE_BIT_LENGTH,
-      :block_mode          => true
-    )
+    DECOMPRESSOR_DEFAULTS = {
+      :gvl                  => false,
+      :without_magic_header => nil,
+      :msb                  => nil,
+      :unaligned_bit_groups => nil,
+      :quiet                => nil
+    }
     .freeze
 
     def self.get_compressor_options(options, buffer_length_names)
@@ -36,17 +38,29 @@ module LZWS
 
       buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
+      Validation.validate_bool options[:gvl]
+
       max_code_bit_length = options[:max_code_bit_length]
-      Validation.validate_positive_integer max_code_bit_length
+      unless max_code_bit_length.nil?
+        Validation.validate_positive_integer max_code_bit_length
+        raise ValidateError, "invalid max code bit length" if
+          max_code_bit_length < LOWEST_MAX_CODE_BIT_LENGTH || max_code_bit_length > BIGGEST_MAX_CODE_BIT_LENGTH
+      end
+
+      without_magic_header = options[:without_magic_header]
+      Validation.validate_bool without_magic_header unless without_magic_header.nil?
 
-      raise ValidateError, "invalid max code bit length" if
-        max_code_bit_length < LOWEST_MAX_CODE_BIT_LENGTH || max_code_bit_length > BIGGEST_MAX_CODE_BIT_LENGTH
+      block_mode = options[:block_mode]
+      Validation.validate_bool block_mode unless block_mode.nil?
 
-      Validation.validate_bool options[:without_magic_header]
-      Validation.validate_bool options[:block_mode]
-      Validation.validate_bool options[:msb]
-      Validation.validate_bool options[:unaligned_bit_groups]
-      Validation.validate_bool options[:quiet]
+      msb = options[:msb]
+      Validation.validate_bool msb unless msb.nil?
+
+      unaligned_bit_groups = options[:unaligned_bit_groups]
+      Validation.validate_bool unaligned_bit_groups unless unaligned_bit_groups.nil?
+
+      quiet = options[:quiet]
+      Validation.validate_bool quiet unless quiet.nil?
 
       options
     end
@@ -59,10 +73,19 @@ module LZWS
 
       buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
-      Validation.validate_bool options[:without_magic_header]
-      Validation.validate_bool options[:msb]
-      Validation.validate_bool options[:unaligned_bit_groups]
-      Validation.validate_bool options[:quiet]
+      Validation.validate_bool options[:gvl]
+
+      without_magic_header = options[:without_magic_header]
+      Validation.validate_bool without_magic_header unless without_magic_header.nil?
+
+      msb = options[:msb]
+      Validation.validate_bool msb unless msb.nil?
+
+      unaligned_bit_groups = options[:unaligned_bit_groups]
+      Validation.validate_bool unaligned_bit_groups unless unaligned_bit_groups.nil?
+
+      quiet = options[:quiet]
+      Validation.validate_bool quiet unless quiet.nil?
 
       options
     end