omnizip 0.3.1

data/lib/omnizip/algorithms/lzma/match_finder_factory.rb

@@ -0,0 +1,88 @@
+# 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 "match_finder_config"
+require_relative "match_finder"
+require_relative "../../implementations/seven_zip/lzma/match_finder"
+
+module Omnizip
+  module Algorithms
+    class LZMA < Algorithm
+      # Factory for creating Match Finder instances
+      #
+      # This factory implements the Factory pattern to create different
+      # match finder implementations based on configuration. It provides
+      # a clean separation between the configuration (what) and the
+      # implementation (how).
+      #
+      # @example Creating an SDK-compatible match finder
+      #   config = MatchFinderConfig.sdk_config(dict_size: 65536, level: 5)
+      #   finder = MatchFinderFactory.create(config)
+      #
+      # @example Creating a simplified match finder
+      #   config = MatchFinderConfig.simplified_config(dict_size: 65536)
+      #   finder = MatchFinderFactory.create(config)
+      class MatchFinderFactory
+        # Create a match finder instance based on configuration
+        #
+        # @param config [MatchFinderConfig] Configuration object
+        # @return [MatchFinder, Implementations::SevenZip::LZMA::MatchFinder] Match finder instance
+        # @raise [ArgumentError] if configuration is invalid
+        def self.create(config)
+          config.validate!
+
+          case config.mode
+          when "sdk"
+            Implementations::SevenZip::LZMA::MatchFinder.new(config)
+          when "simplified"
+            # Use original MatchFinder for backward compatibility
+            MatchFinder.new(config.window_size, config.max_match_length)
+          else
+            raise ArgumentError, "Unknown match finder mode: #{config.mode}"
+          end
+        end
+
+        # Create match finder from options hash (convenience method)
+        #
+        # @param options [Hash] Options hash
+        # @option options [Boolean] :sdk_compatible Use SDK mode
+        # @option options [Integer] :dict_size Dictionary size
+        # @option options [Integer] :level Compression level
+        # @return [MatchFinder, Implementations::SevenZip::LZMA::MatchFinder] Match finder instance
+        def self.from_options(options = {})
+          config = if options[:sdk_compatible]
+                     MatchFinderConfig.sdk_config(
+                       dict_size: options[:dict_size] || 65536,
+                       level: options[:level] || 5,
+                     )
+                   else
+                     MatchFinderConfig.simplified_config(
+                       dict_size: options[:dict_size] || 65536,
+                     )
+                   end
+
+          create(config)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma/optimal_encoder.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    class LZMA < Algorithm
+      # Optimal encoder - chooses best encoding
+      # Ported from lzma_encoder_optimum_fast.c
+      class OptimalEncoder
+        attr_reader :mode
+
+        def initialize(mode: :fast)
+          @mode = mode
+        end
+
+        # Find optimal encoding for current position
+        def find_optimal(position, match_finder, state, reps, models)
+          case @mode
+          when :fast
+            optimum_fast(position, match_finder, state, reps, models)
+          else
+            raise ArgumentError, "Unknown mode: #{@mode}"
+          end
+        end
+
+        private
+
+        # TODO: position, state, reps, and models parameters will be used
+        # when implementing normal mode for more optimal encoding decisions
+        def optimum_fast(position, match_finder, _state, reps, _models)
+          buf = match_finder.buffer # CRITICAL: Use match_finder.buffer, NOT dictionary.buffer!
+          buf_pos = position
+          buf_avail = [buf.bytesize - buf_pos, MATCH_LEN_MAX].min
+
+          # puts "[OPTIMUM] position=#{position} buf_avail=#{buf_avail} buf.bytesize=#{buf.bytesize}" if ENV['DEBUG']
+
+          # Not enough input for a match
+          return [UINT32_MAX, 1] if buf_avail < 2
+
+          # CRITICAL: Check repeated matches FIRST (before normal matches)
+          # This matches XZ Utils lzma_lzma_optimum_fast behavior
+          rep_len = 0
+          rep_index = 0
+
+          # For level 9, nice_len = MATCH_LEN_MAX = 273
+          nice_len = MATCH_LEN_MAX
+
+          # Look for repeated matches; scan the previous four match distances
+          reps.each_with_index do |rep_dist, i|
+            # Pointer to the beginning of the match candidate
+            # In XZ: buf_back = buf - coder->reps[i] - 1
+            # In Ruby: buf_back_index = buf_pos - rep_dist - 1
+            buf_back_index = buf_pos - rep_dist - 1
+
+            # DEBUG: Trace repeated match check
+            # puts "[OPTIMAL] Checking rep#{i}: rep_dist=#{rep_dist} buf_pos=#{buf_pos} buf_back_index=#{buf_back_index}" if ENV['DEBUG']
+
+            # Skip if out of bounds
+            next if buf_back_index.negative? || buf_back_index >= buf.bytesize
+
+            # puts "[OPTIMAL] buf[#{buf_pos}]=#{'%02x' % buf.getbyte(buf_pos)} buf[#{buf_back_index}]=#{'%02x' % buf.getbyte(buf_back_index)}" if ENV['DEBUG']
+
+            # If the first two bytes (2 == MATCH_LEN_MIN) do not match,
+            # this rep is not useful.
+            next if buf.getbyte(buf_pos) != buf.getbyte(buf_back_index) ||
+              buf.getbyte(buf_pos + 1) != buf.getbyte(buf_back_index + 1)
+
+            # The first two bytes matched. Calculate the length of the match.
+            len = 2
+            while (buf_pos + len < buf.bytesize) &&
+                (buf_back_index + len < buf.bytesize) &&
+                (buf.getbyte(buf_pos + len) == buf.getbyte(buf_back_index + len)) &&
+                (len < MATCH_LEN_MAX) &&
+                (len < buf_avail)
+              len += 1
+            end
+
+            # If we have found a repeated match that is at least
+            # nice_len long, return it immediately.
+            if len >= nice_len
+              # Return rep index (0-3 for rep0-rep3)
+              return [i, len]
+            end
+
+            if len > rep_len
+              rep_index = i
+              rep_len = len
+            end
+          end
+
+          # Find normal matches from match finder
+          matches = match_finder.find_matches(position)
+
+          # We didn't find a long enough repeated match.
+          # Encode it as a normal match if the match length is at least nice_len
+          # AND the match distance is within the dictionary buffer.
+          best_normal = matches.max_by { |m| [m.length, m.distance] }
+
+          if best_normal && best_normal.length >= nice_len &&
+              best_normal.distance <= match_finder.dictionary.buffer.bytesize
+            # CRITICAL: Only use normal match if distance is within actual dictionary buffer
+            # This prevents invalid matches that reference bytes not yet written to dictionary
+            # Use normal match
+            return [best_normal.distance + REPS, best_normal.length]
+          end
+
+          # Compare best rep match vs best normal match
+          # Prefer longer match, for equal length prefer rep match (XZ behavior)
+          if rep_len >= 2 && rep_len >= (best_normal&.length || 0)
+            # Use repeated match
+            [rep_index, rep_len]
+          elsif best_normal && best_normal.distance <= match_finder.dictionary.buffer.bytesize
+            # CRITICAL: Only use normal match if distance is within actual dictionary buffer
+            # Use dictionary.buffer.bytesize (actual data), NOT dictionary.size (max capacity)
+            # This prevents invalid matches that reference bytes not yet written to dictionary
+            [best_normal.distance + REPS, best_normal.length]
+          else
+            # Use literal - return UINT32_MAX to indicate literal (not 0!)
+            [UINT32_MAX, 1]
+          end
+        end
+
+        # Constants
+        REPS = 4
+        MATCH_LEN_MAX = 273 # From lzma.h
+        MATCH_LEN_MIN = 2
+        UINT32_MAX = 0xFFFFFFFF
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma/probability_models.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    class LZMA < Algorithm
+      # Container for all LZMA probability models
+      # Ported from lzma_encoder_private.h
+      class ProbabilityModels
+        # Constants
+        STATES = 12
+        POS_STATES_MAX = 16
+        LEN_LOW_SYMBOLS = 8
+        LEN_MID_SYMBOLS = 8
+        LEN_HIGH_SYMBOLS = 16
+        LEN_SYMBOLS = 272
+        MATCH_LEN_MIN = 2
+        MATCH_LEN_MAX = 273
+        DIST_STATES = 4
+        DIST_SLOTS = 64
+        DIST_MODEL_START = 4
+        DIST_MODEL_END = 14
+        FULL_DISTANCES = 128
+        ALIGN_SIZE = 16
+
+        attr_accessor :literal, :is_match, :is_rep,
+                      :is_rep0, :is_rep1, :is_rep2, :is_rep0_long,
+                      :dist_slot, :dist_special, :dist_align,
+                      :match_len_encoder, :rep_len_encoder
+
+        def initialize(lc: 3, lp: 0, pb: 2)
+          @lc = lc
+          @lp = lp
+          @pb = pb
+
+          @literal = init_literal_models
+          @is_match = init_is_match_models
+          @is_rep = init_array(STATES, BitModel)
+          @is_rep0 = init_array(STATES, BitModel)
+          @is_rep1 = init_array(STATES, BitModel)
+          @is_rep2 = init_array(STATES, BitModel)
+          @is_rep0_long = init_is_rep0_long_models
+          @dist_slot = init_dist_slot_models
+          @dist_special = init_array(FULL_DISTANCES - DIST_MODEL_END, BitModel)
+          @dist_align = init_array(ALIGN_SIZE, BitModel)
+        end
+
+        private
+
+        def init_literal_models
+          num_contexts = 1 << (@lc + @lp)
+          Array.new(num_contexts * 0x300) { BitModel.new }
+        end
+
+        def init_is_match_models
+          Array.new(STATES * (1 << @pb)) { BitModel.new }
+        end
+
+        def init_is_rep0_long_models
+          Array.new(STATES * (1 << @pb)) { BitModel.new }
+        end
+
+        def init_dist_slot_models
+          Array.new(DIST_STATES * DIST_SLOTS) { BitModel.new }
+        end
+
+        def init_array(size, _model_class)
+          Array.new(size) { BitModel.new }
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma/range_coder.rb

@@ -0,0 +1,85 @@
+# 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 "bit_model"
+
+module Omnizip
+  module Algorithms
+    class LZMA < Algorithm
+      # Base class for range encoding and decoding
+      #
+      # This class provides the core arithmetic coding functionality
+      # used by both the encoder and decoder. Range coding is a form
+      # of arithmetic coding that uses integer arithmetic to represent
+      # probability ranges.
+      #
+      # The algorithm maintains a range [low, high) and subdivides it
+      # based on symbol probabilities. The range is periodically
+      # normalized to prevent arithmetic overflow/underflow.
+      class RangeCoder
+        include Constants
+
+        attr_reader :range, :low
+
+        # Initialize the range coder
+        #
+        # @param stream [IO] The input or output stream
+        def initialize(stream)
+          @stream = stream
+          @range = 0xFFFFFFFF
+          @low = 0
+        end
+
+        protected
+
+        # Normalize the range when it becomes too small
+        #
+        # This is an abstract method to be implemented by subclasses.
+        # The encoder and decoder have different normalization logic.
+        #
+        # @return [void]
+        def normalize
+          raise NotImplementedError,
+                "#{self.class} must implement #normalize"
+        end
+
+        # Create an array of bit models for probability management
+        #
+        # @param size [Integer] Number of bit models to create
+        # @return [Array<BitModel>] Array of initialized bit models
+        def create_bit_models(size)
+          Array.new(size) { BitModel.new }
+        end
+
+        # Get a bit model from an array based on index
+        #
+        # @param models [Array<BitModel>] Array of bit models
+        # @param index [Integer] Index to retrieve
+        # @return [BitModel] The bit model at the specified index
+        def get_bit_model(models, index)
+          models[index] ||= BitModel.new
+        end
+      end
+    end
+  end
+end