omnizip 0.4.7-aarch64-linux

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    class LZMA < Algorithm
+      # LZMA State Machine
+      # Ported from XZ Utils lzma_common.h and lzma_decoder.c
+      class LZMAState
+        # State transition table (from lzma_decoder.c)
+        TRANSITIONS = {
+          # Literal after literal (matches XZ Utils update_literal macro)
+          update_literal: {
+            0 => 0, 1 => 0, 2 => 0, 3 => 0, 4 => 1, 5 => 2,
+            6 => 3, 7 => 4, 8 => 5, 9 => 6, 10 => 4, 11 => 5
+          }.freeze,
+
+          # Matched literal (literal after match, matches XZ Utils update_literal_matched macro)
+          # Only called when previous state was NOT a literal (states 7-11)
+          update_literal_matched: {
+            0 => 0, 1 => 0, 2 => 0, 3 => 0, 4 => 1, 5 => 2,
+            6 => 3, 7 => 4, 8 => 5, 9 => 6, 10 => 4, 11 => 5
+          }.freeze,
+
+          # Regular match
+          update_match: {
+            0 => 7, 1 => 7, 2 => 7, 3 => 7, 4 => 7, 5 => 7,
+            6 => 7, 7 => 10, 8 => 10, 9 => 10, 10 => 10, 11 => 10
+          }.freeze,
+
+          # Repeat match
+          update_rep: {
+            0 => 8, 1 => 8, 2 => 8, 3 => 8, 4 => 8, 5 => 8,
+            6 => 8, 7 => 11, 8 => 11, 9 => 11, 10 => 11, 11 => 11
+          }.freeze,
+
+          # Short repeat (length=1)
+          update_short_rep: {
+            0 => 9, 1 => 9, 2 => 9, 3 => 9, 4 => 9, 5 => 9,
+            6 => 9, 7 => 11, 8 => 11, 9 => 11, 10 => 11, 11 => 11
+          }.freeze,
+
+          # Long repeat (length>1)
+          # Ported from XZ Utils: state < LIT_STATES ? STATE_LIT_LONGREP : STATE_NONLIT_REP
+          # where LIT_STATES=7, STATE_LIT_LONGREP=8, STATE_NONLIT_REP=11
+          update_long_rep: {
+            0 => 8, 1 => 8, 2 => 8, 3 => 8, 4 => 8, 5 => 8,
+            6 => 8, 7 => 11, 8 => 11, 9 => 11, 10 => 11, 11 => 11
+          }.freeze,
+        }.freeze
+
+        attr_reader :value, :reps
+
+        def initialize(value = 0)
+          @value = value
+          @reps = [0, 0, 0, 0] # Initial repeat distances (matches XZ Utils)
+        end
+
+        # After encoding a literal
+        def update_literal!
+          @value = if use_matched_literal?
+                     TRANSITIONS[:update_literal_matched][@value]
+                   else
+                     TRANSITIONS[:update_literal][@value]
+                   end
+        end
+
+        # After encoding a regular match
+        def update_match!(distance)
+          @value = TRANSITIONS[:update_match][@value]
+          rotate_reps!(distance)
+        end
+
+        # After encoding a repeat match
+        def update_rep!(rep_index)
+          @value = TRANSITIONS[:update_rep][@value]
+          rotate_reps_for_rep!(rep_index)
+        end
+
+        # After encoding a short rep (length=1)
+        def update_short_rep!
+          @value = TRANSITIONS[:update_short_rep][@value]
+        end
+
+        # After encoding a long rep (length>1)
+        # Ported from XZ Utils update_long_rep macro
+        def update_long_rep!
+          @value = TRANSITIONS[:update_long_rep][@value]
+        end
+
+        # Check if we should use matched literal encoding
+        # XZ Utils logic: is_literal_state(state) = (state < LIT_STATES)
+        # where LIT_STATES = 7
+        # States 0-6: literal states (use unmatched literal)
+        # States 7-11: non-literal states (use matched literal)
+        def use_matched_literal?
+          @value >= 7
+        end
+
+        # Repeat distance rotation
+        def rotate_reps!(distance)
+          @reps[3] = @reps[2]
+          @reps[2] = @reps[1]
+          @reps[1] = @reps[0]
+          @reps[0] = distance
+        end
+
+        private
+
+        def rotate_reps_for_rep!(rep_index)
+          case rep_index
+          when 0
+            # Keep rep0, no rotation
+          when 1
+            # rep1 -> rep0
+            @reps[0], @reps[1] = @reps[1], @reps[0]
+          when 2
+            # rep2 -> rep0, rep0 -> rep1, rep1 -> rep2
+            @reps[0], @reps[1], @reps[2] = @reps[2], @reps[0], @reps[1]
+          when 3
+            # rep3 -> rep0, rotate others
+            @reps[0], @reps[1], @reps[2], @reps[3] =
+              @reps[3], @reps[0], @reps[1], @reps[2]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    class LZMA < Algorithm
+      # Match candidate result from LZ77 match finding
+      class Match
+        attr_reader :distance, :length
+
+        def initialize(distance, length)
+          @distance = distance
+          @length = length
+        end
+
+        # Check if match is valid for given dictionary size
+        #
+        # @param dict_size [Integer] Dictionary size in bytes
+        # @return [Boolean] true if match is valid
+        def valid?(dict_size)
+          @distance <= dict_size && @length >= 2
+        end
+
+        # String representation for debugging
+        #
+        # @return [String] Match description
+        def to_s
+          "Match(dist=#{@distance}, len=#{@length})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,233 @@
+# 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 LZMA < Algorithm
+      # Match Finder using hash chain algorithm for LZ77 compression
+      # Ported from XZ Utils lz_encoder.c
+      class MatchFinder
+        # Larger hash table for better distribution
+        # 16384 slots with 4-byte keys gives better collision resistance
+        HASH_SIZE = 16384
+        HASH_MASK = HASH_SIZE - 1
+        MAX_MATCHES = 274
+        # Maximum hash chain depth to prevent O(n) lookups
+        # XZ Utils uses different values based on compression level (4-256)
+        # Ruby needs much lower values due to slower string operations
+        # Testing shows depth 16 gives same compression ratio as 32-64 but 2-3x faster
+        DEFAULT_CHAIN_DEPTH = 16
+
+        attr_reader :dictionary, :buffer, :position
+
+        def initialize(dictionary, chain_depth: DEFAULT_CHAIN_DEPTH)
+          @dictionary = dictionary
+          @buffer = String.new(encoding: Encoding::BINARY)
+          @position = 0
+          @chain_depth = chain_depth
+          # Use nil as empty marker (not 0) to distinguish from position 0
+          @hash_table = Array.new(HASH_SIZE, nil)
+          @hash_chain = Array.new(0)
+          @matches = Array.new(MAX_MATCHES)
+          @matches_count = 0
+        end
+
+        # Add input data for processing
+        #
+        # @param data [String] Binary data to add
+        # @return [void]
+        def feed(data)
+          @buffer << data
+        end
+
+        # Reset the match finder state for a new encoding session
+        # Clears the buffer, hash table, and hash chain
+        def reset
+          @buffer.clear
+          @position = 0
+          @hash_table = Array.new(HASH_SIZE, nil)
+          @hash_chain.clear
+          @matches_count = 0
+        end
+
+        # Initialize hash table for all positions up to end_pos
+        # This is called before encoding starts to ensure the hash table
+        # is populated for all positions. Matches XZ Utils "skip" behavior.
+        #
+        # @param end_pos [Integer] Last position to initialize (inclusive)
+        # @return [void]
+        def skip(end_pos)
+          pos = 0
+          while pos + 3 <= @buffer.bytesize && pos <= end_pos
+            hash = calc_hash(@buffer, pos)
+            if hash
+              @hash_chain[pos] = @hash_table[hash]
+              @hash_table[hash] = pos
+            end
+            pos += 1
+          end
+        end
+
+        # Find matches for current position
+        #
+        # @param current_pos [Integer] Position to find matches at (defaults to end)
+        # @return [Array<Match>] Array of matches sorted by length (descending)
+        def find_matches(current_pos = @buffer.bytesize - 273)
+          # Calculate hash for current position
+          # Note: Using 4-byte hash now (calc_hash checks pos + 4)
+          hash = nil
+          if current_pos >= 0 && current_pos + 4 <= @buffer.bytesize
+            hash = calc_hash(@buffer, current_pos)
+          end
+
+          # Skip hash table update here - skip() already built the table for all positions
+          # Adding current_pos to the chain is redundant since skip processed all positions
+
+          # Can't find matches if no hash or insufficient data
+          # Note: We CAN find matches at early positions (e.g., position 2 can match position 0)
+          # The only requirement is that there's enough data for hash calculation (current_pos + 4 <= buffer size)
+          # and that there's at least 2 bytes of history (for MIN_MATCH_LENGTH=2)
+          # CRITICAL: Don't produce matches until position >= 2 to ensure decoder has enough dict_full
+          # The decoder validates: dict_full > distance, where dict_full starts at 0 after 1st byte
+          # For distance=1 match to be valid, decoder needs dict_full >= 2 (at least 2 bytes decoded)
+          # This happens after processing position 1 (first byte was literal at position 0)
+          # So we can only produce matches starting at position 2
+          return [] if hash.nil? || @buffer.bytesize < 4 || current_pos + 4 > @buffer.bytesize || current_pos < 2
+
+          @matches_count = 0
+          chain_pos = @hash_chain[current_pos]
+          chain_depth = 0
+
+          while chain_pos && @matches_count < MAX_MATCHES && chain_depth < @chain_depth
+            chain_depth += 1
+            # CRITICAL: Skip invalid chain_pos values (beyond buffer or negative)
+            next if chain_pos >= @buffer.bytesize || chain_pos.negative?
+
+            distance = current_pos - chain_pos
+            # CRITICAL: Break if distance is negative (chain_pos > current_pos)
+            # This can happen when skip() links positions within the same chunk
+            # where a later position has the same hash as an earlier position
+            break if distance.negative? || distance > @dictionary.size || distance.zero?
+
+            length = verify_match(current_pos, chain_pos)
+
+            if length >= 2
+              @matches[@matches_count] = Match.new(distance, length)
+              @matches_count += 1
+            end
+
+            # Safely get next chain position
+            chain_pos = if chain_pos < @hash_chain.size
+                          @hash_chain[chain_pos]
+                        end
+          end
+
+          @matches.first(@matches_count).sort_by { |m| -m.length }
+        end
+
+        # Get the longest match at current position
+        #
+        # @return [Match, nil] Longest match found or nil
+        def longest_match
+          find_matches.first
+        end
+
+        # Legacy API: Find longest match at given position in external byte array
+        # This is a compatibility method for older code that passes bytes and position
+        #
+        # @param bytes [Array<Integer>] Byte array
+        # @param pos [Integer] Position to find match at
+        # @return [Match, nil] Longest match found or nil
+        def find_longest_match(bytes, pos)
+          # If position is beyond current buffer, feed more data
+          if pos >= @buffer.bytesize
+            bytes_to_feed = bytes[pos..]
+            @buffer << bytes_to_feed.pack("C*")
+          end
+
+          # Find matches at the given position
+          matches = find_matches(pos)
+          matches.first
+        end
+
+        private
+
+        # Calculate hash for position using 4-byte key with mixing
+        # Uses FNV-1a inspired mixing for better distribution
+        #
+        # @param data [String] Buffer data
+        # @param pos [Integer] Position to hash
+        # @return [Integer] Hash value
+        def calc_hash(data, pos)
+          return 0 if pos + 4 > data.bytesize
+
+          # Read 4 bytes as 32-bit integer (little-endian)
+          v = data.getbyte(pos) |
+            (data.getbyte(pos + 1) << 8) |
+            (data.getbyte(pos + 2) << 16) |
+            (data.getbyte(pos + 3) << 24)
+
+          # FNV-1a style mixing for better distribution
+          # Hash avalanche: each input bit affects all output bits
+          v = (v ^ (v >> 16)) * 0x45D9F3B
+          v = (v ^ (v >> 16)) * 0x45D9F3B
+          (v ^ (v >> 16)) & HASH_MASK
+        end
+
+        # Verify match length between two positions
+        # Uses 4-byte quick check then binary search with integer comparison
+        #
+        # @param pos1 [Integer] First position
+        # @param pos2 [Integer] Second position
+        # @return [Integer] Match length
+        def verify_match(pos1, pos2)
+          buf = @buffer
+          max_len = [273, buf.bytesize - pos1, buf.bytesize - pos2].min
+          return 0 if max_len <= 0
+
+          # Quick rejection: check first 4 bytes as integer
+          if max_len >= 4
+            v1 = buf.byteslice(pos1, 4).unpack1("L<")
+            v2 = buf.byteslice(pos2, 4).unpack1("L<")
+            return 0 if v1 != v2
+          end
+
+          # Binary search for exact match length
+          # Creates O(log n) strings but does efficient integer comparison
+          low = 0
+          high = max_len
+
+          while low < high
+            mid = (low + high + 1) / 2
+            if buf.byteslice(pos1, mid) == buf.byteslice(pos2, mid)
+              low = mid
+            else
+              high = mid - 1
+            end
+          end
+
+          low
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# 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 LZMA < Algorithm
+      # Configuration model for Match Finder behavior
+      #
+      # This model separates configuration from implementation, allowing
+      # different match finding strategies (SDK-compatible vs simplified)
+      # to be configured declaratively.
+      #
+      # @example SDK-compatible configuration
+      #   config = MatchFinderConfig.new(
+      #     mode: :sdk,
+      #     hash_size: 65536,
+      #     chain_length: 32,
+      #     lazy_matching: false
+      #   )
+      #
+      # @example Simplified configuration
+      #   config = MatchFinderConfig.new(
+      #     mode: :simplified,
+      #     hash_size: 65536,
+      #     chain_length: 1024
+      #   )
+      class MatchFinderConfig
+        attr_accessor :mode, :hash_size, :chain_length, :search_mode,
+                      :lazy_matching, :max_match_length, :window_size
+
+        def initialize(mode: "simplified", hash_size: 65_536,
+                       chain_length: 1024, search_mode: "hash_chain",
+                       lazy_matching: false, max_match_length: 273,
+                       window_size: 65_536)
+          @mode = mode
+          @hash_size = hash_size
+          @chain_length = chain_length
+          @search_mode = search_mode
+          @lazy_matching = lazy_matching
+          @max_match_length = max_match_length
+          @window_size = window_size
+        end
+
+        # Validate configuration
+        #
+        # @return [Boolean] true if valid
+        # @raise [ArgumentError] if configuration is invalid
+        def validate!
+          unless %w[sdk simplified].include?(mode)
+            raise ArgumentError, "mode must be :sdk or :simplified"
+          end
+
+          unless %w[hash_chain binary_tree].include?(search_mode)
+            raise ArgumentError,
+                  "search_mode must be :hash_chain or :binary_tree"
+          end
+
+          raise ArgumentError, "hash_size must be positive" if hash_size <= 0
+
+          if chain_length <= 0
+            raise ArgumentError,
+                  "chain_length must be positive"
+          end
+          if max_match_length < 2
+            raise ArgumentError,
+                  "max_match_length must be >= 2"
+          end
+          if window_size <= 0
+            raise ArgumentError,
+                  "window_size must be positive"
+          end
+
+          true
+        end
+
+        # Create SDK-compatible configuration
+        #
+        # @param dict_size [Integer] Dictionary size
+        # @param level [Integer] Compression level (0-9)
+        # @return [MatchFinderConfig] SDK-compatible configuration
+        def self.sdk_config(dict_size: 65536, level: 5)
+          # SDK uses different parameters based on dictionary size and level
+          hash_size = dict_size >= (1 << 20) ? (1 << 20) : (1 << 16)
+
+          # SDK nice_len varies by compression level:
+          # Level 0-4: 32, Level 5-6: 64, Level 7-8: 128, Level 9: 273
+          chain_length = case level
+                         when 0..4 then 32
+                         when 5..6 then 64
+                         when 7..8 then 128
+                         else 273
+                         end
+
+          new(
+            mode: "sdk",
+            hash_size: hash_size,
+            chain_length: chain_length,
+            search_mode: "hash_chain",
+            lazy_matching: level >= 7, # Enable lazy matching for high compression
+            max_match_length: 273,
+            window_size: dict_size,
+          )
+        end
+
+        # Create simplified configuration with sensible defaults.
+        #
+        # @param dict_size [Integer] Dictionary size
+        # @return [MatchFinderConfig] Simplified configuration
+        def self.simplified_config(dict_size: 65536)
+          new(
+            mode: "simplified",
+            hash_size: 65536,
+            chain_length: 1024,
+            search_mode: "hash_chain",
+            lazy_matching: false,
+            max_match_length: 273,
+            window_size: dict_size,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# 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 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 simplified MatchFinder implementation
+            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