omnizip 0.4.7-arm-linux

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

@@ -0,0 +1,74 @@
+# 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
+      # Constants for PPMd7 algorithm
+      #
+      # PPMd7 uses context-based statistical compression with
+      # maximum context orders typically ranging from 2 to 16.
+      module Constants
+        # Maximum context order (model order)
+        MAX_ORDER = 16
+        MIN_ORDER = 2
+        DEFAULT_ORDER = 6
+
+        # Memory allocation constants
+        MIN_MEM_SIZE = 1 << 20  # 1 MB minimum
+        MAX_MEM_SIZE = 1 << 30  # 1 GB maximum
+        DEFAULT_MEM_SIZE = 1 << 24 # 16 MB default
+
+        # Probability scaling factors
+        PROB_TOTAL = 2048
+        MAX_FREQ = 124
+        INIT_ESCAPE_FREQ = 1
+
+        # Symbol alphabet size
+        ALPHABET_SIZE = 256
+
+        # Context node structure sizes
+        UNIT_SIZE = 12
+
+        # Maximum number of states per context
+        MAX_STATES = 256
+
+        # Escape symbol handling
+        SEE_CONTEXTS = 25
+        SUFFIX_CONTEXTS = 32
+
+        # Update intervals for probability models
+        INT_BITS = 7
+        PERIOD_BITS = 7
+        BIN_SCALE = 1 << 13
+        INTERVAL = 1 << INT_BITS
+
+        # Memory unit allocation
+        UNIT_ALLOC_SIZE = 12
+
+        # Range coder constants (inherited from arithmetic coding)
+        TOP_VALUE = 1 << 24
+        BOT_VALUE = 1 << 15
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# 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 context node in the PPMd7 model
+      #
+      # A context in PPMd is a sequence of symbols that have appeared
+      # previously. Each context tracks the symbols that have followed
+      # it and their frequencies. This forms a tree structure where
+      # each node represents a different context.
+      #
+      # The context uses symbol states to track:
+      # - Which symbols have appeared after this context
+      # - How frequently each symbol has appeared
+      # - Escape probabilities for unknown symbols
+      class Context
+        include Constants
+
+        attr_reader :order, :suffix, :states, :sum_freq
+        attr_accessor :escape_freq
+
+        # Initialize a new context
+        #
+        # @param order [Integer] The order of this context (depth in tree)
+        # @param suffix [Context, nil] Parent context (shorter context)
+        def initialize(order, suffix = nil)
+          @order = order
+          @suffix = suffix
+          @states = {} # symbol => SymbolState
+          @sum_freq = 0
+          @escape_freq = INIT_ESCAPE_FREQ
+        end
+
+        # Find a symbol state in this context
+        #
+        # @param symbol [Integer] The symbol to find (0-255)
+        # @return [SymbolState, nil] The state if found, nil otherwise
+        def find_symbol(symbol)
+          @states[symbol]
+        end
+
+        # Add a new symbol to this context
+        #
+        # This is called when a symbol appears for the first time
+        # after this context.
+        #
+        # @param symbol [Integer] The symbol to add (0-255)
+        # @param freq [Integer] Initial frequency (default: 1)
+        # @return [SymbolState] The newly created state
+        def add_symbol(symbol, freq = 1)
+          raise ArgumentError, "Symbol already exists" if @states[symbol]
+
+          state = SymbolState.new(symbol, freq)
+          @states[symbol] = state
+          @sum_freq += freq
+          state
+        end
+
+        # Update symbol frequency after encoding/decoding
+        #
+        # Increases the frequency count for the symbol and updates
+        # the total frequency sum for this context.
+        #
+        # @param symbol [Integer] The symbol to update
+        # @param increment [Integer] Amount to increase frequency
+        # @return [void]
+        def update_symbol(symbol, increment = 1)
+          state = @states[symbol]
+          return unless state
+
+          state.freq += increment
+          @sum_freq += increment
+          rescale_frequencies if @sum_freq > MAX_FREQ
+        end
+
+        # Get total frequency including escape
+        #
+        # @return [Integer] Total frequency for probability calculation
+        def total_freq
+          @sum_freq + @escape_freq
+        end
+
+        # Check if context needs escape (has unseen symbols)
+        #
+        # @return [Boolean] True if escape symbol is needed
+        def needs_escape?
+          @states.size < ALPHABET_SIZE
+        end
+
+        # Get all symbols in order of frequency
+        #
+        # @return [Array<Integer>] Symbols sorted by frequency (desc)
+        def symbols_by_frequency
+          @states.values.sort_by { |s| -s.freq }.map(&:symbol)
+        end
+
+        # Check if this is a root context
+        #
+        # @return [Boolean] True if this has no suffix (order 0)
+        def root?
+          @suffix.nil?
+        end
+
+        # Get the number of distinct symbols in this context
+        #
+        # @return [Integer] Number of symbols tracked
+        def num_symbols
+          @states.size
+        end
+
+        private
+
+        # Rescale frequencies when they grow too large
+        #
+        # This prevents arithmetic overflow and maintains reasonable
+        # probability distributions. Divides all frequencies by 2
+        # while maintaining minimum frequency of 1.
+        #
+        # @return [void]
+        def rescale_frequencies
+          @sum_freq = 0
+          @states.each_value do |state|
+            state.freq = [(state.freq + 1) / 2, 1].max
+            @sum_freq += state.freq
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# 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
+      # PPMd7 Decoder using range coding
+      #
+      # Decodes a stream that was compressed with PPMd7 encoder.
+      # Maintains synchronized model state with the encoder.
+      class Decoder
+        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
+        def initialize(input, options = {})
+          @input = input
+          @model = Model.new(
+            options[:model_order] || Model::DEFAULT_ORDER,
+            options[:mem_size] || Model::DEFAULT_MEM_SIZE,
+          )
+          @range_decoder = LZMA::RangeDecoder.new(input)
+        end
+
+        # Decode a stream back to original bytes
+        #
+        # Reads compressed data, decodes using PPMd7 model,
+        # and returns the original data.
+        #
+        # @return [String] Decoded data
+        def decode_stream
+          result = String.new(encoding: Encoding::BINARY)
+
+          # Simplified decoding - in practice would need proper
+          # stream termination handling
+          100.times do
+            symbol = decode_symbol
+            break if symbol.nil?
+
+            result << symbol.chr
+          end
+
+          result
+        end
+
+        private
+
+        # Decode a single symbol using the model
+        #
+        # Uses the model and range decoder to extract the
+        # original symbol value using proper range decoding.
+        #
+        # @return [Integer, nil] Decoded byte or nil if end
+        def decode_symbol
+          # Get context for decoding
+          context = @model.root_context
+          total_freq = context.total_freq
+
+          return nil if total_freq.zero?
+
+          # Decode cumulative frequency using proper range decoding
+          cum_freq_value = @range_decoder.decode_freq(total_freq)
+
+          # Find symbol from cumulative frequency value
+          symbol, cum_freq, freq = find_symbol_from_cum_freq(context,
+                                                             cum_freq_value)
+          return nil if symbol.nil?
+
+          # Normalize the range decoder state
+          @range_decoder.normalize_freq(cum_freq, freq, total_freq)
+
+          # Update model to stay in sync with encoder
+          @model.update(symbol)
+
+          symbol
+        end
+
+        # Find symbol from cumulative frequency value
+        #
+        # Maps the decoded cumulative frequency back to a symbol
+        # using the context's probability distribution.
+        #
+        # @param context [Context] The current context
+        # @param cum_freq_value [Integer] Decoded cumulative frequency
+        # @return [Array<Integer, Integer, Integer>] symbol, cum_freq, freq
+        def find_symbol_from_cum_freq(context, cum_freq_value)
+          cum_freq = 0
+
+          context.states.keys.sort.each do |symbol|
+            state = context.states[symbol]
+            freq = state.freq
+            next_cum = cum_freq + freq
+
+            return [symbol, cum_freq, freq] if cum_freq_value < next_cum
+
+            cum_freq = next_cum
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# 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
+      # PPMd7 Encoder using range coding
+      #
+      # Encodes a stream of bytes using the PPMd7 prediction
+      # model combined with range encoding for arithmetic coding.
+      class Encoder
+        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
+        def initialize(output, options = {})
+          @output = output
+          @model = Model.new(
+            options[:model_order] || Model::DEFAULT_ORDER,
+            options[:mem_size] || Model::DEFAULT_MEM_SIZE,
+          )
+          @range_encoder = LZMA::RangeEncoder.new(output)
+        end
+
+        # Encode a stream of bytes
+        #
+        # Reads from input, compresses using PPMd7 model,
+        # and writes to output stream.
+        #
+        # @param input [IO] Input stream to compress
+        # @return [void]
+        def encode_stream(input)
+          while (byte = input.getbyte)
+            encode_symbol(byte)
+          end
+
+          # Flush encoder
+          @range_encoder.flush
+        end
+
+        private
+
+        # Encode a single symbol using the model
+        #
+        # Uses the model to get probability information and
+        # encodes using range coding. Handles escapes if symbol
+        # is not in current context.
+        #
+        # @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],
+          )
+          if prob[:escape]
+            # Encode escape and try shorter context
+            # Recursively encode in shorter context
+            encode_with_escape(symbol)
+          else
+            # Encode symbol directly
+          end
+
+          # Update model
+          @model.update(symbol)
+        end
+
+        # Encode with escape handling
+        #
+        # When a symbol isn't in the current context, we encode
+        # an escape and retry with a shorter context.
+        #
+        # @param symbol [Integer] Symbol to encode
+        # @return [void]
+        def encode_with_escape(symbol)
+          # Try encoding in root context (always succeeds)
+          # This is a simplified version - full PPMd would
+          # walk through progressively shorter contexts
+          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
+        #
+        # The root context always contains all symbols.
+        #
+        # @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
+        #
+        # Uses proper range coding to encode the symbol based on
+        # its frequency distribution in the current context.
+        #
+        # @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)
+          # Use proper range encoding (not direct bits)
+          @range_encoder.encode_freq(cum_freq, freq, total_freq)
+        end
+      end
+    end
+  end
+end