omnizip 0.4.7-arm-linux

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

@@ -0,0 +1,245 @@
+# 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 PPMd7 < Algorithm
+      # Core PPMd7 prediction model
+      #
+      # The model maintains a tree of contexts, where each context
+      # represents a sequence of symbols that have appeared in the
+      # input. The model predicts the next symbol based on the
+      # current context's statistics.
+      #
+      # The model uses Prediction by Partial Matching (PPM), which
+      # tries progressively shorter contexts until it finds one
+      # that has seen the current symbol before.
+      class Model
+        include Constants
+
+        attr_reader :max_order, :root_context, :current_context, :mem_size
+
+        # Initialize the PPMd7 model
+        #
+        # @param max_order [Integer] Maximum context order (2-16)
+        # @param mem_size [Integer] Memory size for context allocation
+        def initialize(max_order = DEFAULT_ORDER, mem_size = DEFAULT_MEM_SIZE)
+          validate_parameters(max_order, mem_size)
+
+          @max_order = max_order
+          @mem_size = mem_size
+
+          # Initialize context tree with root (order -1)
+          @root_context = Context.new(-1, nil)
+          @current_context = @root_context
+
+          # Context history for maintaining context chain
+          @context_history = []
+
+          # Initialize root context with uniform distribution
+          initialize_root_context
+        end
+
+        # Get probability information for encoding/decoding a symbol
+        #
+        # Returns information needed by range coder:
+        # - cumulative frequency up to symbol
+        # - symbol frequency
+        # - total frequency
+        # - whether this is an escape
+        #
+        # @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))
+            # Symbol found in context
+            cum_freq = cumulative_frequency(context, symbol)
+            {
+              context: context,
+              cumulative_freq: cum_freq,
+              freq: state.freq,
+              total_freq: context.total_freq,
+              escape: false,
+            }
+          else
+            # Use escape symbol
+            cum_freq = escape_cumulative_frequency(context || @root_context)
+            {
+              context: context || @root_context,
+              cumulative_freq: cum_freq,
+              freq: (context || @root_context).escape_freq,
+              total_freq: (context || @root_context).total_freq,
+              escape: true,
+            }
+          end
+        end
+
+        # Update model after encoding/decoding a symbol
+        #
+        # This updates context statistics and creates new contexts
+        # as needed.
+        #
+        # @param symbol [Integer] The symbol that was encoded/decoded
+        # @return [void]
+        def update(symbol)
+          # Update current context or create new symbol
+          if @current_context.find_symbol(symbol)
+            @current_context.update_symbol(symbol)
+          else
+            @current_context.add_symbol(symbol)
+          end
+
+          # Move to next context
+          update_current_context(symbol)
+        end
+
+        # Reset model to initial state
+        #
+        # @return [void]
+        def reset
+          @root_context = Context.new(-1, nil)
+          @current_context = @root_context
+          @context_history.clear
+          initialize_root_context
+        end
+
+        private
+
+        # Validate initialization parameters
+        #
+        # @param max_order [Integer] Maximum context order
+        # @param mem_size [Integer] Memory size
+        # @return [void]
+        # @raise [ArgumentError] If parameters are invalid
+        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 with all possible symbols
+        #
+        # The root context (order -1) contains all 256 possible
+        # byte values with equal frequency. This ensures we can
+        # always encode any symbol.
+        #
+        # @return [void]
+        def initialize_root_context
+          ALPHABET_SIZE.times do |symbol|
+            @root_context.add_symbol(symbol, 1)
+          end
+        end
+
+        # Find context that contains the given symbol
+        #
+        # Searches from current context up through suffixes until
+        # finding one that has seen this symbol, or reaching root.
+        #
+        # @param symbol [Integer, nil] Symbol to find
+        # @return [Context, nil] Context containing symbol or nil
+        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 up to (but not including) symbol
+        #
+        # @param context [Context] The context
+        # @param symbol [Integer] The symbol
+        # @return [Integer] 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 cumulative frequency for escape symbol
+        #
+        # The escape symbol comes after all regular symbols in the
+        # frequency range.
+        #
+        # @param context [Context] The context
+        # @return [Integer] Cumulative frequency for escape
+        def escape_cumulative_frequency(context)
+          context.sum_freq
+        end
+
+        # Update current context after processing a symbol
+        #
+        # This maintains the context chain, creating new contexts
+        # as needed to extend the order.
+        #
+        # @param symbol [Integer] Symbol that was processed
+        # @return [void]
+        def update_current_context(symbol)
+          # Add to context history
+          @context_history.push(symbol)
+
+          # Limit history to max order
+          @context_history.shift if @context_history.size > @max_order
+
+          # Find or create context for new history
+          @current_context = find_or_create_context(@context_history)
+        end
+
+        # Find or create a context for the given symbol sequence
+        #
+        # @param sequence [Array<Integer>] Sequence of symbols
+        # @return [Context] The context for this sequence
+        def find_or_create_context(sequence)
+          return @root_context if sequence.empty?
+
+          # Start from root and build up context chain
+          context = @root_context
+          sequence.each_with_index do |_symbol, index|
+            suffix = index.zero? ? @root_context : context
+            order = index
+            context = Context.new(order, suffix)
+          end
+
+          context
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/ppmd7/symbol_state.rb

@@ -0,0 +1,57 @@
+# 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 PPMd7 < Algorithm
+      # Represents a symbol's state within a context
+      #
+      # Each symbol that appears after a context has an associated
+      # state that tracks its frequency. This is used to calculate
+      # the probability of each symbol appearing next.
+      class SymbolState
+        attr_reader :symbol
+        attr_accessor :freq
+
+        # Initialize a new symbol state
+        #
+        # @param symbol [Integer] The symbol value (0-255)
+        # @param freq [Integer] Initial frequency (default: 1)
+        def initialize(symbol, freq = 1)
+          @symbol = symbol
+          @freq = freq
+        end
+
+        # Get the probability of this symbol
+        #
+        # The probability is proportional to the frequency.
+        # This is used by the range coder to encode/decode.
+        #
+        # @param total_freq [Integer] Total frequency in context
+        # @return [Float] Probability (0.0 to 1.0)
+        def probability(total_freq)
+          @freq.to_f / total_freq
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/ppmd7.rb

@@ -0,0 +1,146 @@
+# 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 "stringio"
+
+module Omnizip
+  module Algorithms
+    # PPMd7 compression algorithm
+    #
+    # PPMd (Prediction by Partial Matching) is a statistical compression
+    # algorithm that excels at text compression. It uses context-based
+    # prediction to achieve high compression ratios on text files.
+    #
+    # This implementation follows the PPMd7 specification as used in 7-Zip.
+    class PPMd7 < Algorithm
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/algorithms/ppmd7/constants"
+      autoload :SymbolState, "omnizip/algorithms/ppmd7/symbol_state"
+      autoload :Context, "omnizip/algorithms/ppmd7/context"
+      autoload :Model, "omnizip/algorithms/ppmd7/model"
+      autoload :Encoder, "omnizip/algorithms/ppmd7/encoder"
+      autoload :Decoder, "omnizip/algorithms/ppmd7/decoder"
+
+      # Cross-namespace dependencies - autoloaded
+      autoload :RangeDecoder, "omnizip/algorithms/lzma/range_decoder"
+      autoload :RangeEncoder, "omnizip/algorithms/lzma/range_encoder"
+
+      include Constants
+
+      # Algorithm metadata
+      #
+      # @return [AlgorithmMetadata] Metadata describing this algorithm
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |m|
+          m.name = "ppmd7"
+          m.description = "PPMd7 - Prediction by Partial Matching " \
+                          "for statistical text compression"
+          m.version = "1.0.0"
+          m.supports_streaming = true
+        end
+      end
+
+      # Compress data using PPMd7
+      #
+      # @param input [IO, String] Input data to compress
+      # @param output [IO, String] Output for compressed data
+      # @param options [Hash] Compression options
+      # @option options [Integer] :model_order Context order (2-16)
+      # @option options [Integer] :mem_size Memory size
+      # @return [void]
+      def compress(input, output, options = {})
+        input = prepare_input(input)
+        output = prepare_output(output)
+        data = input.read
+        order = options[:model_order] || PPMd7::Model::DEFAULT_ORDER
+        mem = options[:mem_size] || PPMd7::Model::DEFAULT_MEM_SIZE
+
+        # The tier is the authority: Rust's PPMd (the reference-grade
+        # port) frames order/size in-band; params travel in the codec
+        # name. The pure-Ruby core cannot round-trip its own output
+        # beyond ~100 bytes (its decoder reads root-only) — it stays
+        # only as the no-dylib fallback.
+        output.write(
+          Backends.compress("ppmd7:o#{order}:m#{mem}", data, order) do
+            encoder = PPMd7::Encoder.new(output, options)
+            encoder.encode_stream(StringIO.new(data))
+            nil
+          end,
+        )
+      end
+
+      # Decompress data using PPMd7
+      #
+      # @param input [IO, String] Compressed input data
+      # @param output [IO, String] Output for decompressed data
+      # @param options [Hash] Decompression options
+      # @option options [Integer] :model_order Context order (2-16)
+      # @option options [Integer] :mem_size Memory size
+      # @return [void]
+      def decompress(input, output, options = {})
+        input = prepare_input(input)
+        output = prepare_output(output)
+        compressed = input.read
+        order = options[:model_order] || PPMd7::Model::DEFAULT_ORDER
+        mem = options[:mem_size] || PPMd7::Model::DEFAULT_MEM_SIZE
+
+        result = Backends.decompress(
+          "ppmd7:o#{order}:m#{mem}", compressed, Backends::UNKNOWN_LENGTH
+        ) do
+          decoder = PPMd7::Decoder.new(StringIO.new(compressed), options)
+          decoder.decode_stream
+        end
+        output.write(result)
+      end
+
+      private
+
+      # Prepare input for processing
+      #
+      # @param input [IO, String] Input data
+      # @return [IO] IO object ready for reading
+      def prepare_input(input)
+        # StringIO is not an ::IO, and its #to_s is Kernel's (the
+        # INSPECT string) — pass anything readable straight through.
+        return input if input.respond_to?(:read) # allowed: IO-duck detection — StringIO must pass through (its #to_s is the INSPECT string)
+
+        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)
+        # StringIO is NOT an ::IO subclass — the old check discarded
+        # it for a fresh buffer, silently dropping every class-level
+        # compress's output.
+        return output if output.is_a?(IO) || output.is_a?(StringIO)
+
+        StringIO.new(String.new(encoding: Encoding::BINARY))
+      end
+    end
+  end
+end
+
+# Register algorithm with registry
+Omnizip::AlgorithmRegistry.register(:ppmd7, Omnizip::Algorithms::PPMd7)

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

@@ -0,0 +1,61 @@
+# 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
+      # Constants specific to PPMd8 algorithm
+      #
+      # PPMd8 adds restoration methods and enhanced memory management
+      # compared to PPMd7.
+      module Constants
+        # Restoration method constants
+        RESTORE_METHOD_RESTART = 0
+        RESTORE_METHOD_CUT_OFF = 1
+        DEFAULT_RESTORE_METHOD = RESTORE_METHOD_RESTART
+
+        # Probability scaling factors
+        PROB_TOTAL = 2048
+        MAX_FREQ = 124
+        INIT_ESCAPE_FREQ = 1
+
+        # Context management
+        SEE_CONTEXTS = 25
+        SUFFIX_CONTEXTS = 32
+
+        # Update intervals
+        INT_BITS = 7
+        PERIOD_BITS = 7
+        BIN_SCALE = 1 << 13
+        INTERVAL = 1 << INT_BITS
+
+        # Memory management
+        UNIT_SIZE = 12
+        MAX_STATES = 256
+        UNIT_ALLOC_SIZE = 12
+
+        # PPMd8-specific: glue counting threshold
+        GLUE_COUNT_THRESHOLD = 255
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+module Omnizip
+  module Algorithms
+    class PPMd8 < PPMdBase
+      # PPMd8 Context - Enhanced version with Union types
+      #
+      # Represents a context node in the PPMd8 model tree.
+      # PPMd8 uses optimized memory layout with Union types.
+      class Context < PPMd7::Context
+        include Constants
+
+        attr_accessor :num_stats, :flags, :sum_freq, :glue_count
+
+        def initialize(order, suffix)
+          super
+          @num_stats = 0
+          @flags = 0
+          @sum_freq = 0
+          @glue_count = 0
+        end
+
+        # PPMd8-specific: Check if context needs memory restoration
+        def needs_restoration?
+          @glue_count >= GLUE_COUNT_THRESHOLD
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# 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
+      # PPMd8 Decoder
+      #
+      # Decodes streams compressed with PPMd8, maintaining
+      # synchronized model state with the encoder.
+      class Decoder
+        include PPMdBase::BaseConstants
+        include Constants
+
+        attr_reader :model
+
+        # Initialize the decoder
+        #
+        # @param input [IO] Input stream of compressed data
+        # @param options [Hash] Decoding 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(input, options = {})
+          @input = input
+          @model = Model.new(
+            options[:model_order] || DEFAULT_ORDER,
+            options[:mem_size] || DEFAULT_MEM_SIZE,
+            options[:restore_method] || DEFAULT_RESTORE_METHOD,
+          )
+          @range_decoder = LZMA::RangeDecoder.new(input)
+        end
+
+        # Decode a stream back to original bytes
+        #
+        # @return [String] Decoded data
+        # @raise [NotImplementedError] PPMd8 is not yet fully implemented
+        def decode_stream
+          raise NotImplementedError,
+                "PPMd8 decompression is not yet fully implemented. " \
+                "The arithmetic coding integration requires completion. " \
+                "Please use PPMd7 or other compression algorithms instead."
+        end
+
+        private
+
+        # Decode a single symbol
+        #
+        # @return [Integer, nil] Decoded byte or nil if end
+        def decode_symbol
+          value = @range_decoder.decode_direct_bits(16)
+          symbol = find_symbol_from_range(value)
+          return nil if symbol.nil?
+
+          @model.update(symbol)
+          symbol
+        end
+
+        # Find symbol from decoded range value
+        #
+        # @param value [Integer] Decoded range value
+        # @return [Integer, nil] The symbol
+        def find_symbol_from_range(value)
+          context = @model.root_context
+
+          scale = 0x10000
+          cum_freq = 0
+
+          context.states.keys.sort.each do |symbol|
+            state = context.states[symbol]
+            next_cum = cum_freq + state.freq
+            sym_low = (cum_freq * scale) / context.total_freq
+            sym_high = (next_cum * scale) / context.total_freq
+
+            return symbol if value >= sym_low && value < sym_high
+
+            cum_freq = next_cum
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end