omnizip 0.3.1

data/lib/omnizip/algorithms/ppmd8/encoder.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require_relative "model"
+require_relative "../lzma/range_encoder"
+
+module Omnizip
+  module Algorithms
+    class PPMd8 < PPMdBase
+      # PPMd8 Encoder with enhanced features
+      #
+      # Encodes using PPMd8 model with restoration methods,
+      # run-length encoding, and improved update algorithms.
+      class Encoder
+        include PPMdBase::BaseConstants
+        include Constants
+
+        attr_reader :model
+
+        # Initialize the encoder
+        #
+        # @param output [IO] Output stream for compressed data
+        # @param options [Hash] Encoding options
+        # @option options [Integer] :model_order Maximum context order
+        # @option options [Integer] :mem_size Memory size for model
+        # @option options [Integer] :restore_method Restoration method
+        def initialize(output, options = {})
+          @output = output
+          @model = Model.new(
+            options[:model_order] || DEFAULT_ORDER,
+            options[:mem_size] || DEFAULT_MEM_SIZE,
+            options[:restore_method] || DEFAULT_RESTORE_METHOD,
+          )
+          @range_encoder = LZMA::RangeEncoder.new(output)
+        end
+
+        # Encode a stream of bytes
+        #
+        # @param input [IO] Input stream to compress
+        # @return [void]
+        # @raise [NotImplementedError] PPMd8 is not yet fully implemented
+        def encode_stream(input)
+          raise NotImplementedError,
+                "PPMd8 compression is not yet fully implemented. " \
+                "The arithmetic coding integration requires completion. " \
+                "Please use PPMd7 or other compression algorithms instead."
+        end
+
+        private
+
+        # Encode a single symbol
+        #
+        # @param symbol [Integer] The byte to encode (0-255)
+        # @return [void]
+        def encode_symbol(symbol)
+          prob = @model.get_symbol_probability(symbol)
+
+          encode_range(
+            prob[:cumulative_freq],
+            prob[:freq],
+            prob[:total_freq],
+          )
+
+          encode_with_escape(symbol) if prob[:escape]
+
+          @model.update(symbol)
+        end
+
+        # Encode with escape handling
+        #
+        # @param symbol [Integer] Symbol to encode
+        # @return [void]
+        def encode_with_escape(symbol)
+          root_prob = get_root_probability(symbol)
+          encode_range(
+            root_prob[:cumulative_freq],
+            root_prob[:freq],
+            root_prob[:total_freq],
+          )
+        end
+
+        # Get probability from root context
+        #
+        # @param symbol [Integer] Symbol to look up
+        # @return [Hash] Probability information
+        def get_root_probability(symbol)
+          context = @model.root_context
+          state = context.find_symbol(symbol)
+
+          cum_freq = 0
+          context.states.each do |sym, st|
+            break if sym >= symbol
+
+            cum_freq += st.freq
+          end
+
+          {
+            cumulative_freq: cum_freq,
+            freq: state.freq,
+            total_freq: context.total_freq,
+          }
+        end
+
+        # Encode a range for the symbol
+        #
+        # @param cum_freq [Integer] Cumulative frequency
+        # @param freq [Integer] Symbol frequency
+        # @param total_freq [Integer] Total frequency
+        # @return [void]
+        def encode_range(cum_freq, _freq, total_freq)
+          scale = 0x10000
+          low = (cum_freq * scale) / total_freq
+
+          @range_encoder.encode_direct_bits(low, 16)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/ppmd8/model.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require_relative "constants"
+require_relative "context"
+require_relative "restoration_method"
+
+module Omnizip
+  module Algorithms
+    class PPMd8 < PPMdBase
+      # PPMd8 prediction model with enhanced features
+      #
+      # Extends the basic PPMd model with:
+      # - Restoration methods (RESTART/CUT_OFF)
+      # - Run-length encoding for repetitions
+      # - Enhanced update algorithms
+      # - Glue count tracking for memory management
+      class Model
+        include PPMdBase::BaseConstants
+        include Constants
+
+        attr_reader :max_order, :root_context, :current_context,
+                    :restoration_method, :run_length, :glue_count
+        attr_accessor :order_fall, :prev_success
+
+        # Initialize the PPMd8 model
+        #
+        # @param max_order [Integer] Maximum context order (2-16)
+        # @param mem_size [Integer] Memory size for context allocation
+        # @param restore_method [Integer] Restoration method type
+        def initialize(
+          max_order = DEFAULT_ORDER,
+          mem_size = DEFAULT_MEM_SIZE,
+          restore_method = DEFAULT_RESTORE_METHOD
+        )
+          validate_parameters(max_order, mem_size)
+
+          @max_order = max_order
+          @mem_size = mem_size
+          @restoration_method = RestorationMethod.new(restore_method)
+
+          # PPMd8-specific state
+          @run_length = 0
+          @init_rl = 0
+          @glue_count = 0
+          @order_fall = max_order
+          @prev_success = 0
+
+          # Initialize context tree
+          @root_context = Context.new(-1, nil)
+          @current_context = @root_context
+          @context_history = []
+
+          initialize_root_context
+        end
+
+        # Get probability information for a symbol
+        #
+        # @param symbol [Integer, nil] Symbol to encode (nil for decode)
+        # @return [Hash] Probability information
+        def get_symbol_probability(symbol = nil)
+          context = find_context_with_symbol(symbol)
+
+          if context && (state = context.find_symbol(symbol))
+            build_symbol_probability(context, state, symbol)
+          else
+            build_escape_probability(context || @root_context)
+          end
+        end
+
+        # Update model after encoding/decoding a symbol
+        #
+        # PPMd8 uses more sophisticated update algorithms
+        #
+        # @param symbol [Integer] The symbol that was encoded/decoded
+        # @return [void]
+        def update(symbol)
+          update_run_length(symbol)
+          update_context_statistics(symbol)
+          update_current_context(symbol)
+          check_memory_restoration
+        end
+
+        # Reset model to initial state
+        #
+        # @return [void]
+        def reset
+          @root_context = Context.new(-1, nil)
+          @current_context = @root_context
+          @context_history.clear
+          @run_length = 0
+          @glue_count = 0
+          @order_fall = @max_order
+          @prev_success = 0
+          initialize_root_context
+        end
+
+        # Cut off old contexts to free memory (CUT_OFF restoration)
+        #
+        # @return [void]
+        def cut_off_old_contexts
+          # Simplified implementation - would traverse and prune
+          # contexts based on usage statistics
+          @glue_count = 0
+        end
+
+        private
+
+        # Validate initialization parameters
+        def validate_parameters(max_order, mem_size)
+          unless max_order.between?(MIN_ORDER, MAX_ORDER)
+            raise ArgumentError,
+                  "max_order must be between #{MIN_ORDER} and #{MAX_ORDER}"
+          end
+
+          return if mem_size.between?(MIN_MEM_SIZE, MAX_MEM_SIZE)
+
+          raise ArgumentError,
+                "mem_size must be between #{MIN_MEM_SIZE} and " \
+                "#{MAX_MEM_SIZE}"
+        end
+
+        # Initialize root context
+        def initialize_root_context
+          ALPHABET_SIZE.times do |symbol|
+            @root_context.add_symbol(symbol, 1)
+          end
+        end
+
+        # Build probability hash for found symbol
+        def build_symbol_probability(context, state, symbol)
+          cum_freq = cumulative_frequency(context, symbol)
+          {
+            context: context,
+            cumulative_freq: cum_freq,
+            freq: state.freq,
+            total_freq: context.total_freq,
+            escape: false,
+          }
+        end
+
+        # Build probability hash for escape
+        def build_escape_probability(context)
+          cum_freq = escape_cumulative_frequency(context)
+          {
+            context: context,
+            cumulative_freq: cum_freq,
+            freq: context.escape_freq,
+            total_freq: context.total_freq,
+            escape: true,
+          }
+        end
+
+        # Update run-length counter (PPMd8 feature)
+        def update_run_length(_symbol)
+          if @run_length.positive?
+            @run_length += 1
+          else
+            @run_length = 1
+          end
+        end
+
+        # Update context statistics
+        def update_context_statistics(symbol)
+          if @current_context.find_symbol(symbol)
+            @current_context.update_symbol(symbol)
+          else
+            @current_context.add_symbol(symbol)
+          end
+        end
+
+        # Check if memory restoration is needed
+        def check_memory_restoration
+          return unless @root_context.needs_restoration?
+
+          @restoration_method.restore(self)
+        end
+
+        # Find context containing symbol
+        def find_context_with_symbol(symbol)
+          return nil if symbol.nil?
+
+          context = @current_context
+          while context
+            return context if context.find_symbol(symbol)
+
+            context = context.suffix
+          end
+
+          nil
+        end
+
+        # Calculate cumulative frequency
+        def cumulative_frequency(context, symbol)
+          cum_freq = 0
+          context.states.each do |sym, state|
+            break if sym >= symbol
+
+            cum_freq += state.freq
+          end
+          cum_freq
+        end
+
+        # Calculate escape cumulative frequency
+        def escape_cumulative_frequency(context)
+          context.sum_freq
+        end
+
+        # Update current context
+        def update_current_context(symbol)
+          @context_history.push(symbol)
+          @context_history.shift if @context_history.size > @max_order
+          @current_context = find_or_create_context(@context_history)
+        end
+
+        # Find or create context
+        def find_or_create_context(sequence)
+          return @root_context if sequence.empty?
+
+          context = @root_context
+          sequence.each_with_index do |_symbol, index|
+            suffix = index.zero? ? @root_context : context
+            context = Context.new(index, suffix)
+          end
+
+          context
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/ppmd8/restoration_method.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Algorithms
+    class PPMd8 < PPMdBase
+      # Strategy pattern for PPMd8 restoration methods
+      #
+      # PPMd8 supports multiple restoration methods that determine
+      # how the model handles memory management and context updating
+      # when memory is exhausted.
+      class RestorationMethod
+        include Constants
+
+        attr_reader :method_type
+
+        # Initialize restoration method
+        #
+        # @param method_type [Integer] The restoration method type
+        def initialize(method_type = RESTORE_METHOD_RESTART)
+          @method_type = method_type
+        end
+
+        # Execute restoration based on the selected method
+        #
+        # @param model [Model] The PPMd8 model to restore
+        # @return [void]
+        def restore(model)
+          case @method_type
+          when RESTORE_METHOD_RESTART
+            restart_restoration(model)
+          when RESTORE_METHOD_CUT_OFF
+            cut_off_restoration(model)
+          else
+            raise ArgumentError, "Unknown restoration method: #{@method_type}"
+          end
+        end
+
+        private
+
+        # RESTART method: Reinitialize the model from scratch
+        #
+        # @param model [Model] The model to restore
+        # @return [void]
+        def restart_restoration(model)
+          model.reset
+        end
+
+        # CUT_OFF method: Remove older contexts to free memory
+        #
+        # @param model [Model] The model to restore
+        # @return [void]
+        def cut_off_restoration(model)
+          model.cut_off_old_contexts
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/ppmd8.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require_relative "ppmd_base"
+require_relative "ppmd8/constants"
+require_relative "ppmd8/restoration_method"
+require_relative "ppmd8/context"
+require_relative "ppmd8/model"
+require_relative "ppmd8/encoder"
+require_relative "ppmd8/decoder"
+
+module Omnizip
+  module Algorithms
+    # PPMd8 (PPMdI) compression algorithm
+    #
+    # PPMd8 is an improved variant of PPMd7 that adds:
+    # - Multiple restoration methods (RESTART, CUT_OFF)
+    # - Enhanced memory management with glue counting
+    # - Improved context update algorithms
+    # - Run-length encoding support for better repetition handling
+    #
+    # This implementation follows the PPMd8 specification from 7-Zip.
+    class PPMd8 < PPMdBase
+      include Constants
+
+      # Algorithm metadata
+      #
+      # @return [AlgorithmMetadata] Metadata describing this algorithm
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |m|
+          m.name = "ppmd8"
+          m.description = "PPMd8 (PPMdI) - Enhanced Prediction by " \
+                          "Partial Matching with improved restoration"
+          m.version = "1.0.0"
+          m.supports_streaming = true
+        end
+      end
+
+      protected
+
+      # Create PPMd8 encoder
+      #
+      # @param output [IO] Output stream
+      # @param options [Hash] Encoding options
+      # @return [PPMd8::Encoder] Encoder instance
+      def create_encoder(output, options)
+        PPMd8::Encoder.new(output, options)
+      end
+
+      # Create PPMd8 decoder
+      #
+      # @param input [IO] Input stream
+      # @param options [Hash] Decoding options
+      # @return [PPMd8::Decoder] Decoder instance
+      def create_decoder(input, options)
+        PPMd8::Decoder.new(input, options)
+      end
+    end
+  end
+end
+
+# Register algorithm with registry
+Omnizip::AlgorithmRegistry.register(:ppmd8, Omnizip::Algorithms::PPMd8)

data/lib/omnizip/algorithms/ppmd_base.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require_relative "../algorithm"
+
+module Omnizip
+  module Algorithms
+    # Base class for PPMd (Prediction by Partial Matching) algorithms
+    #
+    # This abstract base class provides common functionality for PPMd
+    # variants (PPMd7, PPMd8, etc.) while allowing each variant to
+    # implement its specific features.
+    #
+    # The design follows the Template Method pattern, where common
+    # operations are defined here and variant-specific operations
+    # are delegated to subclasses.
+    class PPMdBase < Algorithm
+      # Common constants for all PPMd variants
+      module BaseConstants
+        # Context order limits
+        MIN_ORDER = 2
+        MAX_ORDER = 16
+        DEFAULT_ORDER = 6
+
+        # Memory allocation
+        MIN_MEM_SIZE = 1 << 20  # 1 MB
+        MAX_MEM_SIZE = 1 << 30  # 1 GB
+        DEFAULT_MEM_SIZE = 1 << 24 # 16 MB
+
+        # Alphabet
+        ALPHABET_SIZE = 256
+
+        # Range coder constants
+        TOP_VALUE = 1 << 24
+        BOT_VALUE = 1 << 15
+      end
+
+      include BaseConstants
+
+      # Compress data using PPMd variant
+      #
+      # @param input [IO, String] Input data to compress
+      # @param output [IO, String] Output for compressed data
+      # @param options [Hash] Compression options
+      # @return [void]
+      def compress(input, output, options = {})
+        input = prepare_input(input)
+        output = prepare_output(output)
+
+        encoder = create_encoder(output, options)
+        encoder.encode_stream(input)
+      end
+
+      # Decompress data using PPMd variant
+      #
+      # @param input [IO, String] Compressed input data
+      # @param output [IO, String] Output for decompressed data
+      # @param options [Hash] Decompression options
+      # @return [void]
+      def decompress(input, output, options = {})
+        input = prepare_input(input)
+        output = prepare_output(output)
+
+        decoder = create_decoder(input, options)
+        result = decoder.decode_stream
+
+        output.write(result)
+      end
+
+      protected
+
+      # Template method for creating encoder
+      # Subclasses must implement this
+      #
+      # @param output [IO] Output stream
+      # @param options [Hash] Encoding options
+      # @return [Object] Encoder instance
+      # @raise [NotImplementedError] if not implemented by subclass
+      def create_encoder(output, options)
+        raise NotImplementedError,
+              "#{self.class} must implement #create_encoder"
+      end
+
+      # Template method for creating decoder
+      # Subclasses must implement this
+      #
+      # @param input [IO] Input stream
+      # @param options [Hash] Decoding options
+      # @return [Object] Decoder instance
+      # @raise [NotImplementedError] if not implemented by subclass
+      def create_decoder(input, options)
+        raise NotImplementedError,
+              "#{self.class} must implement #create_decoder"
+      end
+
+      private
+
+      # Prepare input for processing
+      #
+      # @param input [IO, String] Input data
+      # @return [IO] IO object ready for reading
+      def prepare_input(input)
+        return input if input.is_a?(IO)
+
+        StringIO.new(input.to_s)
+      end
+
+      # Prepare output for processing
+      #
+      # @param output [IO, String, nil] Output destination
+      # @return [IO] IO object ready for writing
+      def prepare_output(output)
+        return output if output.is_a?(IO)
+
+        StringIO.new(String.new(encoding: Encoding::BINARY))
+      end
+    end
+  end
+end