ruby-lzws 1.0.0 → 1.1.0

data/ext/lzws_ext/stream/decompressor.h

@@ -5,6 +5,8 @@
 #define LZWS_EXT_STREAM_DECOMPRESSOR_H
 
 #include <lzws/decompressor/state.h>
+#include <stdint.h>
+#include <stdlib.h>
 
 #include "ruby.h"
 
@@ -18,9 +20,10 @@ typedef struct {
 
 VALUE lzws_ext_allocate_decompressor(VALUE klass);
 VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options);
-VALUE lzws_ext_decompressor_read_magic_header(VALUE self, VALUE source);
 VALUE lzws_ext_decompress(VALUE self, VALUE source);
 VALUE lzws_ext_decompressor_read_result(VALUE self);
 VALUE lzws_ext_decompressor_close(VALUE self);
 
+void lzws_ext_decompressor_exports(VALUE root_module);
+
 #endif // LZWS_EXT_STREAM_DECOMPRESSOR_H

data/ext/lzws_ext/string.c

@@ -1,78 +1,295 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include <lzws/string.h>
+#include "lzws_ext/string.h"
 
-#include "ruby.h"
+#include <lzws/buffer.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 <stdint.h>
+#include <stdlib.h>
 
 #include "lzws_ext/error.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
-#include "lzws_ext/string.h"
+#include "ruby.h"
+
+// -- 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);
 
-#define GET_STRING(source)                         \
-  Check_Type(source, T_STRING);                    \
-                                                   \
-  const char* source_data   = RSTRING_PTR(source); \
-  size_t      source_length = RSTRING_LEN(source);
+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 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)
+{
+  if (*remaining_destination_buffer_length_ptr == destination_buffer_length) {
+    // We want to write more data at once, than buffer has.
+    return LZWS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER;
+  }
+
+  int exception;
+
+  RESIZE_BUFFER(destination_value, destination_length + destination_buffer_length, exception);
+  if (exception != 0) {
+    return LZWS_EXT_ERROR_ALLOCATE_FAILED;
+  }
+
+  *remaining_destination_buffer_length_ptr = destination_buffer_length;
+
+  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); \
+  uint8_t*    remaining_source        = (uint8_t*)source;          \
+  size_t      remaining_source_length = source_length;
+
+// -- compress --
+
+#define BUFFERED_COMPRESS(function, ...)                                                                               \
+  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;                           \
+                                                                                                                       \
+    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;                                                                                                             \
+  }
+
+static inline lzws_ext_result_t compress(
+  lzws_compressor_state_t* state_ptr,
+  uint8_t* remaining_source, size_t remaining_source_length,
+  VALUE destination_value, size_t destination_buffer_length)
+{
+  lzws_result_t     result;
+  lzws_ext_result_t ext_result;
+
+  size_t destination_length                  = 0;
+  size_t remaining_destination_buffer_length = destination_buffer_length;
+
+  BUFFERED_COMPRESS(lzws_compress, state_ptr, &remaining_source, &remaining_source_length);
+  BUFFERED_COMPRESS(lzws_compressor_finish, state_ptr);
+
+  int exception;
+
+  RESIZE_BUFFER(destination_value, destination_length, exception);
+  if (exception != 0) {
+    return LZWS_EXT_ERROR_ALLOCATE_FAILED;
+  }
+
+  return 0;
+}
 
-VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE options)
+VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_STRING(source);
+  GET_SOURCE_DATA(source_value);
+  Check_Type(options, T_HASH);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  char*  destination;
-  size_t destination_length;
+  lzws_compressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_compress_string(
-    (uint8_t*)source_data, source_length,
-    (uint8_t**)&destination, &destination_length, buffer_length,
+  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);
 
-  if (result == LZWS_STRING_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
+  if (result != 0) {
+    switch (result) {
+      case LZWS_COMPRESSOR_ALLOCATE_FAILED:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
+      case LZWS_COMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
+      default:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
+    }
   }
-  else if (result == LZWS_STRING_VALIDATE_FAILED) {
-    lzws_ext_raise_error("ValidateError", "validate error");
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR;
+  }
+
+  int exception;
+
+  CREATE_BUFFER(destination_value, destination_buffer_length, exception);
+  if (exception != 0) {
+    lzws_compressor_free_state(state_ptr);
+    lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
+  }
+
+  lzws_ext_result_t ext_result = compress(
+    state_ptr,
+    remaining_source, remaining_source_length,
+    destination_value, destination_buffer_length);
+
+  lzws_compressor_free_state(state_ptr);
+
+  if (ext_result != 0) {
+    lzws_ext_raise_error(ext_result);
+  }
+
+  return destination_value;
+}
+
+// -- decompress --
+
+static inline lzws_ext_result_t decompress(
+  lzws_decompressor_state_t* state_ptr,
+  uint8_t* remaining_source, size_t remaining_source_length,
+  VALUE destination_value, size_t destination_buffer_length)
+{
+  lzws_result_t     result;
+  lzws_ext_result_t ext_result;
+
+  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;
+
+    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) {
+        case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
+        case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
+          return LZWS_EXT_ERROR_VALIDATE_FAILED;
+        case LZWS_DECOMPRESSOR_CORRUPTED_SOURCE:
+          return LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE;
+        default:
+          return LZWS_EXT_ERROR_UNEXPECTED;
+      }
+    }
+
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;
+
+    if (result == LZWS_DECOMPRESSOR_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;
   }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+
+  int exception;
+
+  RESIZE_BUFFER(destination_value, destination_length, exception);
+  if (exception != 0) {
+    return LZWS_EXT_ERROR_ALLOCATE_FAILED;
   }
 
-  // Ruby copies string on initialization.
-  VALUE result_string = rb_str_new(destination, destination_length);
-  free(destination);
-  return result_string;
+  return 0;
 }
 
-VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE options)
+VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value, VALUE options)
 {
-  GET_STRING(source);
+  GET_SOURCE_DATA(source_value);
+  Check_Type(options, T_HASH);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  char*  destination;
-  size_t destination_length;
+  lzws_decompressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_decompress_string(
-    (uint8_t*)source_data, source_length,
-    (uint8_t**)&destination, &destination_length, buffer_length,
+  lzws_result_t result = lzws_decompressor_get_initial_state(
+    &state_ptr,
     without_magic_header, msb, unaligned_bit_groups, quiet);
 
-  if (result == LZWS_STRING_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
+  if (result != 0) {
+    switch (result) {
+      case LZWS_DECOMPRESSOR_ALLOCATE_FAILED:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
+      default:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
+    }
   }
-  else if (result == LZWS_STRING_VALIDATE_FAILED) {
-    lzws_ext_raise_error("ValidateError", "validate error");
+
+  if (destination_buffer_length == 0) {
+    destination_buffer_length = LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR;
   }
-  else if (result == LZWS_STRING_DECOMPRESSOR_CORRUPTED_SOURCE) {
-    lzws_ext_raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
+
+  int exception;
+
+  CREATE_BUFFER(destination_value, destination_buffer_length, exception);
+  if (exception != 0) {
+    lzws_decompressor_free_state(state_ptr);
+    lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+
+  lzws_ext_result_t ext_result = decompress(
+    state_ptr,
+    remaining_source, remaining_source_length,
+    destination_value, destination_buffer_length);
+
+  lzws_decompressor_free_state(state_ptr);
+
+  if (ext_result != 0) {
+    lzws_ext_raise_error(ext_result);
   }
 
-  // Ruby copies string on initialization.
-  VALUE result_string = rb_str_new(destination, destination_length);
-  free(destination);
-  return result_string;
+  return destination_value;
+}
+
+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);
+  rb_define_module_function(root_module, "_native_decompress_string", RUBY_METHOD_FUNC(lzws_ext_decompress_string), 2);
 }

data/ext/lzws_ext/string.h

@@ -9,4 +9,6 @@
 VALUE lzws_ext_compress_string(VALUE self, VALUE source, VALUE options);
 VALUE lzws_ext_decompress_string(VALUE self, VALUE source, VALUE options);
 
+void lzws_ext_string_exports(VALUE root_module);
+
 #endif // LZWS_EXT_STRING_H

data/lib/lzws/error.rb

@@ -4,17 +4,18 @@
 module LZWS
   class BaseError < ::StandardError; end
 
-  class ValidateError   < BaseError; end
-  class AllocateError   < BaseError; end
-  class UnexpectedError < BaseError; end
-
-  class NotEnoughDestinationError < BaseError; end
-  class UsedAfterCloseError       < BaseError; end
+  class AllocateError < BaseError; end
+  class ValidateError < BaseError; end
 
+  class UsedAfterCloseError              < BaseError; end
+  class NotEnoughSourceBufferError       < BaseError; end
+  class NotEnoughDestinationBufferError  < BaseError; end
+  class NotEnoughDestinationError        < BaseError; end
   class DecompressorCorruptedSourceError < BaseError; end
 
-  class OpenFileError < BaseError; end
   class AccessIOError < BaseError; end
   class ReadIOError   < BaseError; end
   class WriteIOError  < BaseError; end
+
+  class UnexpectedError < BaseError; end
 end

data/lib/lzws/file.rb

@@ -9,11 +9,13 @@ require_relative "validation"
 
 module LZWS
   module File
+    BUFFER_LENGTH_NAMES = %i[source_buffer_length destination_buffer_length].freeze
+
     def self.compress(source, destination, options = {})
       Validation.validate_string source
       Validation.validate_string destination
 
-      options = Option.get_compressor_options options
+      options = Option.get_compressor_options options, BUFFER_LENGTH_NAMES
 
       open_files(source, destination) do |source_io, destination_io|
         LZWS._native_compress_io source_io, destination_io, options
@@ -24,7 +26,7 @@ module LZWS
       Validation.validate_string source
       Validation.validate_string destination
 
-      options = Option.get_decompressor_options options
+      options = Option.get_decompressor_options options, BUFFER_LENGTH_NAMES
 
       open_files(source, destination) do |source_io, destination_io|
         LZWS._native_decompress_io source_io, destination_io, options
@@ -32,25 +34,11 @@ module LZWS
     end
 
     private_class_method def self.open_files(source, destination, &_block)
-      open_file(source, "rb") do |source_io|
-        open_file(destination, "wb") do |destination_io|
+      ::File.open source, "rb" do |source_io|
+        ::File.open destination, "wb" do |destination_io|
           yield source_io, destination_io
         end
       end
     end
-
-    private_class_method def self.open_file(path, mode, &_block)
-      begin
-        io = ::File.open path, mode
-      rescue ::StandardError
-        raise OpenFileError, "open file failed"
-      end
-
-      begin
-        yield io
-      ensure
-        io.close
-      end
-    end
   end
 end

data/lib/lzws/option.rb

@@ -8,11 +8,11 @@ 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 = {
-      :buffer_length        => 0,
       :without_magic_header => false,
       :msb                  => false,
       :unaligned_bit_groups => false,
@@ -26,12 +26,13 @@ module LZWS
     )
     .freeze
 
-    def self.get_compressor_options(options)
+    def self.get_compressor_options(options, buffer_length_names)
       Validation.validate_hash options
 
-      options = COMPRESSOR_DEFAULTS.merge options
+      buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
+      options                = COMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
 
-      Validation.validate_not_negative_integer options[:buffer_length]
+      buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
       max_code_bit_length = options[:max_code_bit_length]
       Validation.validate_positive_integer max_code_bit_length
@@ -49,12 +50,14 @@ module LZWS
       options
     end
 
-    def self.get_decompressor_options(options)
+    def self.get_decompressor_options(options, buffer_length_names)
       Validation.validate_hash options
 
-      options = DECOMPRESSOR_DEFAULTS.merge options
+      buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
+      options                = DECOMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
+
+      buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
-      Validation.validate_not_negative_integer options[:buffer_length]
       Validation.validate_bool options[:without_magic_header]
       Validation.validate_bool options[:msb]
       Validation.validate_bool options[:unaligned_bit_groups]

data/lib/lzws/stream/abstract.rb

@@ -9,7 +9,7 @@ require_relative "../validation"
 module LZWS
   module Stream
     class Abstract
-      # LZWS native stream is not seekable by design.
+      # Native stream is not seekable by design.
       # Related methods like "seek" and "pos=" can't be implemented.
 
       # It is not possible to maintain correspondance between bytes consumed from source and bytes written to destination by design.
@@ -21,6 +21,7 @@ module LZWS
       attr_reader :stat
       attr_reader :external_encoding
       attr_reader :internal_encoding
+      attr_reader :transcode_options
       attr_reader :pos
       alias tell pos
 
@@ -115,7 +116,6 @@ module LZWS
 
       protected def target_encoding
         return @internal_encoding unless @internal_encoding.nil?
-
         return @external_encoding unless @external_encoding.nil?
 
         ::Encoding::BINARY

data/lib/lzws/stream/raw/abstract.rb

@@ -4,6 +4,7 @@
 require "lzws_ext"
 
 require_relative "../../error"
+require_relative "../../validation"
 
 module LZWS
   module Stream
@@ -14,19 +15,16 @@ module LZWS
           @is_closed     = false
         end
 
-        def close(&writer)
-          return nil if @is_closed
+        # -- write --
 
-          flush(&writer)
+        def flush(&writer)
+          do_not_use_after_close
 
-          @native_stream.close
-          @is_closed = true
+          Validation.validate_proc writer
 
-          nil
-        end
+          write_result(&writer)
 
-        def closed?
-          @is_closed
+          nil
         end
 
         protected def flush_destination_buffer(&writer)
@@ -40,6 +38,23 @@ module LZWS
 
           result.bytesize
         end
+
+        # -- close --
+
+        protected def do_not_use_after_close
+          raise UsedAfterCloseError, "used after close" if closed?
+        end
+
+        def close(&writer)
+          write_result(&writer)
+
+          @native_stream.close
+          @is_closed = true
+        end
+
+        def closed?
+          @is_closed
+        end
       end
     end
   end

data/lib/lzws/stream/raw/compressor.rb

@@ -12,13 +12,13 @@ module LZWS
   module Stream
     module Raw
       class Compressor < Abstract
+        BUFFER_LENGTH_NAMES = %i[destination_buffer_length].freeze
+
         def initialize(options = {})
-          options       = Option.get_compressor_options options
+          options       = Option.get_compressor_options options, BUFFER_LENGTH_NAMES
           native_stream = NativeCompressor.new options
 
           super native_stream
-
-          @need_to_write_magic_header = !options[:without_magic_header]
         end
 
         def write(source, &writer)
@@ -27,11 +27,6 @@ module LZWS
           Validation.validate_string source
           Validation.validate_proc writer
 
-          if @need_to_write_magic_header
-            write_magic_header(&writer)
-            @need_to_write_magic_header = false
-          end
-
           total_bytes_written = 0
 
           loop do
@@ -55,28 +50,13 @@ module LZWS
           total_bytes_written
         end
 
-        protected def write_magic_header(&writer)
-          loop do
-            need_more_destination = @native_stream.write_magic_header
-
-            if need_more_destination
-              flush_destination_buffer(&writer)
-              next
-            end
-
-            break
-          end
-
-          nil
-        end
-
-        def flush(&writer)
-          do_not_use_after_close
+        def close(&writer)
+          return nil if closed?
 
           Validation.validate_proc writer
 
           loop do
-            need_more_destination = @native_stream.flush
+            need_more_destination = @native_stream.finish
 
             if need_more_destination
               flush_destination_buffer(&writer)
@@ -86,14 +66,10 @@ module LZWS
             break
           end
 
-          write_result(&writer)
+          super
 
           nil
         end
-
-        protected def do_not_use_after_close
-          raise UsedAfterCloseError, "compressor used after close" if @is_closed
-        end
       end
     end
   end